WIP: async experiments

plextraktsync/commands/sync.py

@@ -69,4 +69,4 @@ async def sync(
             w.print_plan(print=logger.info)
         if dry_run:
             logger.info("Enabled dry-run mode: not making actual changes")
-        runner.sync(walker=w, dry_run=config.dry_run)
+        await runner.sync(walker=w, dry_run=config.dry_run)

plextraktsync/media/MediaFactory.py

@@ -27,7 +27,7 @@ def __init__(self, plex: PlexApi, trakt: TraktApi):
         self.plex = plex
         self.trakt = trakt
 
-    def resolve_any(self, pm: PlexLibraryItem, show: Media = None) -> Media | None:
+    async def resolve_any(self, pm: PlexLibraryItem, show: Media = None) -> Media | None:
         try:
             guids = pm.guids
         except (PlexApiException, RequestException) as e:

plextraktsync/plan/Walker.py

@@ -69,7 +69,7 @@ def print_plan(self, print):
         if self.plan.episodes:
             print(f"Sync Episodes: {[x.title for x in self.plan.episodes]}")
 
-    def get_plex_movies(self) -> Generator[PlexLibraryItem, Any, None]:
+    async def get_plex_movies(self) -> Generator[PlexLibraryItem, Any, None]:
         """
         Iterate over movie sections unless specific movie is requested
         """
@@ -80,28 +80,31 @@ def get_plex_movies(self) -> Generator[PlexLibraryItem, Any, None]:
         else:
             return
 
-        yield from movies
+        async for m in movies:
+            yield m
 
-    def find_movies(self) -> Generator[Media, Any, None]:
-        for plex in self.get_plex_movies():
-            movie = self.mf.resolve_any(plex)
+    async def find_movies(self) -> Generator[Media, Any, None]:
+        async for plex in self.get_plex_movies():
+            movie = await self.mf.resolve_any(plex)
             if not movie:
                 continue
             yield movie
 
-    def get_plex_shows(self) -> Generator[PlexLibraryItem, Any, None]:
+    async def get_plex_shows(self) -> Generator[PlexLibraryItem, Any, None]:
         if self.plan.shows:
             shows = self.media_from_items("show", self.plan.shows)
         elif self.plan.show_sections:
             shows = self.media_from_sections(self.plan.show_sections)
         else:
             return
 
-        yield from shows
+        async for m in shows:
+            yield m
 
-    def find_episodes(self):
+    async def find_episodes(self):
         if self.plan.episodes:
-            yield from self.get_plex_episodes(self.plan.episodes)
+            async for m in self.get_plex_episodes(self.plan.episodes):
+                yield m
 
         # Preload plex shows
         plex_shows = {}
@@ -124,14 +127,15 @@ def find_episodes(self):
             show_cache[show_id] = m.show
             yield m
 
-    def walk_shows(self, shows: set[Media], title="Processing Shows"):
+    async def walk_shows(self, shows: set[Media], title="Processing Shows"):
         if not shows:
             return
-        yield from self.progressbar(shows, desc=title)
+        async for show in self.progressbar(shows, desc=title):
+            yield show
 
-    def get_plex_episodes(self, episodes: list[Episode]) -> Generator[Media, Any, None]:
+    async def get_plex_episodes(self, episodes: list[Episode]) -> Generator[Media, Any, None]:
         it = self.progressbar(episodes, desc="Processing episodes")
-        for pe in it:
+        async for pe in it:
             guid = PlexGuid(pe.grandparentGuid, "show")
             show = self.mf.resolve_guid(guid)
             if not show:
@@ -143,7 +147,7 @@ def get_plex_episodes(self, episodes: list[Episode]) -> Generator[Media, Any, No
             me.show = show
             yield me
 
-    def media_from_sections(self, sections: list[PlexLibrarySection]) -> Generator[PlexLibraryItem, Any, None]:
+    async def media_from_sections(self, sections: list[PlexLibrarySection]) -> Generator[PlexLibraryItem, Any, None]:
         for section in sections:
             with measure_time(f"{section.title_link} processed", extra={"markup": True}):
                 self.set_window_title(f"Processing {section.title}")
@@ -161,42 +165,45 @@ def episodes_from_sections(self, sections: list[PlexLibrarySection]) -> Generato
                     section.pager("episode"),
                     desc=f"Processing {section.title_link}",
                 )
-                yield from it
+                async for m in it:
+                    yield m
 
-    def media_from_items(self, libtype: str, items: list) -> Generator[PlexLibraryItem, Any, None]:
+    async def media_from_items(self, libtype: str, items: list) -> Generator[PlexLibraryItem, Any, None]:
         it = self.progressbar(items, desc=f"Processing {libtype}s")
-        for m in it:
+        async for m in it:
             yield PlexLibraryItem(m, plex=self.plex)
 
-    def episode_from_show(self, show: Media) -> Generator[Media, Any, None]:
+    async def episode_from_show(self, show: Media) -> Generator[Media, Any, None]:
         for pe in show.plex.episodes():
-            me = self.mf.resolve_any(pe, show)
+            me = await self.mf.resolve_any(pe, show)
             if not me:
                 continue
 
             me.show = show
             yield me
 
-    def progressbar(self, iterable: Iterable, **kwargs):
+    async def progressbar(self, iterable: Iterable, **kwargs):
         if self._progressbar:
             pb = self._progressbar(iterable, **kwargs)
             with pb as it:
-                yield from it
+                async for m in it:
+                    yield m
         else:
-            yield from iterable
+            async for m in iterable:
+                yield m
 
-    def media_from_traktlist(self, items: Iterable, title="Trakt watchlist") -> Generator[Media, Any, None]:
+    async def media_from_traktlist(self, items: Iterable, title="Trakt watchlist") -> Generator[Media, Any, None]:
         it = self.progressbar(items, desc=f"Processing {title}")
-        for media in it:
-            tm = TraktItem(media)
+        async for media in it:
+            tm = TraktItem(media, trakt=self.trakt)
             m = self.mf.resolve_trakt(tm)
             yield m
 
-    def media_from_plexlist(self, items: Iterable) -> Generator[Media, Any, None]:
+    async def media_from_plexlist(self, items: Iterable) -> Generator[Media, Any, None]:
         it = self.progressbar(items, desc="Processing Plex watchlist")
-        for media in it:
+        async for media in it:
             pm = PlexLibraryItem(media, plex=self.plex)
-            m = self.mf.resolve_any(pm)
+            m = await self.mf.resolve_any(pm)
             if not m:
                 continue
             yield m