plexflow 0.0.64__py3-none-any.whl

plexflow/core/subtitles/providers/oss/unlimited_oss.py

@@ -0,0 +1,231 @@
+import redis
+import yaml
+from typing import List, Dict, Optional, Iterator
+from contextlib import contextmanager
+from datetime import datetime
+from plexflow.core.subtitles.providers.oss.oss import OpenSubtitles
+from plexflow.core.subtitles.providers.oss.utils.exceptions import OpenSubtitlesDownloadQuotaReachedException
+from plexflow.core.subtitles.providers.oss.utils.download_client import DownloadClient
+from plexflow.core.subtitles.providers.oss.utils.languages import language_codes
+from plexflow.core.subtitles.providers.oss.utils.responses import SearchResponse, Subtitle, DiscoverLatestResponse, DiscoverMostDownloadedResponse
+import logging
+import hashlib
+import json
+import logging
+from plexflow.utils.hooks.redis import UniversalRedisHook
+from plexflow.logging.log_setup import logger
+
+class OpenSubtitlesManager:
+    """
+    A manager class for interacting with the OpenSubtitles API.
+
+    This class provides a convenient way to manage multiple credentials and handle the rate limits of the OpenSubtitles API.
+    It allows you to create an instance of the OpenSubtitles class using a valid credential, and automatically handles
+    credential rotation and blacklisting.
+
+    Usage:
+    credentials = [
+        {
+            'user_agent': 'UserAgent1',
+            'api_key': 'APIKey1',
+            'username': 'Username1',
+            'password': 'Password1'
+        },
+        {
+            'user_agent': 'UserAgent2',
+            'api_key': 'APIKey2',
+            'username': 'Username2',
+            'password': 'Password2'
+        }
+    ]
+
+    with OpenSubtitlesManager(credentials) as instance:
+        # Use the instance to make API calls
+        subtitles = instance.search_subtitles(...)
+
+    Args:
+        credentials (List[Dict[str, str]]): A list of dictionaries containing the credentials for accessing the OpenSubtitles API.
+            Each dictionary should contain the following keys: 'user_agent', 'api_key', 'username', 'password'.
+        redis_host (str, optional): The host of the Redis server used for blacklisting credentials. Defaults to 'localhost'.
+        redis_port (int, optional): The port of the Redis server used for blacklisting credentials. Defaults to 6379.
+    """
+    REDIS_KEY_PREFIX = "blacklist"
+    REDIS_DEFAULT_PORT = 6379
+    DEFAULT_TTL = 60*60  # 1 hour
+
+    def __init__(self, credentials: List[Dict[str, str]], redis_hook: UniversalRedisHook = None, **kwargs):
+        """
+        Initializes an instance of the OpenSubtitlesManager class.
+
+        Args:
+            credentials (List[Dict[str, str]]): A list of dictionaries containing the credentials for accessing the OpenSubtitles API.
+                Each dictionary should contain the following keys: 'user_agent', 'api_key', 'username', 'password'.
+            redis_host (str, optional): The host of the Redis server used for blacklisting credentials. Defaults to 'localhost'.
+            redis_port (int, optional): The port of the Redis server used for blacklisting credentials. Defaults to 6379.
+        """
+        self.credentials = credentials
+        self.redis_hook = redis_hook
+        self.current_instance = None
+        self.current_credential = None
+        self.ignore_blacklist = kwargs.get('ignore_blacklist', False)
+        self.logger = logger
+        self.instances = {}
+        
+    @classmethod
+    def from_yaml(cls, yaml_file: str, redis_hook: UniversalRedisHook = None, **kwargs) -> 'OpenSubtitlesManager':
+        """
+        Creates an instance of the OpenSubtitlesManager class from a YAML file.
+
+        Args:
+            yaml_file (str): The path to the YAML file containing the credentials.
+            redis_host (str, optional): The host of the Redis server used for blacklisting credentials. Defaults to 'localhost'.
+            redis_port (int, optional): The port of the Redis server used for blacklisting credentials. Defaults to 6379.
+
+        Returns:
+            OpenSubtitlesManager: The created instance of the OpenSubtitlesManager class.
+        """
+        with open(yaml_file, 'r') as file:
+            credentials = yaml.safe_load(file)
+        return cls(credentials=credentials, redis_hook=redis_hook, **kwargs)
+
+    def __enter__(self) -> OpenSubtitles:
+        """
+        Enters the context and returns a valid instance of the OpenSubtitles class.
+
+        This context manager handles credential rotation and blacklisting.
+        If a OpenSubtitlesDownloadQuotaReachedException is raised inside the context manager,
+        the current credential will be blacklisted for a certain duration (default is 60 seconds)
+        and the exception will be re-raised.
+
+        Returns:
+            OpenSubtitles: The current valid instance of the OpenSubtitles class.
+        """
+        self.current_credential = self.get_next_available_credential()
+        self.current_instance = self.create_open_subtitles_instance(self.current_credential)
+        return self.current_instance
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """
+        Exits the context and cleans up the current instance and credential.
+
+        Args:
+            exc_type: The type of the exception raised, if any.
+            exc_value: The exception raised, if any.
+            traceback: The traceback of the exception raised, if any.
+        """
+        if exc_type == OpenSubtitlesDownloadQuotaReachedException:
+            self.blacklist_credential()
+            self.logger.warning(f"OpenSubtitlesDownloadQuotaReachedException occurred. Credential blacklisted for {self.DEFAULT_TTL} seconds.")
+            self.current_instance = None
+            self.current_credential = None
+            return False  # Re-raise the exception
+
+        self.current_instance = None
+        self.current_credential = None
+
+
+    def get_next_available_credential(self) -> Dict[str, str]:
+        """
+        Returns the next available credential from the list of credentials.
+
+        Raises:
+            Exception: If no available credentials are found.
+
+        Returns:
+            Dict[str, str]: The next available credential.
+        """
+        for credential in self.credentials["items"]:
+            login = credential.get('login', {})
+            username = login.get('username')
+            password = login.get('password')
+            fields = credential.get('fields', [])
+            api_key = None
+            user_agent = None
+            for field in fields:
+                if field['name'] == 'API Key':
+                    api_key = field['value']
+                elif field['name'] == 'User Agent':
+                    user_agent = field['value']
+            
+            credential_data = {
+                'username': username,
+                'password': password,
+                'api_key': api_key,
+                'user_agent': user_agent
+            }
+            
+            if self.ignore_blacklist or not self.is_credential_blacklisted(credential_data):
+                return credential_data
+
+        self.logger.error("No available credentials found")
+        raise Exception("No available credentials found")
+
+    def create_open_subtitles_instance(self, credential: Dict[str, str]) -> OpenSubtitles:
+        """
+        Creates an instance of the OpenSubtitles class using the given credential.
+
+        Args:
+            credential (Dict[str, str]): The credential to use for creating the instance.
+
+        Returns:
+            OpenSubtitles: The created instance of the OpenSubtitles class.
+        """
+        api_key = credential.get('api_key')
+        user_agent = credential.get('user_agent')
+        username = credential.get('username')
+        password = credential.get('password')
+        
+        self.logger.debug(f"Username: {username}, User Agent: {user_agent}")
+        
+        # Check if instance already exists for the given credential
+        if api_key in self.instances:
+            return self.instances[api_key]
+        
+        instance = OpenSubtitles(user_agent, api_key, redis_hook=self.redis_hook)
+        instance.login(username, password)
+        
+        # Cache the instance for later reuse
+        self.instances[api_key] = instance
+        
+        return instance
+
+    def is_credential_blacklisted(self, credential: Dict[str, str]) -> bool:
+        """
+        Checks if the given credential is blacklisted.
+
+        Args:
+            credential (Dict[str, str]): The credential to check.
+
+        Returns:
+            bool: True if the credential is blacklisted, False otherwise.
+        """
+        key = self.generate_credential_key(credential)
+        self.logger.debug(f"Generated credential key: {key}")
+        return self.redis_hook.get_conn().exists(key)
+
+    def blacklist_credential(self):
+        """
+        Blacklists the current credential for the specified duration.
+
+        """
+        key = self.generate_credential_key(self.current_credential)
+        self.redis_hook.get_conn().setex(key, self.DEFAULT_TTL, 'blacklisted')
+        self.logger.debug(f"Credential blacklisted for {self.DEFAULT_TTL} seconds: {self.current_credential}")
+        self.logger.debug(f"Blacklisted credential key: {key}")
+
+    def generate_credential_key(self, credential: Dict[str, str]) -> str:
+        """
+        Generates the key for the given credential.
+
+        Args:
+            credential (Dict[str, str]): The credential to generate the key for.
+
+        Returns:
+            str: The generated key.
+        """
+        credential_sorted = json.dumps(credential, sort_keys=True)
+        key_parts = [
+            self.REDIS_KEY_PREFIX,
+            hashlib.sha256(credential_sorted.encode()).hexdigest()
+        ]
+        return ":".join(key_parts)

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

@@ -0,0 +1,63 @@
+import os
+import json
+import logging
+from typing import Optional
+from pathlib import Path
+
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_CONFIG_PATH = "~/.config/opensubtitlescom/config.json"
+
+
+class Config:
+    """Represents the configuration for the OpenSubtitles CLI."""
+
+    def __init__(self, path: Optional[Path] = None):
+        """Initialize the Config object.
+
+        Args:
+            path (Path): The path to the configuration file.
+
+        Note:
+            If the configuration file exists, the class is initialized with its content.
+            If not, the class creates the necessary directory structure for the configuration file.
+        """
+        self._path: Path = (Path(path or DEFAULT_CONFIG_PATH)).expanduser()
+        self.username: Optional[str] = None
+        self.password: Optional[str] = None
+        self.language: str = "en"
+
+        if self._path.exists():
+            data = json.loads(self._path.read_text())
+            self.__dict__.update(data)
+
+    def verify_config_dir(self):
+        """Verify the existence of the directory specified by self._path.
+
+        If the directory does not exist, attempts to create it.
+
+        Returns:
+            bool: True if the directory exists or is successfully created, False otherwise.
+        """
+        if self._path.exists():
+            return True
+        path = self._path.parent
+        try:
+            os.makedirs(path, exist_ok=True)
+            return True
+        except OSError as e:
+            if e.errno == 30:
+                logger.error(f"Error: {e}. Check if the file system is read-only or permissions are insufficient.")
+            else:
+                logger.error(f"Error: {e}")
+            return False
+
+    def save(self):
+        """Save the configuration to the specified file."""
+        if not self.verify_config_dir():
+            logger.error("Failed to save config.")
+            return False
+        data = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+        self._path.write_text(json.dumps(data, indent=4))
+        return True

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

@@ -0,0 +1,22 @@
+import requests
+
+
+class DownloadClient:
+    """A client to download files URLs with."""
+
+    def __init__(self):
+        """Initialize the DownloadClient object."""
+        pass
+
+    def get(self, url: str) -> bytes:
+        """Download the subtitle referenced by url.
+
+        Args:
+            url: The url of the subtitle to download.
+
+        Returns:
+            The subtitles data in bytes.
+        """
+        download_remote_file = requests.get(url)
+
+        return download_remote_file.content

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

@@ -0,0 +1,35 @@
+from datetime import datetime
+
+class OpenSubtitlesException(Exception):
+    """Custom exception class for the OpenSubtitles wrapper."""
+
+    def __init__(self, message: str):
+        """
+        Initialize the custom exception.
+
+        :param message: exception message.
+        """
+        self.message = message
+
+
+class OpenSubtitlesDownloadQuotaReachedException(Exception):
+    def __init__(self, message: str, reset_time: datetime):
+        """
+        Initialize the custom exception.
+
+        :param message: exception message.
+        """
+        self.message = message
+        self.reset_time = reset_time
+
+
+class OpenSubtitlesFileException(Exception):
+    """Custom exception class for files operations in OpenSubtitles wrapper."""
+
+    def __init__(self, message: str):
+        """
+        Initialize the custom exception.
+
+        :param message: exception message.
+        """
+        self.message = message

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

@@ -0,0 +1,83 @@
+import struct
+import hashlib
+
+from pathlib import Path
+
+from plexflow.core.subtitles.providers.oss.utils.exceptions import OpenSubtitlesFileException
+
+
+class FileUtils:
+    """Expose file utilities functions."""
+
+    def __init__(self, path: Path):
+        """Initialize the File object.
+
+        Args:
+            path: The Path of the file.
+        """
+        self.path = path
+
+    def write(self, content: bytes) -> None:
+        """Write bytes to a file Path.
+
+        Args:
+            content: The content of the file to be written.
+        Raises:
+            FileNotFoundError if the Path does not exist.
+            PermissionError if the filesystem permissions deny the operation.
+        """
+        self.path.write_bytes(content)
+
+    def delete(self) -> None:
+        """Delete a file Path.
+
+        Raises:
+            FileNotFoundError if the Path does not exist.
+        """
+        self.path.unlink()
+
+    def exists(self) -> bool:
+        """Confirm whether a file Path exists or not.
+
+        Raises:
+            PermissionError if the filesystem permissions deny the operation.
+        """
+        return self.path.exists()
+
+    def get_hash(self):
+        """Return the hash code of a file.
+
+        Original from: https://trac.opensubtitles.org/projects/opensubtitles/wiki/HashSourceCodes.
+
+        Returns:
+            - hash - hash code of a file
+        """
+        if not self.exists():
+            raise OpenSubtitlesFileException(f"File not exists: {self.path}")
+        size = self.path.stat().st_size
+        longlongformat = "q"  # long long
+        bytesize = struct.calcsize(longlongformat)
+
+        if int(size) < 65536 * 2:
+            raise OpenSubtitlesFileException("SizeError")
+
+        with open(self.path, "rb") as file_obj:
+            hash = size
+            for _ in range(65536 // bytesize):
+                buffer = file_obj.read(bytesize)
+                (l_value,) = struct.unpack(longlongformat, buffer)
+                hash += l_value
+                hash = hash & 0xFFFFFFFFFFFFFFFF  # to remain as 64bit number
+
+            file_obj.seek(max(0, int(size) - 65536), 0)
+            for _ in range(65536 // bytesize):
+                buffer = file_obj.read(bytesize)
+                (l_value,) = struct.unpack(longlongformat, buffer)
+                hash += l_value
+                hash = hash & 0xFFFFFFFFFFFFFFFF
+
+        return str("%016x" % hash)
+
+    def get_md5(self):
+        """Return the md5 of a file."""
+        return hashlib.md5(self.path.read_bytes()).hexdigest()

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

@@ -0,0 +1,78 @@
+language_codes = {
+    "af": "Afrikaans",
+    "sq": "Albanian",
+    "ar": "Arabic",
+    "an": "Aragonese",
+    "hy": "Armenian",
+    "at": "Asturian",
+    "eu": "Basque",
+    "be": "Belarusian",
+    "bn": "Bengali",
+    "bs": "Bosnian",
+    "br": "Breton",
+    "bg": "Bulgarian",
+    "my": "Burmese",
+    "ca": "Catalan",
+    "zh-cn": "Chinese (simplified)",
+    "cs": "Czech",
+    "da": "Danish",
+    "nl": "Dutch",
+    "en": "English",
+    "eo": "Esperanto",
+    "et": "Estonian",
+    "fi": "Finnish",
+    "fr": "French",
+    "ka": "Georgian",
+    "de": "German",
+    "gl": "Galician",
+    "el": "Greek",
+    "he": "Hebrew",
+    "hi": "Hindi",
+    "hr": "Croatian",
+    "hu": "Hungarian",
+    "is": "Icelandic",
+    "id": "Indonesian",
+    "it": "Italian",
+    "ja": "Japanese",
+    "kk": "Kazakh",
+    "km": "Khmer",
+    "ko": "Korean",
+    "lv": "Latvian",
+    "lt": "Lithuanian",
+    "lb": "Luxembourgish",
+    "mk": "Macedonian",
+    "ml": "Malayalam",
+    "ms": "Malay",
+    "ma": "Manipuri",
+    "mn": "Mongolian",
+    "no": "Norwegian",
+    "oc": "Occitan",
+    "fa": "Persian",
+    "pl": "Polish",
+    "pt-pt": "Portuguese",
+    "ru": "Russian",
+    "sr": "Serbian",
+    "si": "Sinhalese",
+    "sk": "Slovak",
+    "sl": "Slovenian",
+    "es": "Spanish",
+    "sw": "Swahili",
+    "sv": "Swedish",
+    "sy": "Syriac",
+    "ta": "Tamil",
+    "te": "Telugu",
+    "tl": "Tagalog",
+    "th": "Thai",
+    "tr": "Turkish",
+    "uk": "Ukrainian",
+    "ur": "Urdu",
+    "uz": "Uzbek",
+    "vi": "Vietnamese",
+    "ro": "Romanian",
+    "pt-br": "Portuguese (Brazilian)",
+    "me": "Montenegrin",
+    "zh-tw": "Chinese (traditional)",
+    "ze": "Chinese bilingual",
+    "nb": "Norwegian Bokmal",
+    "se": "Northern Sami",
+}