StreamingCommunity 3.2.7__py3-none-any.whl → 3.2.9__py3-none-any.whl

StreamingCommunity/Util/http_client.py

@@ -0,0 +1,201 @@
+# 09.08.25
+from __future__ import annotations
+
+import time
+import random
+from typing import Any, Dict, Optional, Union
+
+
+# External library
+import httpx
+
+
+# Logic class
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_userAgent
+
+
+# Defaults from config
+def _get_timeout() -> int:
+    try:
+        return int(config_manager.get_int("REQUESTS", "timeout"))
+    except Exception:
+        return 20
+
+
+def _get_max_retry() -> int:
+    try:
+        return int(config_manager.get_int("REQUESTS", "max_retry"))
+    except Exception:
+        return 3
+
+
+def _get_verify() -> bool:
+    try:
+        return bool(config_manager.get_bool("REQUESTS", "verify"))
+    except Exception:
+        return True
+
+
+def _get_proxies() -> Optional[Dict[str, str]]:
+    """Return proxies dict if present in config and non-empty, else None."""
+    try:
+        proxies = config_manager.get_dict("REQUESTS", "proxy")
+        if not isinstance(proxies, dict):
+            return None
+        # Normalize empty strings to None (httpx ignores None)
+        cleaned: Dict[str, str] = {}
+        for scheme, url in proxies.items():
+            if isinstance(url, str) and url.strip():
+                cleaned[scheme] = url.strip()
+        return cleaned or None
+    except Exception:
+        return None
+
+
+def _default_headers(extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+    headers = {"User-Agent": get_userAgent()}
+    if extra:
+        headers.update(extra)
+    return headers
+
+
+def create_client(
+    *,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    http2: bool = False,
+    follow_redirects: bool = True,
+) -> httpx.Client:
+    """Factory for a configured httpx.Client."""
+    return httpx.Client(
+        headers=_default_headers(headers),
+        cookies=cookies,
+        timeout=timeout if timeout is not None else _get_timeout(),
+        verify=_get_verify() if verify is None else verify,
+        follow_redirects=follow_redirects,
+        http2=http2,
+        proxy=proxies if proxies is not None else _get_proxies(),
+    )
+
+
+def create_async_client(
+    *,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    http2: bool = False,
+    follow_redirects: bool = True,
+) -> httpx.AsyncClient:
+    """Factory for a configured httpx.AsyncClient."""
+    return httpx.AsyncClient(
+        headers=_default_headers(headers),
+        cookies=cookies,
+        timeout=timeout if timeout is not None else _get_timeout(),
+        verify=_get_verify() if verify is None else verify,
+        follow_redirects=follow_redirects,
+        http2=http2,
+        proxies=proxies if proxies is not None else _get_proxies(),
+    )
+
+
+def _sleep_with_backoff(attempt: int, base: float = 1.1, cap: float = 10.0) -> None:
+    """Exponential backoff with jitter."""
+    delay = min(base * (2 ** attempt), cap)
+    # Add small jitter to avoid thundering herd
+    delay += random.uniform(0.0, 0.25)
+    time.sleep(delay)
+
+
+def fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    params: Optional[Dict[str, Any]] = None,
+    data: Optional[Any] = None,
+    json: Optional[Any] = None,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    follow_redirects: bool = True,
+    http2: bool = False,
+    max_retry: Optional[int] = None,
+    return_content: bool = False,
+) -> Optional[Union[str, bytes]]:
+    """
+    Perform an HTTP request with retry. Returns text or bytes according to return_content.
+    Returns None if all retries fail.
+    """
+    attempts = max_retry if max_retry is not None else _get_max_retry()
+
+    with create_client(
+        headers=headers,
+        cookies=cookies,
+        timeout=timeout,
+        verify=verify,
+        proxies=proxies,
+        http2=http2,
+        follow_redirects=follow_redirects,
+    ) as client:
+        for attempt in range(attempts):
+            try:
+                resp = client.request(method, url, params=params, data=data, json=json)
+                resp.raise_for_status()
+                return resp.content if return_content else resp.text
+            except Exception:
+                if attempt + 1 >= attempts:
+                    break
+                _sleep_with_backoff(attempt)
+        return None
+
+
+async def async_fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    params: Optional[Dict[str, Any]] = None,
+    data: Optional[Any] = None,
+    json: Optional[Any] = None,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    follow_redirects: bool = True,
+    http2: bool = False,
+    max_retry: Optional[int] = None,
+    return_content: bool = False,
+) -> Optional[Union[str, bytes]]:
+    """
+    Async HTTP request with retry. Returns text or bytes according to return_content.
+    Returns None if all retries fail.
+    """
+    attempts = max_retry if max_retry is not None else _get_max_retry()
+
+    async with create_async_client(
+        headers=headers,
+        cookies=cookies,
+        timeout=timeout,
+        verify=verify,
+        proxies=proxies,
+        http2=http2,
+        follow_redirects=follow_redirects,
+    ) as client:
+        for attempt in range(attempts):
+            try:
+                resp = await client.request(method, url, params=params, data=data, json=json)
+                resp.raise_for_status()
+                return resp.content if return_content else resp.text
+            except Exception:
+                if attempt + 1 >= attempts:
+                    break
+                # Use same backoff logic for async by sleeping in thread (short duration)
+                _sleep_with_backoff(attempt)
+        return None

StreamingCommunity/Util/message.py

@@ -14,7 +14,7 @@ from StreamingCommunity.Util.config_json import config_manager
 
 # Variable
 console = Console()
-CLEAN = config_manager.get_bool('DEFAULT', 'clean_console')
+CLEAN = config_manager.get_bool('DEFAULT', 'show_message')
 SHOW = config_manager.get_bool('DEFAULT', 'show_message')
 
 

StreamingCommunity/Util/os.py

@@ -5,7 +5,6 @@ import os
 import glob
 import sys
 import shutil
-import hashlib
 import logging
 import platform
 import inspect
@@ -432,10 +431,11 @@ class OsSummary:
 
         if not self.mp4decrypt_path:
             console.log("[yellow]Warning: mp4decrypt not found")
-
-        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]'{self.ffmpeg_path}'[/bold yellow][white], [red]ffprobe '[bold yellow]{self.ffprobe_path}'[/bold yellow]")
-        if self.mp4decrypt_path:
-            console.print(f"[cyan]Path: [red]mp4decrypt [bold yellow]'{self.mp4decrypt_path}'[/bold yellow]")
+        
+        ffmpeg_str = f"'{self.ffmpeg_path}'" if self.ffmpeg_path else "None"
+        ffprobe_str = f"'{self.ffprobe_path}'" if self.ffprobe_path else "None"
+        mp4decrypt_str = f"'{self.mp4decrypt_path}'" if self.mp4decrypt_path else "None"
+        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]{ffmpeg_str}[/bold yellow][white], [red]ffprobe [bold yellow]{ffprobe_str}[/bold yellow][white], [red]mp4decrypt [bold yellow]{mp4decrypt_str}[/bold yellow]")
 
 
 os_manager = OsManager()

StreamingCommunity/Util/table.py

@@ -107,7 +107,7 @@ class TVShowManager:
             search_func = getattr(module, 'search')
             search_func(None)
             
-        except Exception as e:
+        except Exception:
             logging.error("Error during search execution")
             
         finally:
@@ -142,7 +142,7 @@ class TVShowManager:
 
             # Handle pagination and user input
             if self.slice_end < total_items:
-                self.console.print(f"\n[green]Press [red]Enter [green]for next page, [red]'q' [green]to quit, or [red]'back' [green]to search.")
+                self.console.print("\n[green]Press [red]Enter [green]for next page, [red]'q' [green]to quit, or [red]'back' [green]to search.")
 
                 if not force_int_input:
                     prompt_msg = ("\n[cyan]Insert media index [yellow](e.g., 1), [red]* [cyan]to download all media, "
@@ -184,7 +184,7 @@ class TVShowManager:
 
             else:
                 # Last page handling
-                self.console.print(f"\n[green]You've reached the end. [red]Enter [green]for first page, [red]'q' [green]to quit, or [red]'back' [green]to search.")
+                self.console.print("\n[green]You've reached the end. [red]Enter [green]for first page, [red]'q' [green]to quit, or [red]'back' [green]to search.")
                 
                 if not force_int_input:
                     prompt_msg = ("\n[cyan]Insert media index [yellow](e.g., 1), [red]* [cyan]to download all media, "

StreamingCommunity/__init__.py

@@ -4,4 +4,12 @@ from .run import main
 from .Lib.Downloader.HLS.downloader import HLS_Downloader
 from .Lib.Downloader.MP4.downloader import MP4_downloader
 from .Lib.Downloader.TOR.downloader import TOR_downloader
-from .Lib.Downloader.DASH.downloader import DASH_Downloader
+from .Lib.Downloader.DASH.downloader import DASH_Downloader
+
+__all__ = [
+    "main",
+    "HLS_Downloader",
+    "MP4_downloader",
+    "TOR_downloader",
+    "DASH_Downloader"
+]