plexflow 0.0.64__py3-none-any.whl

plexflow/core/subtitles/providers/oss/utils/response_base.py

@@ -0,0 +1,221 @@
+"""
+Copyright (c) 2023 Omer Duskin.
+
+This file is part of Opensubtitles API wrapper.
+
+Opensubtitles API is free software: you can redistribute it and/or modify
+it under the terms of the MIT License as published by the Massachusetts
+Institute of Technology.
+
+For full details, please see the LICENSE file located in the root
+directory of this project.
+
+This module define base class of opensubtitles responses.
+"""
+
+import ast
+import json
+import functools
+import logging
+from typing import Any
+from datetime import datetime, date
+
+logger = logging.getLogger(__name__)
+
+
+def rgetattr(obj, attr, *args):
+    """Support getattr on nested subobjects / chained properties.
+
+    For example, for d = DotDict(aa={"bb": cc"})
+    rgetattr(d, "aa.bb") will return "cc"
+    """
+
+    def _getattr(obj, attr):
+        return getattr(obj, attr, *args)
+
+    return functools.reduce(_getattr, [obj] + attr.split("."))
+
+
+def rsetattr(obj, attr, val):
+    """Support setattr on nested subobjects / chained properties."""
+    pre, _, post = attr.rpartition(".")
+    return setattr(rgetattr(obj, pre) if pre else obj, post, val)
+
+
+class ResponseJSONEncoder(json.JSONEncoder):
+    """JSON encoder class for handling custom serialization of Response objects.
+
+    Handle the SearchResponse that consists of Subtitle list.
+    """
+
+    def default(self, o: object) -> Any:
+        """Override the default method of the JSONEncoder class.
+
+        Serializes objects with a 'to_dict' method using 'to_dict'.
+        Falls back to the super class's default method for other objects.
+
+        Parameters:
+            o (object): The object to be serialized.
+
+        Returns:
+            Any: The serialized representation of the object.
+        """
+        if hasattr(o, "to_dict"):
+            return o.to_dict()
+        return super().default(o)
+
+
+class BaseResponse:
+    """
+    Base class for API responses.
+
+    Attributes:
+        Meta (class): Meta class for BaseResponse.
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize the BaseResponse object with optional keyword arguments."""
+        pass
+
+    class Meta:
+        """Meta class for BaseResponse."""
+
+        abstract = True
+
+    def __str__(self):
+        """Return a string representation of the BaseResponse object."""
+        return self.__repr__()
+
+    def __repr__(self):
+        """Return a string representation of the BaseResponse object."""
+        main_field = getattr(self.Meta, "main_field", "")
+        main_field_value = f" {getattr(self, main_field)}" if main_field else ""
+        return f"<{self.__class__.__name__}{main_field_value}>"
+
+    def fields(self):
+        """Return a dictionary of attributes and their values."""
+        attributes = vars(self)
+        return attributes
+
+    def attr(
+        self,
+        key,
+        default=None,
+        cast=None,
+        jsonify=False,
+        to_epoch=False,
+        to_date_str=None,
+        str_date_format=None,
+        auto_format=False,
+    ):
+        """Get and potentially format an attribute of the BaseResponse object.
+
+        Args:
+            key (str): The name of the attribute to retrieve.
+            default: The default value to return if the attribute is not found.
+            cast (type): The type to which the attribute should be cast.
+            jsonify (bool): Whether to parse the attribute as JSON.
+            to_epoch (bool): Whether to convert the attribute to an epoch timestamp.
+            to_date_str (str): The date string format to use.
+            str_date_format (str): The date string format to use.
+            auto_format (bool): Whether to automatically format the attribute.
+
+        Returns:
+            The formatted attribute value.
+
+        Raises:
+            Exception: If an error occurs while retrieving or formatting the attribute.
+        """
+        try:
+            value = rgetattr(self, key, default)
+            value = value if value is not None else default
+            if not value:
+                return value
+            if auto_format:
+                if isinstance(value, (datetime, date)):
+                    to_date_str = True
+                if isinstance(value, (list, dict)):
+                    jsonify = True
+                if isinstance(value, str) and value.isdigit():
+                    cast = int
+            if cast:
+                value = cast(value)
+            if jsonify:
+                value = ast.literal_eval(value)
+            if to_date_str:
+                str_date_format = str_date_format or "%Y-%m-%dT%H:%M:%S"
+                value = value.strftime(str_date_format)
+            if to_epoch:
+                value = value.timestamp()
+            return value
+        except Exception as ex:
+            raise Exception(f"Unable to get field attribute: `{key}` of {self} ex: {ex}")
+
+    def styling(self, value, camel_case=False, dotted_key_merge=False):
+        """Style a value according to specified formatting options.
+
+        Args:
+            value (str): The value to be styled.
+            camel_case (bool): Whether to use camelCase formatting.
+            dotted_key_merge (bool): Whether to merge keys separated by dots.
+
+        Returns:
+            The styled value.
+
+        Raises:
+            Exception: If an error occurs while styling the value.
+        """
+        try:
+            if dotted_key_merge:
+                value = value.replace(".", "_")
+            if camel_case:
+                tmp = value.replace("_", " ").title().replace(" ", "")
+                return tmp[0].lower() + tmp[1:]
+            return value
+        except Exception as ex:
+            raise Exception(f"Unable to set styling for value: {value}: {ex}")
+
+    def to_dict(self, ignore_none=False, dotted_key_to_dict=False) -> dict:
+        """Convert the BaseResponse object to a dictionary.
+
+        Args:
+            ignore_none (bool): Whether to exclude attributes with None values.
+            dotted_key_to_dict (bool): Whether to convert dotted keys to nested dictionaries.
+
+        Returns:
+            A dictionary representation of the BaseResponse object.
+
+        Raises:
+            Exception: If an error occurs while converting the object to a dictionary.
+        """
+        returned_fields = self.fields()
+        key_styling = functools.partial(self.styling, camel_case=False, dotted_key_merge=False)
+        try:
+            fields_data = {}
+            for field in returned_fields:
+                try:
+                    fields_data[key_styling(field)] = self.attr(key=field)
+                except Exception as ex:
+                    logger.warning(f"Failed to get value for {field}: {ex}")
+            if ignore_none:
+                fields_data = {k: v for k, v in fields_data.items() if v is not None}
+            if dotted_key_to_dict:
+                new_fields_data = {}
+                for key, value in fields_data.items():
+                    items = key.split(".")
+                    if len(items) > 1:
+                        new_fields_data.setdefault(items[0], {})[items[1]] = value
+                    else:
+                        new_fields_data[key] = value
+                fields_data = new_fields_data
+        except Exception as ex:
+            raise Exception(f"Unable to get fields: {returned_fields}, ex: {ex}")
+        return fields_data
+
+    def to_json(self) -> str:
+        """Convert the object to a JSON-formatted string.
+
+        Returns:
+           str: The JSON-formatted string representation of the object.
+        """
+        return json.dumps(self.to_dict(), cls=ResponseJSONEncoder)

plexflow/core/subtitles/providers/oss/utils/responses.py

@@ -0,0 +1,176 @@
+import logging
+from datetime import datetime
+
+from plexflow.core.subtitles.providers.oss.utils.response_base import BaseResponse
+
+logger = logging.getLogger(__name__)
+
+
+class LoginResponse(BaseResponse):
+    """Response class for the login results."""
+
+    def __init__(self, user, token, status):
+        """
+        Initialize a LoginResponse object with user data, token, and status.
+
+        Args:
+            user (User): An dict representing the user data.
+            token (str): The authentication token.
+            status (int): The status code of the login response (e.g., 200 for success).
+
+
+        Example:
+            # Create a LoginResponse object
+            user_data = {allowed_translations=1, allowed_downloads=20, level='Sub leecher', user_id=502210,
+                             ext_installed=False, vip=False}
+            login_response = LoginResponse(user=user_data, token='eyJ0eXAiOiJKV1Qi...', status=200)
+        """
+        self.user = user
+        self.token = token
+        self.status = status
+
+    class Meta:
+        """Meta class for LoginResponse."""
+
+        main_field = "status"
+
+
+class SearchResponse(BaseResponse):
+    """Response class for search results."""
+
+    def __init__(self, total_pages, total_count, per_page, page, data, query_string=None):
+        """Initialize the SearchResponse object with search-related data.
+
+        Args:
+            total_pages (int): The total number of pages in the search results.
+            total_count (int): The total number of search results.
+            per_page (int): The number of results per page.
+            page (int): The current page number.
+            data (list): A list of data items for each search result.
+            query_string (str): The search query string.
+        """
+        self.total_pages = total_pages
+        self.total_count = total_count
+        self.per_page = per_page
+        self.page = page
+        self.data = [Subtitle(item) for item in data]
+        self.query_string = query_string
+
+    class Meta:
+        """Meta class for SearchResponse."""
+
+        main_field = "query_string"
+
+
+class DiscoverLatestResponse(BaseResponse):
+    """Response class for discover latest results."""
+
+    def __init__(self, total_pages, total_count, page, data):
+        """Initialize the DiscoverLatestResponse object with latest discovery data.
+
+        Args:
+            total_pages (int): The total number of pages in the discovery results.
+            total_count (int): The total number of discovery results.
+            page (int): The current page number.
+            data (list): A list of data items for each discovery result.
+        """
+        self.total_pages = total_pages
+        self.total_count = total_count
+        self.page = page
+        self.data = [Subtitle(item) for item in data]
+        self.created_at = datetime.now()
+        self.created_at_str = self.created_at.strftime("%Y-%m-%d %H:%M%z")
+
+    class Meta:
+        """Meta class for DiscoverLatestResponse."""
+
+        main_field = "created_at_str"
+
+
+class DiscoverMostDownloadedResponse(DiscoverLatestResponse):
+    """Response class for the discovre most downloaded results."""
+
+    pass
+
+
+class DownloadResponse(BaseResponse):
+    """Response class for the download subtitles results."""
+
+    def __init__(self, response_data):
+        """Initialize the DownloadResponse object with download-related data.
+
+        Args:
+            response_data (dict): A dictionary containing download-related information.
+        """
+        self.link = response_data.get("link")
+        self.file_name = response_data.get("file_name")
+        self.requests = response_data.get("requests")
+        self.remaining = response_data.get("remaining")
+        self.message = response_data.get("message")
+        self.reset_time = response_data.get("reset_time")
+        self.reset_time_utc = response_data.get("reset_time_utc")
+        self.uk = response_data.get("uk")
+        self.uid = response_data.get("uid")
+        self.ts = response_data.get("ts")
+
+    class Meta:
+        """Meta class for DownloadResponse."""
+
+        main_field = "file_name"
+
+
+class Subtitle(BaseResponse):
+    """Object representing a subtitle data given from API."""
+
+    def __init__(self, data_dict):
+        """Initialize the Subtitle object with subtitle-related data.
+
+        Args:
+            data_dict (dict): A dictionary containing subtitle-related information.
+        """
+        self.id = data_dict.get("id")
+        self.type = data_dict.get("type")
+        self.subtitle_id = data_dict.get("attributes", {}).get("subtitle_id")
+        self.language = data_dict.get("attributes", {}).get("language")
+        self.download_count = data_dict.get("attributes", {}).get("download_count")
+        self.new_download_count = data_dict.get("attributes", {}).get("new_download_count")
+        self.hearing_impaired = data_dict.get("attributes", {}).get("hearing_impaired")
+        self.hd = data_dict.get("attributes", {}).get("hd")
+        self.fps = data_dict.get("attributes", {}).get("fps")
+        self.votes = data_dict.get("attributes", {}).get("votes")
+        self.ratings = data_dict.get("attributes", {}).get("ratings")
+        self.from_trusted = data_dict.get("attributes", {}).get("from_trusted")
+        self.foreign_parts_only = data_dict.get("attributes", {}).get("foreign_parts_only")
+        self.upload_date = data_dict.get("attributes", {}).get("upload_date")
+        self.ai_translated = data_dict.get("attributes", {}).get("ai_translated")
+        self.machine_translated = data_dict.get("attributes", {}).get("machine_translated")
+        self.release = data_dict.get("attributes", {}).get("release")
+        self.comments = data_dict.get("attributes", {}).get("comments")
+        self.legacy_subtitle_id = data_dict.get("attributes", {}).get("legacy_subtitle_id")
+        self.uploader_id = data_dict.get("attributes", {}).get("uploader", {}).get("uploader_id")
+        self.uploader_name = data_dict.get("attributes", {}).get("uploader", {}).get("name")
+        self.uploader_rank = data_dict.get("attributes", {}).get("uploader", {}).get("rank")
+        self.feature_id = data_dict.get("attributes", {}).get("feature_details", {}).get("feature_id")
+        self.feature_type = data_dict.get("attributes", {}).get("feature_details", {}).get("feature_type")
+        self.year = data_dict.get("attributes", {}).get("feature_details", {}).get("year")
+        self.title = data_dict.get("attributes", {}).get("feature_details", {}).get("title")
+        self.movie_name = data_dict.get("attributes", {}).get("feature_details", {}).get("movie_name")
+        self.imdb_id = data_dict.get("attributes", {}).get("feature_details", {}).get("imdb_id")
+        self.tmdb_id = data_dict.get("attributes", {}).get("feature_details", {}).get("tmdb_id")
+        self.season_number = data_dict.get("attributes", {}).get("feature_details", {}).get("season_number")
+        self.episode_number = data_dict.get("attributes", {}).get("feature_details", {}).get("episode_number")
+        self.parent_imdb_id = data_dict.get("attributes", {}).get("feature_details", {}).get("parent_imdb_id")
+        self.parent_title = data_dict.get("attributes", {}).get("feature_details", {}).get("parent_title")
+        self.parent_tmdb_id = data_dict.get("attributes", {}).get("feature_details", {}).get("parent_tmdb_id")
+        self.parent_feature_id = data_dict.get("attributes", {}).get("feature_details", {}).get("parent_feature_id")
+        self.url = data_dict.get("attributes", {}).get("url")
+        self.related_links = data_dict.get("attributes", {}).get("related_links", [])
+        self.files = data_dict.get("attributes", {}).get("files", [])
+
+        self.file_id = self.files[0].get("file_id") if self.files else None
+        self.file_name = self.files[0].get("file_name") if self.files else None
+
+    class Meta:
+        """Meta class for Subtitle."""
+
+        main_field = "release"