plexflow 0.0.64__py3-none-any.whl

plexflow/core/plex/library/library.py

@@ -0,0 +1,103 @@
+from plexflow.core.plex.api.context.library import PlexLibraryRequestContext
+
+def get_library_id(library_name: str) -> int:
+    """
+    Get the ID of a Plex library based on its name.
+
+    Parameters:
+    library_name (str): The name of the Plex library.
+
+    Returns:
+    int: The ID of the Plex library.
+
+    Raises:
+    ValueError: If the library name is not found.
+
+    Examples:
+    >>> get_library_id('Movies')
+    1
+    >>> get_library_id('TV Shows')
+    2
+    """
+    context = PlexLibraryRequestContext()
+    response = context.get(f"/library/sections")
+    
+    data = response.json()
+    sections = data["MediaContainer"]["Directory"]
+    for section in sections:
+        if section["title"] == library_name:
+            return section["key"]
+    raise ValueError(f"Library '{library_name}' not found.")
+
+def is_media_in_library(guid: str, library_name: str, media_type: str) -> bool:
+    """
+    Check if a media exists in a Plex library based on its GUID.
+
+    Parameters:
+    guid (str): The GUID of the media to search for.
+    library_name (str): The name of the Plex library.
+    media_type (str): The type of media (e.g., 'movie', 'show').
+
+    Returns:
+    bool: True if the media is found in the library, False otherwise.
+
+    Examples:
+    >>> is_media_in_library('plex://movie/65581f1fb67b7b5555369f9c', 'Movies', 'movie')
+    True
+    >>> is_media_in_library('plex://show/65581f1fb67b7b5555369f9c', 'TV Shows', 'show')
+    False
+    """
+    library_id = get_library_id(library_name)
+    context = PlexLibraryRequestContext()
+    response = context.get(f"/library/sections/{library_id}/all", params={
+        "guid": guid
+    })
+    
+    data = response.json()
+    n_results = data["MediaContainer"]["size"]
+
+    if media_type == 'movie':
+        return n_results > 0
+    elif media_type == 'show':
+        return n_results > 0
+    else:
+        raise ValueError(f"Invalid media type: {media_type}")
+    
+def is_movie_in_library(guid: str, library_name: str = 'Films') -> bool:
+    """
+    Check if a movie exists in a Plex library based on its GUID.
+
+    Parameters:
+    guid (str): The GUID of the movie to search for.
+    library_name (str): The name of the Plex library. Default is 'Films'.
+
+    Returns:
+    bool: True if the movie is found in the library, False otherwise.
+
+    Examples:
+    >>> is_movie_in_library('plex://movie/65581f1fb67b7b5555369f9c', 'Movies')
+    True
+    >>> is_movie_in_library('plex://show/65581f1fb67b7b5555369f9c', 'TV Shows')
+    False
+    """
+    return is_media_in_library(guid, library_name, 'movie')
+
+def is_show_in_library(guid: str, library_name: str = 'Series') -> bool:
+    """
+    Check if a TV show exists in a Plex library based on its GUID.
+
+    Parameters:
+    guid (str): The GUID of the TV show to search for.
+    library_name (str): The name of the Plex library. Default is 'Series'.
+
+    Returns:
+    bool: True if the TV show is found in the library, False otherwise.
+
+    Examples:
+    >>> is_show_in_library('plex://movie/65581f1fb67b7b5555369f9c', 'Movies')
+    True
+    >>> is_show_in_library('plex://show/65581f1fb67b7b5555369f9c', 'TV Shows')
+    False
+    True
+    """
+    return is_media_in_library(guid, library_name, 'show')

plexflow/core/plex/token/auto_token.py

@@ -0,0 +1,91 @@
+import os
+import redis
+import xml.etree.ElementTree as ET
+from typing import Union
+
+class PlexAutoToken:
+    """
+    A class to automatically try to fetch the value for PLEX_TOKEN from a number of locations.
+
+    This class tries to fetch the Plex token from the following sources in order:
+    1. Redis database (optional)
+    2. Environment variable 'PLEX_TOKEN'
+    3. A Plex configured Preferences.xml file specified by the user
+    4. A manually passed token
+
+    If the token is not found in any of these sources, a ValueError is raised.
+
+    Example:
+    ```
+    plex_token = PlexAutoToken(redis_host='localhost', port=6379, db=0, file_path='/path/to/Preferences.xml').get_token()
+    print(plex_token)  # Prints the fetched Plex token
+    ```
+
+    Args:
+        redis_instance (Union[redis.Redis, None], optional): An instance of a Redis database. Defaults to None.
+        redis_host (str, optional): The host of the Redis database. Defaults to 'localhost'.
+        port (int, optional): The port of the Redis database. Defaults to 6379.
+        db (int, optional): The database index of the Redis database. Defaults to 0.
+        file_path (str, optional): The path to the Plex configured Preferences.xml file. Defaults to None.
+        plex_token (str, optional): A manually passed Plex token. Defaults to None.
+    """
+
+    def __init__(self, redis_instance: Union[redis.Redis, None] = None, redis_host: str = 'localhost', port: int = 6379, db: int = 0, file_path: str = None, plex_token: str = None):
+        self.redis_instance = None
+        if redis_instance is not None:
+            self.redis_instance = redis_instance
+        elif redis_host is not None:
+            try:
+                self.redis_instance = redis.Redis(host=redis_host, port=port, db=db)
+            except redis.ConnectionError:
+                print("Unable to connect to Redis at {}:{}. Continuing without Redis.".format(redis_host, port))
+        self.file_path = file_path
+        self.plex_token = plex_token
+
+    def get_token(self) -> str:
+        """
+        Fetches the Plex token from the sources specified in the class docstring.
+
+        Returns:
+            str: The fetched Plex token.
+
+        Raises:
+            ValueError: If the Plex token is not found in any of the sources.
+
+        Example:
+        ```
+        plex_token = PlexAutoToken(redis_host='localhost', port=6379, db=0, file_path='/path/to/Preferences.xml').get_token()
+        print(plex_token)  # Prints the fetched Plex token
+        ```
+        """
+        # Try to fetch the token from the Redis instance
+        try:
+            if self.redis_instance is not None:
+                token = self.redis_instance.get('PLEX_TOKEN')
+                if token is not None:
+                    return token.decode()
+        except redis.RedisError as e:
+            pass
+
+        # Try to fetch the token from the environment variables
+        token = os.getenv('PLEX_TOKEN')
+        if token is not None:
+            return token
+
+        # Try to fetch the token from the Plex configured Preferences.xml file
+        if self.file_path is not None:
+            try:
+                tree = ET.parse(self.file_path)
+                root = tree.getroot()
+                token = root.attrib.get('PlexOnlineToken')
+                if token:
+                    return token
+            except FileNotFoundError:
+                pass
+
+        # Use the manually passed token
+        if self.plex_token is not None:
+            return self.plex_token
+
+        # If the token is not found, raise an error
+        raise ValueError('PLEX_TOKEN not found')

plexflow/core/plex/utils/paginated.py

@@ -0,0 +1,39 @@
+from typing import Iterator
+
+def paginated(func) -> Iterator:
+    """
+    Decorator function that enables paginated retrieval of data from the Plex API.
+
+    Args:
+        func: The function to be decorated.
+
+    Yields:
+        The partial response obtained from the decorated function.
+
+    Raises:
+        Exception: If an error occurs during the retrieval process.
+
+    Returns:
+        The wrapper function that enables paginated retrieval.
+    """
+    def wrapper():
+        container_start = 0
+        container_size = 100
+        container_end_reached = False
+        
+        while not container_end_reached:
+            try:
+                partial_response = func(params={
+                    "X-Plex-Container-Start": container_start,
+                    "X-Plex-Container-Size": container_size,
+                })
+                
+                yield partial_response
+                
+                if len(partial_response.Metadata) == 0:
+                    container_end_reached = True
+                
+                container_start += container_size
+            except Exception as _:
+                container_end_reached = True
+    return wrapper

plexflow/core/plex/watchlist/datatypes.py

@@ -0,0 +1,124 @@
+from dataclasses import dataclass, field
+from typing import Optional, List
+import json
+from dataclasses_json import dataclass_json, Undefined, CatchAll
+
+@dataclass_json(undefined=Undefined.INCLUDE)
+@dataclass
+class PlexImage:
+    """
+    Represents an image with optional alt text, type, and URL.
+
+    Attributes:
+        alt (Optional[str]): The alt text of the image.
+        type (Optional[str]): The type of the image.
+        url (Optional[str]): The URL of the image.
+    """
+    alt: Optional[str] = field(default=None)
+    type: Optional[str] = field(default=None)
+    url: Optional[str] = field(default=None)
+    _catch_all: CatchAll = field(default_factory=dict)
+
+@dataclass_json(undefined=Undefined.INCLUDE)
+@dataclass
+class PlexMetadata:
+    """
+    Represents the metadata of a media item.
+
+    Attributes:
+        Image (Optional[List[Image]]): A list of Image objects associated with the media item.
+        addedAt (Optional[int]): The timestamp when the media item was added.
+        art (Optional[str]): The URL of the artwork of the media item.
+        audienceRating (Optional[float]): The audience rating of the media item.
+        audienceRatingImage (Optional[str]): The URL of the audience rating image.
+        banner (Optional[str]): The URL of the banner image.
+        contentRating (Optional[str]): The content rating of the media item.
+        duration (Optional[int]): The duration of the media item in seconds.
+        guid (Optional[str]): The globally unique identifier of the media item.
+        imdbRatingCount (Optional[int]): The number of IMDb ratings.
+        key (Optional[str]): The key of the media item.
+        originallyAvailableAt (Optional[str]): The original release date of the media item.
+        publicPagesURL (Optional[str]): The URL of the public pages.
+        rating (Optional[float]): The rating of the media item.
+        ratingImage (Optional[str]): The URL of the rating image.
+        ratingKey (Optional[str]): The rating key of the media item.
+        slug (Optional[str]): The slug of the media item.
+        studio (Optional[str]): The studio that produced the media item.
+        tagline (Optional[str]): The tagline of the media item.
+        thumb (Optional[str]): The URL of the thumbnail image.
+        title (Optional[str]): The title of the media item.
+        type (Optional[str]): The type of the media item.
+        userState (Optional[bool]): The user state of the media item.
+        year (Optional[int]): The release year of the media item.
+    """
+
+    Image: Optional[List[PlexImage]] = field(default_factory=list)
+    addedAt: Optional[int] = None
+    art: Optional[str] = None
+    audienceRating: Optional[float] = None
+    audienceRatingImage: Optional[str] = None
+    banner: Optional[str] = None
+    contentRating: Optional[str] = None
+    duration: Optional[int] = None
+    guid: Optional[str] = None
+    imdbRatingCount: Optional[int] = None
+    key: Optional[str] = None
+    originallyAvailableAt: Optional[str] = None
+    publicPagesURL: Optional[str] = None
+    rating: Optional[float] = None
+    ratingImage: Optional[str] = None
+    ratingKey: Optional[str] = None
+    slug: Optional[str] = None
+    studio: Optional[str] = None
+    tagline: Optional[str] = None
+    thumb: Optional[str] = None
+    title: Optional[str] = None
+    type: Optional[str] = None
+    userState: Optional[bool] = None
+    year: Optional[int] = None
+    _catch_all: CatchAll = field(default_factory=dict)
+    
+    def __post_init__(self):
+        self.Image = [PlexImage(**img) if isinstance(img, dict) else img for img in self.Image]
+    
+    @property
+    def is_movie(self):
+        return self.type == "movie"
+
+    @property
+    def is_show(self):
+        return self.type == "show"
+
+@dataclass_json(undefined=Undefined.INCLUDE)
+@dataclass
+class MediaContainer:
+    """
+    Represents a media container with metadata and other properties.
+
+    Attributes:
+        Metadata (Optional[List[PlexMetadata]]): A list of Metadata objects associated with the media container.
+        identifier (Optional[str]): The identifier of the media container.
+        librarySectionID (Optional[str]): The ID of the library section.
+        librarySectionTitle (Optional[str]): The title of the library section.
+        offset (Optional[int]): The offset of the media container.
+        size (Optional[int]): The size of the media container.
+        totalSize (Optional[int]): The total size of the media container.
+    """
+
+    Metadata: Optional[List[PlexMetadata]] = field(default_factory=list)
+    identifier: Optional[str] = None
+    librarySectionID: Optional[str] = None
+    librarySectionTitle: Optional[str] = None
+    offset: Optional[int] = None
+    size: Optional[int] = None
+    totalSize: Optional[int] = None
+    _catch_all: CatchAll = field(default_factory=dict)
+    
+    def __post_init__(self):
+        self.Metadata = [PlexMetadata(**meta) if isinstance(meta, dict) else meta for meta in self.Metadata]
+
+def from_json(json_str: str) -> MediaContainer:
+    try:
+        return MediaContainer(**json.loads(json_str).get("MediaContainer"))
+    except json.JSONDecodeError as e:
+        raise f"Error decoding JSON: {e}"

plexflow/core/plex/watchlist/watchlist.py

@@ -0,0 +1,23 @@
+from plexflow.core.plex.hooks.plex_authorized import PlexAuthorizedHttpHook
+from plexflow.core.plex.watchlist.datatypes import from_json, MediaContainer
+from plexflow.core.plex.utils.paginated import paginated
+from plexflow.core.plex.api.context.authorized import PlexAuthorizedRequestContext
+
+@paginated
+def get_watchlist(**kwargs) -> MediaContainer:
+    """
+    Retrieves the watchlist from the Plex server.
+
+    Args:
+        **kwargs: Additional keyword arguments to be passed to the PlexAuthorizedHttpHook.
+
+    Returns:
+        MediaContainer: The watchlist as a MediaContainer object.
+
+    Raises:
+        None
+
+    """
+    context = PlexAuthorizedRequestContext(base_url="https://metadata.provider.plex.tv")
+    response = context.get(endpoint="/library/sections/watchlist/all", **kwargs)
+    return from_json(response.content.decode("utf-8"))

plexflow/core/storage/object/plexflow_storage.py

@@ -0,0 +1,143 @@
+from pathlib import Path
+from plexflow.core.storage.object.redis_storage import RedisObjectStore
+from typing import Union
+import os
+
+class PlexflowObjectStore:
+    """A class used to represent the Plexflow Object Store.
+
+    Attributes:
+        run_id (str): The run id of the object store.
+        host (str): The host of the Redis server. Defaults to 'localhost'.
+        port (int): The port of the Redis server. Defaults to 6379.
+        db (int): The database index of the Redis server. Defaults to 0.
+        default_ttl (int): The default TTL (in seconds) for the stored objects. Defaults to 3600.
+        root_key (Union[str, Path]): The root key in the object store. Defaults to "@plexflow".
+        bucket_store (RedisObjectStore): The RedisObjectStore instance.
+    """
+
+    def __init__(self, run_id: str, host: str = os.getenv('REDIS_HOST', 'localhost'), port: int = int(os.getenv('REDIS_PORT', 6379)), db: int = 0, default_ttl: int = 3600, root_key: Union[str, Path] = "@plexflow", password=os.getenv('REDIS_PASSWORD', None)):
+        """Initializes the PlexflowObjectStore with the given parameters.
+
+        Args:
+            run_id (str): The run id of the object store.
+            host (str, optional): The host of the Redis server. Defaults to 'localhost'.
+            port (int, optional): The port of the Redis server. Defaults to 6379.
+            db (int, optional): The database index of the Redis server. Defaults to 0.
+            default_ttl (int, optional): The default TTL (in seconds) for the stored objects. Defaults to 3600.
+            root_key (Union[str, Path], optional): The root key in the object store. Defaults to "@plexflow".
+        """
+
+        self.bucket_store = RedisObjectStore(host=host, port=port, db=db, default_ttl=default_ttl, password=password)
+        self.root_key = Path(root_key) if isinstance(root_key, str) else root_key
+        self.run_id = run_id
+
+    @property
+    def bucket(self):
+        """Gets the RedisObjectStore instance.
+
+        Returns:
+            RedisObjectStore: The RedisObjectStore instance.
+        """
+
+        return self.bucket_store
+
+    def make_key(self, name: Union[str, Path]) -> Path:
+        """Constructs a global key by joining root_key and name.
+
+        Args:
+            name (Union[str, Path]): The name to be joined with root_key.
+
+        Returns:
+            Path: The constructed global key.
+        """
+
+        if isinstance(name, str):
+            name = Path(name)
+        return self.root_key / name
+
+    def make_run_key(self, name: Union[str, Path]) -> Path:
+        """Constructs a run-specific key by joining root_key, run_id, and name.
+
+        Args:
+            name (Union[str, Path]): The name to be joined with root_key and run_id.
+
+        Returns:
+            Path: The constructed run-specific key.
+        """
+
+        return self.root_key / self.run_id / name
+
+    def store(self, key: Union[str, Path], obj, use_json=False):
+        """Stores a serialized version of an object in the Redis store permanently.
+
+        Args:
+            key (Union[str, Path]): The key under which the object is stored.
+            obj (Any): The object to be stored.
+            use_json (bool, optional): Whether to use JSON for serialization. Defaults to False.
+        """
+
+        if isinstance(key, Path):
+            key = str(key)
+        self.bucket_store.store(key, obj, use_json)
+
+    def store_temporarily(self, key: Union[str, Path], obj, ttl=None, use_json=False):
+        """Stores a serialized version of an object in the Redis store temporarily.
+
+        Args:
+            key (Union[str, Path]): The key under which the object is stored.
+            obj (Any): The object to be stored.
+            ttl (int, optional): The TTL (in seconds) for the stored object. If not provided, default_ttl is used.
+            use_json (bool, optional): Whether to use JSON for serialization. Defaults to False.
+        """
+
+        if isinstance(key, Path):
+            key = str(key)
+        self.bucket_store.store_temporarily(key, obj, ttl, use_json)
+
+    def retrieve(self, key: Union[str, Path], use_json=False):
+        """Retrieves an object from the Redis store and deserializes it.
+
+        Args:
+            key (Union[str, Path]): The key under which the object is stored.
+            use_json (bool, optional): Whether to use JSON for deserialization. Defaults to False.
+
+        Returns:
+            Any: The deserialized object.
+        """
+
+        if isinstance(key, Path):
+            key = str(key)
+        return self.bucket_store.retrieve(key, use_json)
+
+    def retrieve_keys(self, pattern):
+        """Retrieves all keys matching a given pattern from the Redis store.
+
+        Args:
+            pattern (str): The pattern to match.
+
+        Returns:
+            list: A list of keys matching the pattern.
+
+        Raises:
+            Exception: If an error occurs during retrieving the keys.
+
+        """
+
+        return self.bucket_store.retrieve_keys(pattern)
+
+    def retrieve_values(self, pattern):
+        """Retrieves all values matching a given pattern from the Redis store.
+
+        Args:
+            pattern (str): The pattern to match.
+
+        Returns:
+            list: A list of values matching the pattern.
+
+        Raises:
+            Exception: If an error occurs during retrieving the values.
+
+        """
+
+        return self.bucket_store.retrieve_values(pattern)