plexflow 0.0.64__py3-none-any.whl

plexflow/__main__.py

@@ -0,0 +1,15 @@
+from plexflow.core.subtitles.providers.oss.search import get_subtitles
+from plexflow.core.subtitles.providers.oss.download import download_subtitles
+from plexflow.core.subtitles.providers.auto_subtitles import AutoSubtitles
+from pathlib import Path
+from typing import List
+
+auto_subtitles = AutoSubtitles(
+    imdb_id="tt8367814",
+    languages=["nl", "en"],
+    credentials_path="config/credentials.yaml",
+    redis_host="localhost",
+    redis_port=6379,
+)
+
+download_subtitles(auto_subtitles)

plexflow/core/context/metadata/context.py

@@ -0,0 +1,32 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+from plexflow.core.context.plexflow_context import PlexflowContext
+from plexflow.core.context.metadata.tmdb.context import TMDbMetadataContext
+
+class MetadataContext(PlexflowContext):
+    """A class used to represent a Select Context in Plexflow.
+
+    This class extends PlexflowContext and adds a selected item property.
+
+    Attributes:
+        selected_item (PlexflowObjectProperty): The selected item in the context.
+    """
+
+    def __init__(self, store: PlexflowObjectStore, **kwargs):
+        """Initializes the SelectContext with the given object store and keyword arguments.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used.
+            **kwargs: Arbitrary keyword arguments.
+        """
+
+        super().__init__(store=store, **kwargs)
+
+    @property
+    def tmdb(self) -> TMDbMetadataContext:
+        """Gets the value of the selected item.
+
+        Returns:
+            Any: The value of the selected item.
+        """
+
+        return TMDbMetadataContext(store=self.object_store)

plexflow/core/context/metadata/tmdb/context.py

@@ -0,0 +1,45 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+from plexflow.core.context.plexflow_context import PlexflowContext
+from plexflow.core.context.plexflow_property import PlexflowObjectProperty
+from plexflow.core.metadata.providers.tmdb.datatypes import TmdbMovie
+from typing import Union
+
+class TMDbMetadataContext(PlexflowContext):
+    """A class used to represent a Select Context in Plexflow.
+
+    This class extends PlexflowContext and adds a selected item property.
+
+    Attributes:
+        selected_item (PlexflowObjectProperty): The selected item in the context.
+    """
+
+    def __init__(self, store: PlexflowObjectStore, **kwargs):
+        """Initializes the SelectContext with the given object store and keyword arguments.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used.
+            **kwargs: Arbitrary keyword arguments.
+        """
+
+        super().__init__(store=store, **kwargs)
+        self.movie_details = PlexflowObjectProperty(self.object_store, "movie_details", local=True)
+
+    @property
+    def movie_data(self) -> Union[TmdbMovie, None]:
+        """Gets the value of the selected item.
+
+        Returns:
+            Any: The value of the selected item.
+        """
+
+        return self.movie_details.value
+    
+    @movie_data.setter
+    def movie_data(self, val: TmdbMovie):
+        """Sets the value of the selected item.
+
+        Args:
+            val (Any): The value to be set.
+        """
+
+        self.movie_details.value = val

plexflow/core/context/partial_context.py

@@ -0,0 +1,46 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+from typing import Any
+from ulid import ULID
+
+class PartialContext:
+    @staticmethod
+    def create_universal_id(dag_run_id: str):
+        store = PlexflowObjectStore(dag_run_id)
+        try:
+            print("try retrieving universal id")
+            universal_id = store.retrieve(store.make_key(dag_run_id))
+            if isinstance(universal_id, str) and len(universal_id) > 0:
+                return universal_id
+        except Exception:
+            print("creating universal id")
+            
+        universal_id = str(ULID())
+        store.store_temporarily(key=store.make_key(dag_run_id), obj=universal_id)
+        return universal_id
+
+    def __init__(self, context_id: str, dag_run_id: str, default_ttl: int, **kwargs) -> None:
+        self.context_id = context_id
+        self.dag_run_id = dag_run_id
+        self.default_ttl = default_ttl
+        self.store = PlexflowObjectStore(context_id, **kwargs)
+    
+    def update_universal_id(self, value: str):
+        self.store.store_temporarily(key=self.store.make_key(self.dag_run_id), obj=value)
+
+    def set(self, key: str, value: Any, ttl: int = None) -> None:
+        self.store.store_temporarily(key=self.store.make_run_key(key), obj=value, ttl=ttl or self.default_ttl)
+
+    def set_global(self, key: str, value: Any, ttl: int = None) -> None:
+        self.store.store_temporarily(key=self.store.make_key(key), obj=value, ttl=ttl or self.default_ttl)
+    
+    def get(self, key: str) -> Any:
+        return self.store.retrieve(key=self.store.make_run_key(key))
+
+    def get_global(self, key: str) -> Any:
+        return self.store.retrieve(key=self.store.make_key(key))
+
+    def get_keys(self, pattern: str):
+        return list(map(lambda key_bytes: key_bytes.decode('utf-8'), self.store.retrieve_keys(self.store.make_run_key(pattern))))
+    
+    def get_by_pattern(self, pattern: str):
+        return self.store.retrieve_values(self.store.make_run_key(pattern))

plexflow/core/context/partials/__init__.py

@@ -0,0 +1,8 @@
+from plexflow.core.context.partials.ids import Ids
+from plexflow.core.context.partials.watchlist import Watchlist
+from plexflow.core.context.partials.cache import LRUCache
+from plexflow.core.context.partials.movie import Movie
+from plexflow.core.context.partials.context import Context
+from plexflow.core.context.partials.torrents import Torrents
+from plexflow.core.context.partials.tgx_context import TgxRequestContext
+from plexflow.core.context.partials.tgx_batch import TgxBatch

plexflow/core/context/partials/cache.py

@@ -0,0 +1,16 @@
+from plexflow.core.context.partial_context import PartialContext
+from datetime import datetime as dt
+    
+class LRUCache(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def touch(self, media_id: str) -> None:
+        self.set_global(f"cache/processing/{media_id}", dt.now())
+    
+    def last_used(self, media_id: str) -> dt:
+        try:
+            return self.get_global(f"cache/processing/{media_id}")
+        except Exception:
+            return None
+

plexflow/core/context/partials/context.py

@@ -0,0 +1,12 @@
+from plexflow.core.context.partial_context import PartialContext
+
+class Context(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def update(self, id: str):
+        self.update_universal_id(id)
+
+    @property
+    def id(self) -> str:
+        return self.context_id

plexflow/core/context/partials/ids.py

@@ -0,0 +1,37 @@
+from plexflow.core.context.partial_context import PartialContext
+
+class Ids(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+    
+    @property
+    def imdb_id(self) -> str:
+        return self.get("imdb_id")
+    
+    @imdb_id.setter
+    def imdb_id(self, value: str) -> None:
+        self.set("imdb_id", value)
+    
+    @property
+    def tmdb_id(self) -> int:
+        return self.get("tmdb_id")
+    
+    @tmdb_id.setter
+    def tmdb_id(self, value: int) -> None:
+        self.set("tmdb_id", value)
+    
+    @property
+    def tvdb_id(self) -> int:
+        return self.get("tvdb_id")
+    
+    @tvdb_id.setter
+    def tvdb_id(self, value: int) -> None:
+        self.set("tvdb_id", value)
+    
+    @property
+    def plex_id(self) -> str:
+        return self.get("plex_id")
+
+    @plex_id.setter
+    def plex_id(self, value: str) -> None:
+        self.set("plex_id", value)

plexflow/core/context/partials/movie.py

@@ -0,0 +1,115 @@
+from plexflow.core.context.partial_context import PartialContext
+from datetime import datetime as dt
+from plexflow.core.metadata.auto.auto_providers.auto.movie import AutoMovie
+from plexflow.core.metadata.auto.auto_providers.tmdb.movie import AutoTmdbMovie
+from plexflow.core.metadata.auto.auto_providers.tvdb.movie import AutoTvdbMovie
+from plexflow.core.metadata.auto.auto_providers.moviemeter.movie import AutoMovieMeterMovie
+from plexflow.core.metadata.auto.auto_providers.imdb.movie import AutoImdbMovie
+from plexflow.core.metadata.auto.auto_providers.tmdb.show import AutoTmdbShow
+from plexflow.core.metadata.auto.auto_providers.tvdb.show import AutoTvdbShow
+from plexflow.core.metadata.auto.auto_providers.imdb.show import AutoImdbShow
+from plexflow.core.metadata.auto.auto_providers.plex.movie import AutoPlexMovie
+
+class Movie(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    @property
+    def sources(self) -> list:
+        keys = self.get_keys("movie/*")
+        # extract the source from the key
+        return [key.split("/")[-1] for key in keys]
+
+    def from_source(self, source: str) -> AutoMovie:
+        return self.get(f"movie/{source}")
+
+    @property
+    def title(self) -> str:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.title:
+                return details.title
+    
+    @property
+    def year(self) -> int:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.year:
+                return details.year
+    
+    @property
+    def release_date(self) -> dt:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.release_date:
+                return details.release_date
+    
+    @property
+    def rank(self) -> int:
+        return self.plex.rank
+    
+    @property
+    def released(self) -> bool:
+        dates = []
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.release_date:
+                dates.append(details.release_date)
+        
+        sorted_dates = sorted(dates)
+        now = dt.now()
+        return all([date < now for date in sorted_dates])
+    
+    @property
+    def runtime(self) -> int:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.runtime:
+                return details.runtime
+
+    @property
+    def titles(self) -> set:
+        titles = set()
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.title:
+                titles.add(details.title)
+                titles.update(details.titles)
+        return titles
+
+    @property
+    def summary(self) -> str:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.summary:
+                return details.summary
+    
+    @property
+    def language(self) -> str:
+        for source in self.sources:
+            details = self.from_source(source)
+            if details and details.language:
+                return details.language
+        
+    @property
+    def plex(self) -> AutoPlexMovie:
+        return self.from_source("plex")
+        
+    @property
+    def tmdb(self) -> AutoTmdbMovie:
+        return self.from_source("tmdb")
+        
+    @property
+    def imdb(self) -> AutoImdbMovie:
+        return self.from_source("imdb")
+        
+    @property
+    def tvdb(self) -> AutoTvdbMovie:
+        return self.from_source("tvdb")
+        
+    @property
+    def moviemeter(self) -> AutoMovieMeterMovie:
+        return self.from_source("moviemeter")
+    
+    def update(self, movie: AutoMovie):
+        self.set(f"movie/{movie.source}", movie)

plexflow/core/context/partials/tgx_batch.py

@@ -0,0 +1,33 @@
+from plexflow.core.context.partial_context import PartialContext
+
+class TgxBatch(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def update(self, ids):
+        self.set("tgx/ids", ids)
+    
+    def update_finished(self, ids):
+        self.set("tgx/finished", ids)
+    
+    def update_unfinished(self, ids):
+        self.set("tgx/unfinished", ids)
+    
+    def update_finished_items(self, items):
+        self.set("tgx/finished_items", items)
+    
+    @property
+    def ids(self) -> set:
+        return self.get("tgx/ids")
+    
+    @property
+    def finished(self) -> set:
+        return self.get("tgx/finished")
+    
+    @property
+    def unfinished(self) -> set:
+        return self.get("tgx/unfinished")
+    
+    @property
+    def finished_items(self) -> list:
+        return self.get("tgx/finished_items")

plexflow/core/context/partials/tgx_context.py

@@ -0,0 +1,34 @@
+from plexflow.core.context.partial_context import PartialContext
+
+class TgxRequestContext(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    def update(self, cookies: dict):
+        self.set_global("tgx/cookies", cookies)
+
+    @property
+    def session_id(self) -> str:
+        """
+        Cookies is a dictionary like below:
+        
+        [{'name': 'PHPSESSID', 'value': 'a95el556bo30414fslulnbdi03', 'domain': 'torrentgalaxy.to', 'path': '/', 'expires': -1, 'httpOnly': False, 'secure': False, 'sameSite': 'Lax'}, {'name': 'AdskeeperStorage', 'value': '%7B%220%22%3A%7B%22svspr%22%3A%22https%3A%2F%2Ftorrentgalaxy.to%2Ftorrent%2F16100045%22%2C%22svsds%22%3A2%7D%2C%22C385455%22%3A%7B%22page%22%3A1%2C%22time%22%3A%221722597496754%22%7D%2C%22C1543068%22%3A%7B%22page%22%3A1%2C%22time%22%3A%221722597496757%22%7D%2C%22C1343686%22%3A%7B%22page%22%3A1%2C%22time%22%3A%221722597497305%22%7D%7D', 'domain': 'torrentgalaxy.to', 'path': '/', 'expires': -1, 'httpOnly': False, 'secure': False, 'sameSite': 'Lax'}]
+        """
+        try:
+            cookies = self.get_global("tgx/cookies")
+            for cookie in cookies:
+                if cookie["name"] == "PHPSESSID":
+                    return cookie["value"]
+        except Exception:
+            return None
+
+    @property
+    def cookies(self) -> dict:
+        try:
+            cookies = self.get_global("tgx/cookies")
+            simple_cookies = {}
+            for cookie in cookies:
+                simple_cookies[cookie["name"]] = cookie["value"]
+            return simple_cookies
+        except Exception:
+            return None

plexflow/core/context/partials/torrents.py

@@ -0,0 +1,23 @@
+from plexflow.core.context.partial_context import PartialContext
+from datetime import datetime as dt
+from plexflow.core.torrents.results.torrent import Torrent
+from typing import List
+
+class Torrents(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    @property
+    def sources(self) -> list[str]:
+        keys = self.get_keys("torrents/*")
+        # extract the source from the key
+        return [key.split("/")[-1] for key in keys]
+
+    def from_source(self, source: str) -> List[Torrent]:
+        return self.get(f"torrents/{source}")
+
+    def update(self, torrents: Torrent):
+        if len(torrents) == 0:
+            return
+        source = next(iter(torrents)).source
+        self.set(f"torrents/{source}", torrents)

plexflow/core/context/partials/watchlist.py

@@ -0,0 +1,35 @@
+from plexflow.core.context.partial_context import PartialContext
+from plexflow.core.plex.watchlist.datatypes import MediaContainer, PlexMetadata
+from ulid import ULID
+from typing import Generator, Any
+    
+class Watchlist(PartialContext):
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+    @property
+    def selected(self) -> PlexMetadata:
+        try:
+            return self.get("watchlist/selected")
+        except Exception:
+            return None
+    
+    def select(self, value: PlexMetadata) -> None:
+        self.set("watchlist/selected", value)
+    
+    def update(self, container: MediaContainer) -> None:
+        tag = ULID()
+        self.set(f"watchlist/items/{tag}", container)
+
+    def __iter__(self):
+        return self.generator()
+    
+    def raw(self):
+        return self.get_by_pattern("watchlist/items/*")
+    
+    def generator(self) -> Generator[Any, Any, Any]:
+        items = self.get_by_pattern("watchlist/items/*")
+        for part in items:
+            part: MediaContainer = part
+            for item in part.Metadata:
+                yield item

plexflow/core/context/plexflow_context.py

@@ -0,0 +1,29 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+
+class PlexflowContext:
+    """A class used to represent the Plexflow Context.
+
+    This class provides a context for Plexflow computations, allowing access to an object store.
+
+    Attributes:
+        store (PlexflowObjectStore): The object store used in the Plexflow context.
+    """
+
+    def __init__(self, store: PlexflowObjectStore):
+        """Initializes the PlexflowContext with the given object store.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used in the Plexflow context.
+        """
+
+        self.store = store
+
+    @property
+    def object_store(self) -> PlexflowObjectStore:
+        """Gets the object store used in the Plexflow context.
+
+        Returns:
+            PlexflowObjectStore: The object store used in the Plexflow context.
+        """
+
+        return self.store

plexflow/core/context/plexflow_property.py

@@ -0,0 +1,36 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+
+class PlexflowObjectProperty:
+    """A class used to represent a property of a Plexflow object."""
+
+    def __init__(self, store: PlexflowObjectStore, key: str, local: bool = True):
+        """Initializes the PlexflowObjectProperty with the given object store, key, and locality.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used.
+            key (str): The key of the object.
+            local (bool, optional): Whether the key is local. Defaults to True.
+        """
+
+        self.store = store
+        self.object_key = self.store.make_run_key(key) if local else self.store.make_key(key)
+
+    @property
+    def value(self):
+        """Gets the value of the object from the object store.
+
+        Returns:
+            Any: The value of the object.
+        """
+
+        return self.store.retrieve(self.object_key)
+    
+    @value.setter
+    def value(self, val):
+        """Sets the value of the object in the object store.
+
+        Args:
+            val (Any): The value to be set.
+        """
+
+        self.store.store_temporarily(self.object_key, val)

plexflow/core/context/root/context.py

@@ -0,0 +1,25 @@
+from plexflow.core.context.plexflow_context import PlexflowContext
+from plexflow.core.context.select.context import SelectContext
+from plexflow.core.context.watchlist.context import WatchlistContext
+from plexflow.core.context.metadata.context import MetadataContext
+from plexflow.core.context.torrent.context import TorrentContext
+
+class RootContext(PlexflowContext):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    @property
+    def select(self):
+        return SelectContext(self.object_store)
+    
+    @property
+    def watchlist(self):
+        return WatchlistContext(self.object_store)
+    
+    @property
+    def metadata(self):
+        return MetadataContext(self.object_store)
+    
+    @property
+    def torrent(self):
+        return TorrentContext(self.object_store)

plexflow/core/context/select/context.py

@@ -0,0 +1,45 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+from plexflow.core.context.plexflow_context import PlexflowContext
+from plexflow.core.context.plexflow_property import PlexflowObjectProperty
+from plexflow.core.plex.watchlist.datatypes import PlexMetadata
+from typing import Union
+
+class SelectContext(PlexflowContext):
+    """A class used to represent a Select Context in Plexflow.
+
+    This class extends PlexflowContext and adds a selected item property.
+
+    Attributes:
+        selected_item (PlexflowObjectProperty): The selected item in the context.
+    """
+
+    def __init__(self, store: PlexflowObjectStore, **kwargs):
+        """Initializes the SelectContext with the given object store and keyword arguments.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used.
+            **kwargs: Arbitrary keyword arguments.
+        """
+
+        super().__init__(store=store, **kwargs)
+        self.selected_item = PlexflowObjectProperty(self.object_store, "selected", local=True)
+
+    @property
+    def item(self) -> Union[PlexMetadata, None]:
+        """Gets the value of the selected item.
+
+        Returns:
+            Any: The value of the selected item.
+        """
+
+        return self.selected_item.value
+    
+    @item.setter
+    def item(self, val: PlexMetadata):
+        """Sets the value of the selected item.
+
+        Args:
+            val (Any): The value to be set.
+        """
+
+        self.selected_item.value = val

plexflow/core/context/torrent/context.py

@@ -0,0 +1,43 @@
+from plexflow.core.storage.object.plexflow_storage import PlexflowObjectStore
+from plexflow.core.context.plexflow_context import PlexflowContext
+from plexflow.core.context.torrent.tpb.context import ThePirateBayTorrentContext
+from plexflow.core.context.torrent.yts.context import YTSTorrentContext
+
+class TorrentContext(PlexflowContext):
+    """A class used to represent a Select Context in Plexflow.
+
+    This class extends PlexflowContext and adds a selected item property.
+
+    Attributes:
+        selected_item (PlexflowObjectProperty): The selected item in the context.
+    """
+
+    def __init__(self, store: PlexflowObjectStore, **kwargs):
+        """Initializes the SelectContext with the given object store and keyword arguments.
+
+        Args:
+            store (PlexflowObjectStore): The object store to be used.
+            **kwargs: Arbitrary keyword arguments.
+        """
+
+        super().__init__(store=store, **kwargs)
+
+    @property
+    def tpb(self) -> ThePirateBayTorrentContext:
+        """Gets the value of the selected item.
+
+        Returns:
+            Any: The value of the selected item.
+        """
+
+        return ThePirateBayTorrentContext(store=self.object_store)
+
+    @property
+    def yts(self) -> YTSTorrentContext:
+        """Gets the value of the selected item.
+
+        Returns:
+            Any: The value of the selected item.
+        """
+
+        return YTSTorrentContext(store=self.object_store)