Switch to absolute imports

Author: croneter

addon.xml

@@ -3,8 +3,8 @@
   <requires>
     <import addon="xbmc.python" version="2.1.0"/>
     <import addon="script.module.requests" version="2.9.1" />
-    <import addon="plugin.video.plexkodiconnect.movies" version="2.0.4" />
-    <import addon="plugin.video.plexkodiconnect.tvshows" version="2.0.4" />
+    <import addon="plugin.video.plexkodiconnect.movies" version="2.0.5" />
+    <import addon="plugin.video.plexkodiconnect.tvshows" version="2.0.5" />
   </requires>
   <extension point="xbmc.python.pluginsource" library="default.py">
         <provides>video audio image</provides>

default.py

@@ -1,47 +1,19 @@
 # -*- coding: utf-8 -*-
 
 ###############################################################################
-from __future__ import unicode_literals  # nice to fix os.walk unicode
+from __future__ import absolute_import, division, unicode_literals
 import logging
-from os import path as os_path
-from sys import path as sys_path, argv
+from sys import argv
 from urlparse import parse_qsl
-
-from xbmc import translatePath, sleep, executebuiltin
-from xbmcaddon import Addon
+from xbmc import sleep, executebuiltin
 from xbmcgui import ListItem
 from xbmcplugin import setResolvedUrl
 
-_addon = Addon(id='plugin.video.plexkodiconnect')
-try:
-    _addon_path = _addon.getAddonInfo('path').decode('utf-8')
-except TypeError:
-    _addon_path = _addon.getAddonInfo('path').decode()
-try:
-    _base_resource = translatePath(os_path.join(
-        _addon_path,
-        'resources',
-        'lib')).decode('utf-8')
-except TypeError:
-    _base_resource = translatePath(os_path.join(
-        _addon_path,
-        'resources',
-        'lib')).decode()
-sys_path.append(_base_resource)
+from resources.lib import entrypoint, utils, pickler, pkc_listitem, \
+    variables as v, loghandler
 
 ###############################################################################
 
-import entrypoint
-from utils import window, reset, passwords_xml, language as lang, dialog, \
-    plex_command
-from pickler import unpickle_me, pickl_window
-from PKC_listitem import convert_PKC_to_listitem
-import variables as v
-
-###############################################################################
-
-import loghandler
-
 loghandler.config()
 log = logging.getLogger('PLEX.default')
 
@@ -104,7 +76,7 @@ def __init__(self):
             entrypoint.create_new_pms()
 
         elif mode == 'reset':
-            reset()
+            utils.reset()
 
         elif mode == 'togglePlexTV':
             entrypoint.toggle_plex_tv_sign_in()
@@ -113,41 +85,41 @@ def __init__(self):
             entrypoint.reset_authorization()
 
         elif mode == 'passwords':
-            passwords_xml()
+            utils.passwords_xml()
 
         elif mode == 'switchuser':
             entrypoint.switch_plex_user()
 
         elif mode in ('manualsync', 'repair'):
-            if window('plex_online') != 'true':
+            if pickler.pickl_window('plex_online') != 'true':
                 # Server is not online, do not run the sync
-                dialog('ok', lang(29999), lang(39205))
+                utils.dialog('ok', utils.lang(29999), utils.lang(39205))
                 log.error('Not connected to a PMS.')
             else:
                 if mode == 'repair':
                     log.info('Requesting repair lib sync')
-                    plex_command('RUN_LIB_SCAN', 'repair')
+                    utils.plex_command('RUN_LIB_SCAN', 'repair')
                 elif mode == 'manualsync':
                     log.info('Requesting full library scan')
-                    plex_command('RUN_LIB_SCAN', 'full')
+                    utils.plex_command('RUN_LIB_SCAN', 'full')
 
         elif mode == 'texturecache':
             log.info('Requesting texture caching of all textures')
-            plex_command('RUN_LIB_SCAN', 'textures')
+            utils.plex_command('RUN_LIB_SCAN', 'textures')
 
         elif mode == 'chooseServer':
             entrypoint.choose_pms_server()
 
         elif mode == 'refreshplaylist':
             log.info('Requesting playlist/nodes refresh')
-            plex_command('RUN_LIB_SCAN', 'views')
+            utils.plex_command('RUN_LIB_SCAN', 'views')
 
         elif mode == 'deviceid':
             self.deviceid()
 
         elif mode == 'fanart':
             log.info('User requested fanarttv refresh')
-            plex_command('RUN_LIB_SCAN', 'fanart')
+            utils.plex_command('RUN_LIB_SCAN', 'fanart')
 
         elif '/extrafanart' in argv[0]:
             plexpath = argv[2][1:]
@@ -171,40 +143,40 @@ def play():
         """
         request = '%s&handle=%s' % (argv[2], HANDLE)
         # Put the request into the 'queue'
-        plex_command('PLAY', request)
+        utils.plex_command('PLAY', request)
         if HANDLE == -1:
             # Handle -1 received, not waiting for main thread
             return
         # Wait for the result
-        while not pickl_window('plex_result'):
+        while not pickler.pickl_window('plex_result'):
             sleep(50)
-        result = unpickle_me()
+        result = pickler.unpickle_me()
         if result is None:
             log.error('Error encountered, aborting')
-            dialog('notification',
-                   heading='{plex}',
-                   message=lang(30128),
-                   icon='{error}',
-                   time=3000)
+            utils.dialog('notification',
+                         heading='{plex}',
+                         message=utils.lang(30128),
+                         icon='{error}',
+                         time=3000)
             setResolvedUrl(HANDLE, False, ListItem())
         elif result.listitem:
-            listitem = convert_PKC_to_listitem(result.listitem)
+            listitem = pkc_listitem.convert_pkc_to_listitem(result.listitem)
             setResolvedUrl(HANDLE, True, listitem)
 
     @staticmethod
     def deviceid():
-        deviceId_old = window('plex_client_Id')
+        deviceId_old = pickler.pickl_window('plex_client_Id')
         from clientinfo import getDeviceId
         try:
             deviceId = getDeviceId(reset=True)
         except Exception as e:
             log.error('Failed to generate a new device Id: %s' % e)
-            dialog('ok', lang(29999), lang(33032))
+            utils.dialog('ok', utils.lang(29999), utils.lang(33032))
         else:
             log.info('Successfully removed old device ID: %s New deviceId:'
                      '%s' % (deviceId_old, deviceId))
             # 'Kodi will now restart to apply the changes'
-            dialog('ok', lang(29999), lang(33033))
+            utils.dialog('ok', utils.lang(29999), utils.lang(33033))
             executebuiltin('RestartApp')
 
 

resources/lib/PKC_listitem.py

@@ -3,11 +3,11 @@
 from xbmcgui import ListItem
 
 
-def convert_PKC_to_listitem(PKC_listitem):
+def convert_pkc_to_listitem(pkc_listitem):
     """
-    Insert a PKC_listitem and you will receive a valid XBMC listitem
+    Insert a PKCListItem() and you will receive a valid XBMC listitem
     """
-    data = PKC_listitem.data
+    data = pkc_listitem.data
     listitem = ListItem(label=data.get('label'),
                         label2=data.get('label2'),
                         path=data.get('path'))
@@ -26,7 +26,7 @@ def convert_PKC_to_listitem(PKC_listitem):
     return listitem
 
 
-class PKC_ListItem(object):
+class PKCListItem(object):
     """
     Imitates xbmcgui.ListItem and its functions. Pass along PKC_Listitem().data
     when pickling!

resources/lib/artwork.py

@@ -12,18 +12,17 @@
 import xbmc
 from xbmcvfs import exists
 
-from utils import settings, language as lang, kodi_sql, try_encode, try_decode,\
-    thread_methods, dialog, exists_dir
-import state
+from . import utils
+from . import state
 
 ###############################################################################
-LOG = getLogger("PLEX." + __name__)
+LOG = getLogger('PLEX.artwork')
 
 # Disable annoying requests warnings
 requests.packages.urllib3.disable_warnings()
 ARTWORK_QUEUE = Queue()
 IMAGE_CACHING_SUSPENDS = ['SUSPEND_LIBRARY_THREAD', 'DB_SCAN', 'STOP_SYNC']
-if not settings('imageSyncDuringPlayback') == 'true':
+if not utils.settings('imageSyncDuringPlayback') == 'true':
     IMAGE_CACHING_SUSPENDS.append('SUSPEND_SYNC')
 
 ###############################################################################
@@ -37,7 +36,7 @@ def double_urldecode(text):
     return unquote(unquote(text))
 
 
-@thread_methods(add_suspends=IMAGE_CACHING_SUSPENDS)
+@utils.thread_methods(add_suspends=IMAGE_CACHING_SUSPENDS)
 class Image_Cache_Thread(Thread):
     sleep_between = 50
     # Potentially issues with limited number of threads
@@ -73,20 +72,20 @@ def run(self):
                         'Window.IsVisible(DialogAddonSettings.xml)'):
                     # Avoid saving '0' all the time
                     set_zero = True
-                    settings('caching_artwork_count', value='0')
+                    utils.settings('caching_artwork_count', value='0')
                 xbmc.sleep(1000)
                 continue
             set_zero = False
             if isinstance(url, ArtworkSyncMessage):
                 if state.IMAGE_SYNC_NOTIFICATIONS:
-                    dialog('notification',
-                           heading=lang(29999),
-                           message=url.message,
-                           icon='{plex}',
-                           sound=False)
+                    utils.dialog('notification',
+                                 heading=utils.lang(29999),
+                                 message=url.message,
+                                 icon='{plex}',
+                                 sound=False)
                 queue.task_done()
                 continue
-            url = double_urlencode(try_encode(url))
+            url = double_urlencode(utils.try_encode(url))
             sleeptime = 0
             while True:
                 try:
@@ -133,14 +132,15 @@ def run(self):
             if (counter > 20 and not xbmc.getCondVisibility(
                     'Window.IsVisible(DialogAddonSettings.xml)')):
                 counter = 0
-                settings('caching_artwork_count', value=str(queue.qsize()))
+                utils.settings('caching_artwork_count',
+                               value=str(queue.qsize()))
             # Sleep for a bit to reduce CPU strain
             xbmc.sleep(sleep_between)
         LOG.info("---===### Stopped Image_Cache_Thread ###===---")
 
 
 class Artwork():
-    enableTextureCache = settings('enableTextureCache') == "true"
+    enableTextureCache = utils.settings('enableTextureCache') == "true"
     if enableTextureCache:
         queue = ARTWORK_QUEUE
 
@@ -156,15 +156,15 @@ def cache_major_artwork(self):
         artworks = list()
         # Get all posters and fanart/background for video and music
         for kind in ('video', 'music'):
-            connection = kodi_sql(kind)
+            connection = utils.kodi_sql(kind)
             cursor = connection.cursor()
             for typus in ('poster', 'fanart'):
                 cursor.execute('SELECT url FROM art WHERE type == ?',
                                (typus, ))
                 artworks.extend(cursor.fetchall())
             connection.close()
         artworks_to_cache = list()
-        connection = kodi_sql('texture')
+        connection = utils.kodi_sql('texture')
         cursor = connection.cursor()
         for url in artworks:
             query = 'SELECT url FROM texture WHERE url == ? LIMIT 1'
@@ -175,40 +175,41 @@ def cache_major_artwork(self):
         if not artworks_to_cache:
             LOG.info('Caching of major images to Kodi texture cache done')
             # Set to "None"
-            settings('caching_artwork_count', value=lang(30069))
+            utils.settings('caching_artwork_count', value=utils.lang(30069))
             return
         length = len(artworks_to_cache)
         LOG.info('Caching has not been completed - caching %s major images',
                  length)
-        settings('caching_artwork_count', value=str(length))
+        utils.settings('caching_artwork_count', value=str(length))
         # Caching %s Plex images
-        self.queue.put(ArtworkSyncMessage(lang(30006) % length))
+        self.queue.put(ArtworkSyncMessage(utils.lang(30006) % length))
         for i, url in enumerate(artworks_to_cache):
             self.queue.put(url[0])
         # Plex image caching done
-        self.queue.put(ArtworkSyncMessage(lang(30007)))
+        self.queue.put(ArtworkSyncMessage(utils.lang(30007)))
 
     def fullTextureCacheSync(self):
         """
         This method will sync all Kodi artwork to textures13.db
         and cache them locally. This takes diskspace!
         """
-        if not dialog('yesno', "Image Texture Cache", lang(39250)):
+        if not utils.dialog('yesno', "Image Texture Cache", utils.lang(39250)):
             return
 
         LOG.info("Doing Image Cache Sync")
 
         # ask to rest all existing or not
-        if dialog('yesno', "Image Texture Cache", lang(39251)):
+        if utils.dialog('yesno', "Image Texture Cache", utils.lang(39251)):
             LOG.info("Resetting all cache data first")
             # Remove all existing textures first
-            path = try_decode(xbmc.translatePath("special://thumbnails/"))
-            if exists_dir(path):
+            path = utils.try_decode(
+                xbmc.translatePath("special://thumbnails/"))
+            if utils.exists_dir(path):
                 rmtree(path, ignore_errors=True)
                 self.restore_cache_directories()
 
             # remove all existing data from texture DB
-            connection = kodi_sql('texture')
+            connection = utils.kodi_sql('texture')
             cursor = connection.cursor()
             query = 'SELECT tbl_name FROM sqlite_master WHERE type=?'
             cursor.execute(query, ('table', ))
@@ -221,7 +222,7 @@ def fullTextureCacheSync(self):
             connection.close()
 
         # Cache all entries in video DB
-        connection = kodi_sql('video')
+        connection = utils.kodi_sql('video')
         cursor = connection.cursor()
         # dont include actors
         query = "SELECT url FROM art WHERE media_type != ?"
@@ -234,7 +235,7 @@ def fullTextureCacheSync(self):
         for url in result:
             self.cache_texture(url[0])
         # Cache all entries in music DB
-        connection = kodi_sql('music')
+        connection = utils.kodi_sql('music')
         cursor = connection.cursor()
         cursor.execute("SELECT url FROM art")
         result = cursor.fetchall()
@@ -309,7 +310,7 @@ def delete_cached_artwork(url):
         """
         Deleted the cached artwork with path url (if it exists)
         """
-        connection = kodi_sql('texture')
+        connection = utils.kodi_sql('texture')
         cursor = connection.cursor()
         try:
             cursor.execute("SELECT cachedurl FROM texture WHERE url=? LIMIT 1",
@@ -323,7 +324,7 @@ def delete_cached_artwork(url):
             path = xbmc.translatePath("special://thumbnails/%s" % cachedurl)
             LOG.debug("Deleting cached thumbnail: %s", path)
             if exists(path):
-                rmtree(try_decode(path), ignore_errors=True)
+                rmtree(utils.try_decode(path), ignore_errors=True)
             cursor.execute("DELETE FROM texture WHERE url = ?", (url,))
             connection.commit()
         finally:
@@ -336,8 +337,8 @@ def restore_cache_directories():
                  "a", "b", "c", "d", "e", "f",
                  "Video", "plex")
         for path in paths:
-            makedirs(try_decode(xbmc.translatePath("special://thumbnails/%s"
-                                                   % path)))
+            makedirs(utils.try_decode(
+                xbmc.translatePath("special://thumbnails/%s" % path)))
 
 
 class ArtworkSyncMessage(object):