Refactor: Use named loggers everywhere

plextraktsync/cli.py

@@ -27,12 +27,14 @@ def wrap(*args, **kwargs):
             except EOFError as e:
                 raise ClickException(f"Program requested terminal, No terminal is connected: {e}")
             except ClickException as e:
-                from plextraktsync.factory import logger
+                from plextraktsync.factory import logging
 
+                logger = logging.getLogger(__name__)
                 logger.fatal(f"Error running {name} command: {str(e)}")
             except Exception as e:
-                from plextraktsync.factory import logger
+                from plextraktsync.factory import logging
 
+                logger = logging.getLogger(__name__)
                 logger.exception(e)
 
                 raise ClickException(f"Error running {name} command: {str(e)}")

plextraktsync/commands/sync.py

@@ -2,7 +2,9 @@
 
 from plextraktsync.commands.login import ensure_login
 from plextraktsync.decorators.measure_time import measure_time
-from plextraktsync.factory import factory, logger
+from plextraktsync.factory import factory, logging
+
+logger = logging.getLogger(__name__)
 
 
 def sync(

plextraktsync/decorators/measure_time.py

@@ -1,8 +1,9 @@
-import logging
 from contextlib import contextmanager
 from time import time
 
-from plextraktsync.factory import logger
+from plextraktsync.factory import logging
+
+logger = logging.getLogger(__name__)
 
 
 @contextmanager

plextraktsync/decorators/rate_limit.py

@@ -4,7 +4,9 @@
 from click import ClickException
 from trakt.errors import RateLimitException
 
-from plextraktsync.factory import logger
+from plextraktsync.factory import logging
+
+logger = logging.getLogger(__name__)
 
 
 # https://trakt.docs.apiary.io/#introduction/rate-limiting

plextraktsync/decorators/retry.py

@@ -7,7 +7,9 @@
 from trakt.errors import (BadResponseException, TraktBadGateway,
                           TraktInternalException, TraktUnavailable)
 
-from plextraktsync.factory import logger
+from plextraktsync.factory import logging
+
+logger = logging.getLogger(__name__)
 
 
 def retry(retries=5):

plextraktsync/media/MediaFactory.py

@@ -6,7 +6,7 @@
 from requests import RequestException
 from trakt.errors import TraktException
 
-from plextraktsync.factory import logger
+from plextraktsync.factory import logging
 from plextraktsync.media.Media import Media
 
 if TYPE_CHECKING:
@@ -21,6 +21,7 @@ class MediaFactory:
     """
     Class that is able to resolve Trakt media item from Plex media item and vice versa and return generic Media class
     """
+    logger = logging.getLogger(__name__)
 
     def __init__(self, plex: PlexApi, trakt: TraktApi):
         self.plex = plex
@@ -30,13 +31,13 @@ def resolve_any(self, pm: PlexLibraryItem, show: Media = None) -> Media | None:
         try:
             guids = pm.guids
         except (PlexApiException, RequestException) as e:
-            logger.error(f"Skipping {pm}: {e}")
+            self.logger.error(f"Skipping {pm}: {e}")
             return None
 
         for guid in guids:
             m = self.resolve_guid(guid, show)
             if m:
-                logger.debug(f"Resolved {guid} of {guid.pm} to {m}")
+                self.logger.debug(f"Resolved {guid} of {guid.pm} to {m}")
                 return m
 
         return None
@@ -55,7 +56,7 @@ def resolve_guid(self, guid: PlexGuid, show: Media = None):
                 level = "error"
                 reason = "is not a valid provider"
 
-            getattr(logger, level)(f"{error} {reason}", extra={"markup": True})
+            getattr(self.logger, level)(f"{error} {reason}", extra={"markup": True})
 
             return None
 
@@ -65,11 +66,11 @@ def resolve_guid(self, guid: PlexGuid, show: Media = None):
             else:
                 tm = self.trakt.find_by_guid(guid)
         except (TraktException, RequestException) as e:
-            logger.warning(f"{guid.title_link}: Skipping {guid}: Trakt errors: {e}", extra={"markup": True})
+            self.logger.warning(f"{guid.title_link}: Skipping {guid}: Trakt errors: {e}", extra={"markup": True})
             return None
 
         if tm is None:
-            logger.warning(f"{guid.title_link}: Skipping {guid} not found on Trakt", extra={"markup": True})
+            self.logger.warning(f"{guid.title_link}: Skipping {guid} not found on Trakt", extra={"markup": True})
             return None
 
         return self.make_media(guid.pm, tm)

plextraktsync/plan/Walker.py

@@ -27,6 +27,7 @@ class Walker(SetWindowTitle):
     """
     Class dealing with finding and walking library, movies/shows, episodes
     """
+    logger = logging.getLogger(__name__)
 
     def __init__(
         self,
@@ -41,7 +42,6 @@ def __init__(
         self.trakt = trakt
         self.mf = mf
         self.config = config
-        self.logger = logging.getLogger("PlexTraktSync.Walker")
 
     @cached_property
     def plan(self):

plextraktsync/plex/PlexApi.py

@@ -12,7 +12,7 @@
 from plextraktsync.decorators.flatten import flatten_dict, flatten_list
 from plextraktsync.decorators.memoize import memoize
 from plextraktsync.decorators.retry import retry
-from plextraktsync.factory import factory, logger
+from plextraktsync.factory import factory, logging
 from plextraktsync.plex.PlexId import PlexId
 from plextraktsync.plex.PlexLibraryItem import PlexLibraryItem
 from plextraktsync.plex.PlexLibrarySection import PlexLibrarySection
@@ -30,6 +30,7 @@ class PlexApi:
     """
     Plex API class abstracting common data access and dealing with requests cache.
     """
+    logger = logging.getLogger(__name__)
 
     def __init__(
             self,
@@ -160,7 +161,7 @@ def history(self, m, device=False, account=False):
         try:
             history = m.history()
         except Unauthorized as e:
-            logger.debug(f"No permission to access play history: {e}")
+            self.logger.debug(f"No permission to access play history: {e}")
             return
 
         for h in history:
@@ -200,17 +201,17 @@ def account(self):
                 plex_owner_account = MyPlexAccount(token=plex_owner_token, session=factory.session)
                 return plex_owner_account.switchHomeUser(plex_username)
             except BadRequest as e:
-                logger.error(f"Error during {plex_username} account access: {e}")
+                self.logger.error(f"Error during {plex_username} account access: {e}")
         elif plex_account_token:
             try:
                 return MyPlexAccount(token=plex_account_token, session=factory.session)
             except BadRequest as e:
-                logger.error(f"Error during {plex_username} account access: {e}")
+                self.logger.error(f"Error during {plex_username} account access: {e}")
         else:
             try:
                 return self.server.myPlexAccount()
             except BadRequest as e:
-                logger.error(f"Error during {plex_username} account access: {e}")
+                self.logger.error(f"Error during {plex_username} account access: {e}")
         return None
 
     def watchlist(self, libtype=None) -> list[Movie | Show] | None:
@@ -225,20 +226,20 @@ def watchlist(self, libtype=None) -> list[Movie | Show] | None:
         try:
             return self.account.watchlist(libtype=libtype, **params)
         except BadRequest as e:
-            logger.error(f"Error during {self.account.username} watchlist access: {e}")
+            self.logger.error(f"Error during {self.account.username} watchlist access: {e}")
             return None
 
     def add_to_watchlist(self, item):
         try:
             self.account.addToWatchlist(item)
         except BadRequest as e:
-            logger.error(f"Error when adding {item.title} to Plex watchlist: {e}")
+            self.logger.error(f"Error when adding {item.title} to Plex watchlist: {e}")
 
     def remove_from_watchlist(self, item):
         try:
             self.account.removeFromWatchlist(item)
         except BadRequest as e:
-            logger.error(f"Error when removing {item.title} from Plex watchlist: {e}")
+            self.logger.error(f"Error when removing {item.title} from Plex watchlist: {e}")
 
     @retry()
     def search_online(self, title: str, media_type: str):
@@ -247,7 +248,7 @@ def search_online(self, title: str, media_type: str):
         try:
             result = self.account.searchDiscover(title, libtype=media_type)
         except (BadRequest, Unauthorized) as e:
-            logger.error(f"{title}: Searching Plex Discover error: {e}")
+            self.logger.error(f"{title}: Searching Plex Discover error: {e}")
             return None
         except NotFound:
             return None
@@ -261,6 +262,6 @@ def reset_show(self, show: Show, reset_date: datetime):
                 self.mark_unwatched(ep)
                 reset_count += 1
             else:
-                logger.debug(
+                self.logger.debug(
                     f"{show.title} {ep.seasonEpisode} watched at {ep.lastViewedAt} after reset date {reset_date}")
-        logger.debug(f"{show.title}: {reset_count} Plex episode(s) marked as unwatched.")
+        self.logger.debug(f"{show.title}: {reset_count} Plex episode(s) marked as unwatched.")

plextraktsync/plex/PlexPlaylist.py

@@ -16,10 +16,11 @@
 
 
 class PlexPlaylist(RichMarkup):
+    logger = logging.getLogger(__name__)
+
     def __init__(self, server: PlexServer, name: str):
         self.server = server
         self.name = name
-        self.logger = logging.getLogger("PlexTraktSync.PlexPlaylist")
 
     def __iter__(self):
         return iter(self.items)

plextraktsync/plex/PlexServerConnection.py

@@ -12,9 +12,10 @@
 
 
 class PlexServerConnection:
+    logger = logging.getLogger(__name__)
+
     def __init__(self, factory: Factory):
         self.factory = factory
-        self.logger = logging.getLogger("PlexTraktSync.PlexServerConnection")
 
     @property
     def timeout(self):

plextraktsync/queue/BackgroundTask.py

@@ -17,12 +17,12 @@ class BackgroundTask:
     """
     Class to read events from queue and invoke them at tasks to flush them at interval set by the timer
     """
+    logger = logging.getLogger(__name__)
 
     def __init__(self, timer: Timer = None, *tasks):
         self.queues = defaultdict(list)
         self.timer = timer
         self.tasks = tasks
-        self.logger = logging.getLogger("PlexTraktSync.BackgroundTask")
 
     def check_timer(self):
         if not self.timer:

plextraktsync/queue/TraktBatchWorker.py

@@ -17,9 +17,7 @@ class TraktBatchWorker:
         "add_to_watchlist",
         "remove_from_watchlist",
     )
-
-    def __init__(self):
-        self.logger = logging.getLogger("PlexTraktSync.TraktBatchWorker")
+    logger = logging.getLogger(__name__)
 
     def __call__(self, queues):
         for name in self.QUEUES:

plextraktsync/queue/TraktMarkWatchedWorker.py

@@ -14,9 +14,7 @@
 class TraktMarkWatchedWorker:
     # Queue this Worker can handle
     QUEUE = "add_to_history"
-
-    def __init__(self):
-        self.logger = logging.getLogger("PlexTraktSync.TraktMarkWatchedWorker")
+    logger = logging.getLogger(__name__)
 
     def __call__(self, queues):
         items = queues[self.QUEUE]

plextraktsync/queue/TraktScrobbleWorker.py

@@ -20,9 +20,7 @@ class TraktScrobbleWorker:
         "scrobble_pause",
         "scrobble_stop",
     )
-
-    def __init__(self):
-        self.logger = logging.getLogger("PlexTraktSync.TraktScrobbleWorker")
+    logger = logging.getLogger(__name__)
 
     def __call__(self, queues):
         for name in self.QUEUES: