quasarr 2.6.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

quasarr/providers/jd_cache.py

@@ -2,7 +2,7 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
-from quasarr.providers.log import debug
+from quasarr.providers.log import trace
 from quasarr.providers.myjd_api import (
     MYJDException,
     RequestTimeoutException,
@@ -62,7 +62,7 @@ class JDPackageCache:
     """
 
     def __init__(self, device):
-        debug("JDPackageCache: Initializing new cache instance")
+        trace("Initializing new cache instance")
         self._device = device
         self._linkgrabber_packages = None
         self._linkgrabber_links = None
@@ -87,97 +87,91 @@ class JDPackageCache:
     @property
     def linkgrabber_packages(self):
         if self._linkgrabber_packages is None:
-            debug("JDPackageCache: Fetching linkgrabber_packages from API")
+            trace("Fetching linkgrabber_packages from API")
             self._api_calls += 1
             try:
                 self._linkgrabber_packages = self._device.linkgrabber.query_packages()
-                debug(
-                    f"JDPackageCache: Retrieved {len(self._linkgrabber_packages)} linkgrabber packages"
+                trace(
+                    f"Retrieved {len(self._linkgrabber_packages)} linkgrabber packages"
                 )
             except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
-                debug(f"JDPackageCache: Failed to fetch linkgrabber_packages: {e}")
+                trace(f"Failed to fetch linkgrabber_packages: {e}")
                 self._linkgrabber_packages = []
         else:
             self._cache_hits += 1
-            debug(
-                f"JDPackageCache: Using cached linkgrabber_packages ({len(self._linkgrabber_packages)} packages)"
+            trace(
+                f"Using cached linkgrabber_packages ({len(self._linkgrabber_packages)} packages)"
             )
         return self._linkgrabber_packages
 
     @property
     def linkgrabber_links(self):
         if self._linkgrabber_links is None:
-            debug("JDPackageCache: Fetching linkgrabber_links from API")
+            trace("Fetching linkgrabber_links from API")
             self._api_calls += 1
             try:
                 self._linkgrabber_links = self._device.linkgrabber.query_links()
-                debug(
-                    f"JDPackageCache: Retrieved {len(self._linkgrabber_links)} linkgrabber links"
-                )
+                trace(f"Retrieved {len(self._linkgrabber_links)} linkgrabber links")
             except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
-                debug(f"JDPackageCache: Failed to fetch linkgrabber_links: {e}")
+                trace(f"Failed to fetch linkgrabber_links: {e}")
                 self._linkgrabber_links = []
         else:
             self._cache_hits += 1
-            debug(
-                f"JDPackageCache: Using cached linkgrabber_links ({len(self._linkgrabber_links)} links)"
+            trace(
+                f"Using cached linkgrabber_links ({len(self._linkgrabber_links)} links)"
             )
         return self._linkgrabber_links
 
     @property
     def downloader_packages(self):
         if self._downloader_packages is None:
-            debug("JDPackageCache: Fetching downloader_packages from API")
+            trace("Fetching downloader_packages from API")
             self._api_calls += 1
             try:
                 self._downloader_packages = self._device.downloads.query_packages()
-                debug(
-                    f"JDPackageCache: Retrieved {len(self._downloader_packages)} downloader packages"
-                )
+                trace(f"Retrieved {len(self._downloader_packages)} downloader packages")
             except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
-                debug(f"JDPackageCache: Failed to fetch downloader_packages: {e}")
+                trace(f"Failed to fetch downloader_packages: {e}")
                 self._downloader_packages = []
         else:
             self._cache_hits += 1
-            debug(
-                f"JDPackageCache: Using cached downloader_packages ({len(self._downloader_packages)} packages)"
+            trace(
+                f"Using cached downloader_packages ({len(self._downloader_packages)} packages)"
             )
         return self._downloader_packages
 
     @property
     def downloader_links(self):
         if self._downloader_links is None:
-            debug("JDPackageCache: Fetching downloader_links from API")
+            trace("Fetching downloader_links from API")
             self._api_calls += 1
             try:
                 self._downloader_links = self._device.downloads.query_links()
-                debug(
-                    f"JDPackageCache: Retrieved {len(self._downloader_links)} downloader links"
-                )
+                trace(f"Retrieved {len(self._downloader_links)} downloader links")
             except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
-                debug(f"JDPackageCache: Failed to fetch downloader_links: {e}")
+                trace(f"Failed to fetch downloader_links: {e}")
                 self._downloader_links = []
         else:
             self._cache_hits += 1
-            debug(
-                f"JDPackageCache: Using cached downloader_links ({len(self._downloader_links)} links)"
+            trace(
+                f"Using cached downloader_links ({len(self._downloader_links)} links)"
             )
         return self._downloader_links
 
     @property
     def is_collecting(self):
         if self._is_collecting is None:
-            debug("JDPackageCache: Checking is_collecting from API")
+            trace("Checking is_collecting from API")
             self._api_calls += 1
             try:
                 self._is_collecting = self._device.linkgrabber.is_collecting()
-                debug(f"JDPackageCache: is_collecting = {self._is_collecting}")
+                trace(f"is_collecting = {self._is_collecting}")
             except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
-                debug(f"JDPackageCache: Failed to check is_collecting: {e}")
+                trace(f"Failed to check is_collecting: {e}")
                 self._is_collecting = False
         else:
             self._cache_hits += 1
-            debug(f"JDPackageCache: Using cached is_collecting = {self._is_collecting}")
+            trace(f"Using cached is_collecting = {self._is_collecting}")
         return self._is_collecting
 
     def _has_archive_extension(self, package_uuid, links):
@@ -189,8 +183,8 @@ class JDPackageCache:
             name_lower = name.lower()
             for ext in ARCHIVE_EXTENSIONS:
                 if name_lower.endswith(ext):
-                    debug(
-                        f"JDPackageCache: Found archive extension '{ext}' in file '{name}' for package {package_uuid}"
+                    trace(
+                        f"Found archive extension '{ext}' in file '{name}' for package {package_uuid}"
                     )
                     return True
         return False
@@ -207,51 +201,43 @@ class JDPackageCache:
         confirmed_archives = set()
 
         if not package_uuids:
-            debug(
-                "JDPackageCache: _bulk_detect_archives called with empty package_uuids"
-            )
+            trace("_bulk_detect_archives called with empty package_uuids")
             return confirmed_archives, True
 
         package_list = list(package_uuids)
-        debug(
-            f"JDPackageCache: Bulk archive detection for {len(package_list)} packages"
-        )
+        trace(f"Bulk archive detection for {len(package_list)} packages")
 
         try:
             self._api_calls += 1
             archive_infos = self._device.extraction.get_archive_info([], package_list)
-            debug(
-                f"JDPackageCache: get_archive_info returned {len(archive_infos) if archive_infos else 0} results"
+            trace(
+                f"get_archive_info returned {len(archive_infos) if archive_infos else 0} results"
             )
 
             if archive_infos:
                 for i, archive_info in enumerate(archive_infos):
                     if archive_info:
-                        debug(f"JDPackageCache: archive_info[{i}] = {archive_info}")
+                        trace(f"archive_info[{i}] = {archive_info}")
                         # Try to get packageUUID from response
                         pkg_uuid = archive_info.get("packageUUID")
                         if pkg_uuid:
-                            debug(
-                                f"JDPackageCache: Confirmed archive via packageUUID: {pkg_uuid}"
-                            )
+                            trace(f"Confirmed archive via packageUUID: {pkg_uuid}")
                             confirmed_archives.add(pkg_uuid)
                         else:
                             # Log what fields ARE available for debugging
-                            debug(
-                                f"JDPackageCache: archive_info has no packageUUID, available keys: {list(archive_info.keys())}"
+                            trace(
+                                f"archive_info has no packageUUID, available keys: {list(archive_info.keys())}"
                             )
                     else:
-                        debug(f"JDPackageCache: archive_info[{i}] is empty/None")
+                        trace(f"archive_info[{i}] is empty/None")
 
-            debug(
-                f"JDPackageCache: Bulk detection confirmed {len(confirmed_archives)} archives: {confirmed_archives}"
+            trace(
+                f"Bulk detection confirmed {len(confirmed_archives)} archives: {confirmed_archives}"
             )
             return confirmed_archives, True
 
         except Exception as e:
-            debug(
-                f"JDPackageCache: Bulk archive detection API FAILED: {type(e).__name__}: {e}"
-            )
+            trace(f"Bulk archive detection API FAILED: {type(e).__name__}: {e}")
             return confirmed_archives, False
 
     def detect_all_archives(self, packages, links):
@@ -269,50 +255,46 @@ class JDPackageCache:
             Set of package UUIDs that should be treated as archives
         """
         if not packages:
-            debug("JDPackageCache: detect_all_archives called with no packages")
+            trace("detect_all_archives called with no packages")
             return set()
 
         all_package_uuids = {p.get("uuid") for p in packages if p.get("uuid")}
-        debug(
-            f"JDPackageCache: detect_all_archives for {len(all_package_uuids)} packages"
-        )
+        trace(f"detect_all_archives for {len(all_package_uuids)} packages")
 
         # ONE bulk API call for all packages
         confirmed_archives, api_succeeded = self._bulk_detect_archives(
             all_package_uuids
         )
-        debug(
-            f"JDPackageCache: Bulk API succeeded={api_succeeded}, confirmed={len(confirmed_archives)} archives"
+        trace(
+            f"Bulk API succeeded={api_succeeded}, confirmed={len(confirmed_archives)} archives"
         )
 
         # For packages NOT confirmed as archives, apply safety fallbacks
         unconfirmed = all_package_uuids - confirmed_archives
-        debug(f"JDPackageCache: {len(unconfirmed)} packages need fallback checking")
+        trace(f"{len(unconfirmed)} packages need fallback checking")
 
         for pkg_uuid in unconfirmed:
             # Fallback 1: Check file extensions
             if self._has_archive_extension(pkg_uuid, links):
-                debug(
-                    f"JDPackageCache: Package {pkg_uuid} confirmed as archive via extension fallback"
-                )
+                trace(f"Package {pkg_uuid} confirmed as archive via extension fallback")
                 confirmed_archives.add(pkg_uuid)
             # Fallback 2: If bulk API failed completely, assume archive (safe)
             elif not api_succeeded:
-                debug(
-                    f"JDPackageCache: SAFETY - Bulk API failed, assuming package {pkg_uuid} is archive"
+                trace(
+                    f"SAFETY - Bulk API failed, assuming package {pkg_uuid} is archive"
                 )
                 confirmed_archives.add(pkg_uuid)
             else:
-                debug(
-                    f"JDPackageCache: Package {pkg_uuid} confirmed as NON-archive (API worked, no extension match)"
+                trace(
+                    f"Package {pkg_uuid} confirmed as NON-archive (API worked, no extension match)"
                 )
 
         # Cache results for is_package_archive() lookups
         for pkg_uuid in all_package_uuids:
             self._archive_cache[pkg_uuid] = pkg_uuid in confirmed_archives
 
-        debug(
-            f"JDPackageCache: Final archive detection: {len(confirmed_archives)}/{len(all_package_uuids)} packages are archives"
+        trace(
+            f"Final archive detection: {len(confirmed_archives)}/{len(all_package_uuids)} packages are archives"
         )
         return confirmed_archives
 
@@ -327,20 +309,16 @@ class JDPackageCache:
         premature "finished" status.
         """
         if package_uuid is None:
-            debug("JDPackageCache: is_package_archive called with None UUID")
+            trace("is_package_archive called with None UUID")
             return False
 
         if package_uuid in self._archive_cache:
             self._cache_hits += 1
             cached = self._archive_cache[package_uuid]
-            debug(
-                f"JDPackageCache: is_package_archive({package_uuid}) = {cached} (cached)"
-            )
+            trace(f"is_package_archive({package_uuid}) = {cached} (cached)")
             return cached
 
-        debug(
-            f"JDPackageCache: is_package_archive({package_uuid}) - cache miss, querying API"
-        )
+        trace(f"is_package_archive({package_uuid}) - cache miss, querying API")
 
         # Single package lookup (fallback if detect_all_archives wasn't called)
         is_archive = None
@@ -349,33 +327,29 @@ class JDPackageCache:
         try:
             self._api_calls += 1
             archive_info = self._device.extraction.get_archive_info([], [package_uuid])
-            debug(f"JDPackageCache: Single get_archive_info returned: {archive_info}")
+            trace(f"Single get_archive_info returned: {archive_info}")
             # Original logic: is_archive = True if archive_info and archive_info[0] else False
             is_archive = True if archive_info and archive_info[0] else False
-            debug(f"JDPackageCache: API says is_archive = {is_archive}")
+            trace(f"API says is_archive = {is_archive}")
         except Exception as e:
             api_failed = True
-            debug(
-                f"JDPackageCache: Single archive detection API FAILED for {package_uuid}: {type(e).__name__}: {e}"
+            trace(
+                f"Single archive detection API FAILED for {package_uuid}: {type(e).__name__}: {e}"
             )
 
         # Fallback: check file extensions if API failed or returned False
         if (api_failed or not is_archive) and links:
             if self._has_archive_extension(package_uuid, links):
-                debug(
-                    f"JDPackageCache: Package {package_uuid} confirmed as archive via extension fallback"
+                trace(
+                    f"Package {package_uuid} confirmed as archive via extension fallback"
                 )
                 is_archive = True
 
         # SAFETY: If API failed and no extension detected, assume archive (conservative)
         if is_archive is None:
-            debug(
-                f"JDPackageCache: SAFETY - Detection uncertain for {package_uuid}, assuming archive"
-            )
+            trace(f"SAFETY - Detection uncertain for {package_uuid}, assuming archive")
             is_archive = True
 
         self._archive_cache[package_uuid] = is_archive
-        debug(
-            f"JDPackageCache: is_package_archive({package_uuid}) = {is_archive} (final)"
-        )
+        trace(f"is_package_archive({package_uuid}) = {is_archive} (final)")
         return is_archive

quasarr/providers/log.py

@@ -1,19 +1,237 @@
 # -*- coding: utf-8 -*-
 # Quasarr
 # Project by https://github.com/rix1337
+from __future__ import annotations
 
-import datetime
+import inspect
 import os
+import sys
+from typing import TYPE_CHECKING, Any
 
+from dotenv import load_dotenv
+from loguru import logger
+from wcwidth import wcswidth, wrap
 
-def timestamp():
-    return datetime.datetime.now().strftime("[%Y-%m-%d %H:%M:%S]")
+if TYPE_CHECKING:
+    from loguru import Message
 
+load_dotenv()
 
-def info(string):
-    print(f"{timestamp()} {string}")
 
+def get_log_max_width() -> int:
+    try:
+        return int(os.getenv("LOG_MAX_WIDTH"))
+    except Exception:
+        pass
+    try:
+        return os.get_terminal_size().columns
+    except Exception:
+        return 160
 
-def debug(string):
-    if os.getenv("DEBUG"):
-        info(string)
+
+_subsequent_indent = " " * 33
+
+
+def wrapping_sink(message: Message) -> None:
+    wrapped = wrap(
+        text=message,
+        width=get_log_max_width(),
+        subsequent_indent=_subsequent_indent,
+    )
+    for w in wrapped:
+        sys.stdout.write(w + "\n")
+
+
+logger.remove(0)
+logger.add(
+    wrapping_sink,
+    format="<d>{time:YYYY-MM-DDTHH:mm:ss}</d> <lvl>{level:<5}</lvl> {extra[context]}<b><M>{extra[source]}</M></b>{extra[padding]} {message}",
+    colorize=os.getenv("LOG_COLOR", "1").lower() in ["1", "true", "yes"],
+    level=5,
+)
+logger.level(name="WARN", no=30, color="<yellow>")
+logger.level(name="CRIT", no=50, color="<red>")
+
+log_level_names = {
+    50: "CRIT",
+    40: "ERROR",
+    30: "WARN",
+    20: "INFO",
+    10: "DEBUG",
+    5: "TRACE",
+}
+
+# reverse map log_level_names
+log_names_to_level = {v: k for k, v in log_level_names.items()}
+
+
+def _read_env_log(key, default):
+    try:
+        try:
+            level = log_names_to_level[os.getenv(key, default).upper()]
+        except Exception:
+            level = max(0, min(int(level), 50))
+    except Exception:
+        level = default
+
+    return level
+
+
+_log_level = _read_env_log("LOG", 20)
+
+
+_context_replace = {
+    "quasarr": "",  # /quasarr/*
+    "arr": "🏴‍☠️",  # /quasarr/arr/*
+    "api": "🌐",  # /quasarr/api/*
+    "captcha": "🧩",  # /quasarr/api/captcha/*
+    "config": "⚙️",  # /quasarr/api/config/*
+    "sponsors_helper": "💖",  # /quasarr/api/sponsors_helper/*
+    "downloads": "📥",  # /quasarr/downloads/*
+    "linkcrypters": "🔐",  # /quasarr/linkcrypters/*
+    "filecrypt": "🛡️",  # /quasarr/linkcrypters/filecrypt.py
+    "hide": "👻",  # /quasarr/linkcrypters/hide.py
+    "packages": "📦",  # /quasarr/api/packages/*
+    "providers": "🔌",  # /quasarr/providers/*
+    "imdb_metadata": "🎬",  # /quasarr/providers/imdb_metadata.py
+    "jd_cache": "📇",  # /quasarr/providers/jd_cache.py
+    "log": "📝",  # /quasarr/providers/log.py
+    "myjd_api": "🔑",  # /quasarr/providers/myjd_api.py
+    "notifications": "🔔",  # /quasarr/providers/notifications.py
+    "shared_state": "🧠",  # /quasarr/providers/shared_state.py
+    "sessions": "🍪",  # /quasarr/providers/sessions/*
+    "search": "🔍",  # /quasarr/search/*
+    "storage": "💽",  # /quasarr/storage/*
+    "setup": "🛠️",  # /quasarr/storage/setup.py
+    "sqlite_database": "🗃️",  # /quasarr/storage/sqlite_database.py
+    "sources": "🧲",  # /quasarr/*/sources/*
+    "utils": "🧰",  # /quasarr/providers/utils.py
+}
+
+
+def _contexts_to_str(contexts: list[str]) -> str:
+    source = ""
+    if len(contexts) == 0:
+        return "", source
+
+    if contexts:
+        if contexts[-1].__len__() == 2:
+            source = contexts.pop()
+        elif contexts[0] == "quasarr" and contexts.__len__() == 1:
+            return "🌌", source
+
+    return "".join(_context_replace.get(c, c) for c in contexts), source.upper()
+
+
+def get_log_level_name(level: int = _log_level) -> str:
+    return log_level_names[level]
+
+
+def get_log_level(contexts: list[str] | None = None) -> int:
+    if contexts is None:
+        contexts = []
+    level = _log_level
+
+    for context in contexts:
+        context_level = _read_env_log(
+            "LOG" + f"_{context.upper()}" if context else "", _log_level
+        )
+        if context_level < level:
+            level = context_level
+
+    return level
+
+
+class _Logger:
+    def __init__(self, contexts: list[str] | None = None):
+        if contexts is None:
+            contexts = []
+        self.level = get_log_level(contexts)
+        context, source = _contexts_to_str(contexts)
+        width = wcswidth(context + source)
+        padding = 6 - width
+
+        self.logger_alt = logger.bind(
+            context=context,
+            source=source,
+            padding=" " * padding,
+        )
+        self.logger = self.logger_alt.opt(colors=True)
+
+    def _log(self, level: int, msg: str, *args: Any, **kwargs: Any) -> None:
+        if self.level > level:
+            return
+        try:
+            try:
+                self.logger.log(log_level_names[level], msg, *args, **kwargs)
+            except ValueError as e:
+                # Fallback: try logging without color parsing if tags are mismatched
+                self.logger_alt.log(log_level_names[level], msg, *args, **kwargs)
+
+                if self.level <= 10:
+                    self.logger_alt.debug(
+                        f"Log formatting error: {e} | Original message: {msg}"
+                    )
+        except Exception:
+            # Fallback: just print to stderr if logging fails completely
+            print(f"LOGGING FAILURE: {msg}", file=sys.stderr)
+
+    def crit(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(50, msg, *args, **kwargs)
+
+    def error(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(40, msg, *args, **kwargs)
+
+    def warn(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(30, msg, *args, **kwargs)
+
+    def info(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(20, msg, *args, **kwargs)
+
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(10, msg, *args, **kwargs)
+
+    def trace(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._log(5, msg, *args, **kwargs)
+
+
+_loggers = {}
+
+
+def get_logger(context: str) -> _Logger:
+    if context not in _loggers:
+        _loggers[context] = _Logger(context.split(".") if context else [])
+    return _loggers[context]
+
+
+def _get_logger_for_module() -> _Logger:
+    # get the calling module filename
+    frame = inspect.currentframe()
+    caller_frame = frame.f_back.f_back
+    module_name = caller_frame.f_globals["__name__"]
+
+    return get_logger(module_name)
+
+
+def crit(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().crit(msg, *args, **kwargs)
+
+
+def error(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().error(msg, *args, **kwargs)
+
+
+def warn(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().warn(msg, *args, **kwargs)
+
+
+def info(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().info(msg, *args, **kwargs)
+
+
+def debug(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().debug(msg, *args, **kwargs)
+
+
+def trace(msg: str, *args: Any, **kwargs: Any) -> None:
+    _get_logger_for_module().trace(msg, *args, **kwargs)