[script.myepisodes] 3.2.0

Author: maximeh

script.myepisodes/addon.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <addon id="script.myepisodes"
        name="MyEpisodes"
-       version="3.0.2"
+       version="3.2.0"
        provider-name="Maxime Hadjinlian">
   <requires>
     <import addon="xbmc.python" version="3.0.0"/>

script.myepisodes/changelog.txt

@@ -1,3 +1,5 @@
+3.2.0
++ Important refactor and bug fixes.
 3.0.2
 + Use "is_alive" instead of "is_Alive" that doesn't exists
 3.0.1

script.myepisodes/default.py

@@ -4,6 +4,7 @@
 import sys
 import threading
 import logging
+from typing import Callable
 
 import xbmc
 import xbmcvfs
@@ -12,7 +13,7 @@
 import utils
 import kodilogging
 
-from myepisodes import MyEpisodes
+from myepisodes import MyEpisodes, SHOW_ID_ERR
 
 _addon = xbmcaddon.Addon()
 _kodiversion = float(xbmcaddon.Addon("xbmc.addon").getAddonInfo("version")[0:4])
@@ -25,90 +26,85 @@
 logger = logging.getLogger(__name__)
 
 
-class MyeMonitor(xbmc.Monitor):
-    def __init__(self, *args, **kwargs):
+class MEMonitor(xbmc.Monitor):
+    def __init__(self, *args: int, **kwargs: Callable) -> None:
         xbmc.Monitor.__init__(self)
         self.action = kwargs["action"]
 
-    def onSettingsChanged(self):
+    def onSettingsChanged(self) -> None:
         logger.debug("User changed settings")
         self.action()
 
 
-def _initMyEpisodes():
-    username = utils.getSetting("Username")
-    password = utils.getSetting("Password")
-
-    login_notif = _language(32912)
-    if not username or not password:
-        utils.notif(login_notif, time=2500)
-        return None
-
-    mye = MyEpisodes(username, password)
-    mye.login()
-    if mye.is_logged:
-        login_notif = f"{username} {_language(32911)}"
-    utils.notif(login_notif, time=2500)
-
-    if mye.is_logged and (not mye.populate_shows()):
-        utils.notif(_language(32927), time=2500)
-    return mye
+class MEProperties:
+    def __init__(self) -> None:
+        self.showid = self.episode = self.season = 0
+        self.title = ""
+        self.is_excluded = False
+        self.total_time = sys.maxsize
+        self.last_pos = 0
 
 
-class MyePlayer(xbmc.Player):
-    def __init__(self):
+class MEPlayer(xbmc.Player):
+    def __init__(self) -> None:
         xbmc.Player.__init__(self)
-        logger.debug("MyePlayer - init")
+        logger.debug("MEPlayer - init")
+        self._tracker = threading.Thread(target=self._track_position)
+        self._reset()
 
-        self.mye = _initMyEpisodes()
+    def _reset(self) -> None:
+        logger.debug("_reset called")
+        self.resetTracker()
+        if hasattr(self, "mye"):
+            del self.mye
+        self.monitor = MEMonitor(action=self._reset)
+        self.props = MEProperties()
+        self._playback_lock = threading.Event()
+        self.mye: MyEpisodes = MEPlayer.initMyEpisodes()
         if not self.mye.is_logged:
             return
-
         logger.debug("MyePlayer - account is logged successfully.")
 
-        self.showid = self.episode = self.title = self.season = None
-        self.is_excluded = False
-        self._total_time = sys.maxsize
-        self._last_pos = 0
-        self._min_percent = utils.getSettingAsInt("watched-percent")
-        self._tracker = None
-        self._playback_lock = threading.Event()
-        self.monitor = MyeMonitor(action=self._reset)
-
-    def _reset(self):
-        logger.debug("_reset called")
-        self.tearDown()
-        if self.mye:
-            del self.mye
-        self.__init__()
-
-    def _trackPosition(self):
-        while self._playback_lock.isSet() and not self.monitor.abortRequested():
-            try:
-                self._last_pos = self.getTime()
-            except:
-                self._playback_lock.clear()
-            logger.debug(f"Tracker time = {self._last_pos}")
-            xbmc.sleep(250)
-        logger.debug(f"Tracker time (ended) = {self._last_pos}")
-
-    def setUp(self):
-        self._playback_lock.set()
-        self._tracker = threading.Thread(target=self._trackPosition)
-
-    def tearDown(self):
+    def resetTracker(self) -> None:
         if hasattr(self, "_playback_lock"):
             self._playback_lock.clear()
         if not hasattr(self, "_tracker"):
             return
-        if self._tracker is None:
-            return
         if self._tracker.is_alive():
             self._tracker.join()
-        self._tracker = None
+        self._tracker = threading.Thread(target=self._track_position)
+
+    @classmethod
+    def initMyEpisodes(cls) -> MyEpisodes:
+        username = utils.getSetting("Username")
+        password = utils.getSetting("Password")
+
+        login_notif = _language(32912)
+        if not username or not password:
+            utils.notif(login_notif, time=2500)
+            return MyEpisodes("", "")
+
+        mye = MyEpisodes(username, password)
+        mye.login()
+        if mye.is_logged:
+            login_notif = f"{username} {_language(32911)}"
+        utils.notif(login_notif, time=2500)
 
-    def _addShow(self):
+        if mye.is_logged and (not mye.populate_shows()):
+            utils.notif(_language(32927), time=2500)
+        return mye
 
+    def _track_position(self) -> None:
+        while self._playback_lock.is_set() and not self.monitor.abortRequested():
+            try:
+                self.props.last_pos = self.getTime()
+            except:
+                self._playback_lock.clear()
+            logger.debug("Tracker time = %d", self.props.last_pos)
+            xbmc.sleep(250)
+        logger.debug("Tracker time (ended) = %d", self.props.last_pos)
+
+    def _add_show(self) -> None:
         if not utils.getSettingAsBool("auto-add"):
             logger.debug("Auto-add function disabled.")
             return
@@ -117,118 +113,149 @@ def _addShow(self):
         self.mye.populate_shows()
 
         # Add the show if it's not already in our account
-        if self.showid in list(self.mye.shows.values()):
+        if self.props.showid in list(self.mye.shows.values()):
             logger.debug("Show is already in the account.")
             return
 
-        was_added = self.mye.add_show(self.showid)
+        was_added = self.mye.add_show(self.props.showid)
         added = 32926
         if was_added:
             added = 32925
-        utils.notif(f"{self.title} {_language(added)}")
+        utils.notif(f"{self.props.title} {_language(added)}")
 
     # For backward compatibility
-    def onPlayBackStarted(self):
+    def onPlayBackStarted(self) -> None:
         if _kodiversion >= 17.9:
             return
         # This call is only for Krypton and below
         self.onAVStarted()
 
     # Only available in Leia (18) and up
-    def onAVStarted(self):
-        self.setUp()
-        self._total_time = self.getTotalTime()
+    def onAVStarted(self) -> None:
+        self._playback_lock.set()
+        self.props.total_time = self.getTotalTime()
         self._tracker.start()
 
         filename_full_path = self.getPlayingFile()
         # We don't want to take care of any URL because we can't really gain
         # information from it.
-        self.is_excluded = False
+        self.props.is_excluded = False
         if utils.is_excluded(filename_full_path):
-            self.is_excluded = True
-            self.tearDown()
+            self.props.is_excluded = True
+            self.resetTracker()
             return
 
         # Try to find the title with the help of Kodi (Theses came from
         # Kodi.Subtitles add-ons)
-        self.season = str(xbmc.getInfoLabel("VideoPlayer.Season"))
-        logger.debug("Player - Season: {self.season}")
-        self.episode = str(xbmc.getInfoLabel("VideoPlayer.Episode"))
-        logger.debug("Player - Episode: {self.episode}")
-        self.title = xbmc.getInfoLabel("VideoPlayer.TVshowtitle")
-        logger.debug("Player - TVShow: {self.title}")
-        if self.title == "":
+        try:
+            self.props.season = int(xbmc.getInfoLabel("VideoPlayer.Season"))
+        except ValueError:
+            self.props.season = 0
+        logger.debug("Player - Season: %02d", self.props.season)
+
+        try:
+            self.props.episode = int(xbmc.getInfoLabel("VideoPlayer.Episode"))
+        except ValueError:
+            self.props.episode = 0
+        logger.debug("Player - Episode: %02d", self.props.episode)
+
+        self.props.title = xbmc.getInfoLabel("VideoPlayer.TVshowtitle")
+        logger.debug("Player - TVShow: %s", self.props.title)
+
+        if self.props.title == "":
             filename = os.path.basename(filename_full_path)
-            logger.debug("Player - Filename: {filename}")
-            self.title, self.season, self.episode = self.mye.get_info(filename)
-            logger.debug("Player - TVShow: {self.title}")
+            logger.debug("Player - Filename: '%s'", filename)
+            self.props.title, self.props.season, self.props.episode = self.mye.get_info(
+                filename
+            )
+            logger.debug("Player - TVShow: '%s'", self.props.title)
 
         logger.debug(
-            f"Title: {self.title} - Season: {self.season} - Ep: {self.episode}"
+            "Title: '%s' - Season: %02d - Ep: %02d ",
+            self.props.title,
+            self.props.season,
+            self.props.episode,
         )
-        if not self.season and not self.episode:
+        if not self.props.season and not self.props.episode:
             # It's not a show. If it should be recognised as one. Send a bug.
-            self.tearDown()
+            self.resetTracker()
             return
 
-        self.showid = self.mye.find_show_id(self.title)
-        if self.showid is None:
-            utils.notif(f"{self.title} {_language(32923)}", time=3000)
-            self.tearDown()
+        self.props.showid = self.mye.find_show_id(self.props.title)
+        if self.props.showid == SHOW_ID_ERR:
+            utils.notif(f"{self.props.title} {_language(32923)}", time=3000)
+            self.resetTracker()
             return
         logger.debug(
-            f"Player - Found : {self.title} - {self.showid} (S{self.season} E{self.episode}"
+            "Player - Found : '%s' - %02d (S%02d E%02d",
+            self.props.title,
+            self.props.showid,
+            self.props.season,
+            self.props.episode,
         )
 
-        utils.notif(self.title, time=2000)
-        self._addShow()
+        utils.notif(self.props.title, time=2000)
+        self._add_show()
 
-    def onPlayBackStopped(self):
+    def onPlayBackStopped(self) -> None:
         # User stopped the playback
         self.onPlayBackEnded()
 
-    def onPlayBackEnded(self):
-        self.tearDown()
+    def onPlayBackEnded(self) -> None:
+        self.resetTracker()
 
-        logger.debug(f"onPlayBackEnded: is_exluded: {self.is_excluded}")
-        if self.is_excluded:
+        logger.debug("onPlayBackEnded: is_exluded: %r", self.props.is_excluded)
+        if self.props.is_excluded:
             return
 
-        logger.debug(f"last_pos / total_time : {self._last_pos} / {self._total_time}")
-
-        actual_percent = (self._last_pos / self._total_time) * 100
         logger.debug(
-            f"last_pos / total_time : {self._last_pos} / {self._total_time} = {actual_percent} %%",
+            "last_pos / total_time : %d / %d",
+            self.props.last_pos,
+            self.props.total_time,
         )
 
-        logger.debug(f"min_percent: {self._min_percent}")
+        actual_percent = (self.props.last_pos / self.props.total_time) * 100
+        logger.debug(
+            "last_pos / total_time : %d / %d = %d%%",
+            self.props.last_pos,
+            self.props.total_time,
+            actual_percent,
+        )
 
-        if actual_percent < self._min_percent:
+        min_percent = min(utils.getSettingAsInt("watched-percent"), 95)
+        logger.debug("min_percent: %d%%", min_percent)
+        if actual_percent < min_percent:
             return
 
         # In case it was deleted or whatever happened during playback
-        self._addShow()
+        self._add_show()
 
         # Playback is finished, set the items to watched
         found = 32923
-        if self.mye.set_episode_watched(self.showid, self.season, self.episode):
+        if self.mye.set_episode_watched(
+            self.props.showid, self.props.season, self.props.episode
+        ):
             found = 32924
-        utils.notif(f"{self.title} ({self.season} - {self.episode}) {_language(found)}")
+        utils.notif(
+            f"{self.props.title} ({self.props.season:02} - {self.props.episode:02}) {_language(found)}"
+        )
 
 
 if __name__ == "__main__":
-    player = MyePlayer()
+    player = MEPlayer()
     if not player.mye.is_logged:
         sys.exit(0)
 
     logger.debug(
-        f"[{_addon.getAddonInfo('name')}] - Version: {_addon.getAddonInfo('version')} Started"
+        "[%s] - Version: %s Started",
+        _addon.getAddonInfo("name"),
+        _addon.getAddonInfo("version"),
     )
 
     while not player.monitor.abortRequested():
         if player.monitor.waitForAbort(1):
             # Abort was requested while waiting. We should exit
             break
 
-    player.tearDown()
+    player.resetTracker()
     sys.exit(0)