qBitrr2 3.7.1__py3-none-any.whl

qBitrr/bundled_data.py

@@ -0,0 +1,6 @@
+version = "3.7.1"
+git_hash = "da63e3c"
+license_text = (
+    "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
+)
+patched_version = f"{version}-{git_hash}"

qBitrr/config.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import pathlib
+import shutil
+import signal
+import sys
+
+from qBitrr.bundled_data import license_text, patched_version
+from qBitrr.env_config import ENVIRO_CONFIG
+from qBitrr.gen_config import MyConfig, _write_config_file, generate_doc
+from qBitrr.home_path import APPDATA_FOLDER, HOME_PATH, ON_DOCKER
+
+
+def process_flags() -> argparse.Namespace | bool:
+    parser = argparse.ArgumentParser(description="An interface to interact with qBit and *arrs.")
+    parser.add_argument(
+        "--gen-config",
+        "-gc",
+        dest="gen_config",
+        help="Generate a config file in the current working directory",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"qBitrr version: {patched_version}"
+    )
+
+    parser.add_argument(
+        "-l",
+        "--license",
+        dest="license",
+        action="store_const",
+        const=license_text,
+        help="Show the qBitrr's licence",
+    )
+    parser.add_argument(
+        "-s",
+        "--source",
+        action="store_const",
+        dest="source",
+        const="Source code can be found on: https://github.com/Feramance/qBitrr",
+        help="Shows a link to qBitrr's source",
+    )
+
+    args = parser.parse_args()
+
+    if args.gen_config:
+        from qBitrr.gen_config import _write_config_file
+
+        _write_config_file()
+        return True
+    elif args.license:
+        print(args.license)
+        return True
+    elif args.source:
+        print(args.source)
+        return True
+    return args
+
+
+COPIED_TO_NEW_DIR = False
+file = "config.toml"
+CONFIG_FILE = HOME_PATH.joinpath(file)
+CONFIG_PATH = pathlib.Path(f"./{file}")
+if any(
+    a in sys.argv
+    for a in [
+        "--gen-config",
+        "-gc",
+        "--version",
+        "-v",
+        "--license",
+        "-l",
+        "--source",
+        "-s",
+        "-h",
+        "--help",
+    ]
+):
+    CONFIG = MyConfig(CONFIG_FILE, config=generate_doc())
+    COPIED_TO_NEW_DIR = None
+elif (not CONFIG_FILE.exists()) and (not CONFIG_PATH.exists()):
+    if ON_DOCKER:
+        print(f"{file} has not been found")
+
+        CONFIG_FILE = _write_config_file(docker=True)
+        print(f"'{CONFIG_FILE.name}' has been generated")
+        print('Rename it to "config.toml" then edit it and restart the container')
+
+        os.kill(os.getppid(), signal.SIGTERM)
+
+    else:
+        print(f"{file} has not been found")
+
+        CONFIG_FILE = _write_config_file(docker=True)
+        print(f"'{CONFIG_FILE.name}' has been generated")
+        print('Rename it to "config.toml" then edit it and restart the container')
+
+        os.kill(os.getppid(), signal.SIGTERM)
+
+elif CONFIG_FILE.exists():
+    CONFIG = MyConfig(CONFIG_FILE)
+else:
+    with contextlib.suppress(
+        Exception
+    ):  # If file already exist or can't copy to APPDATA_FOLDER ignore the exception
+        shutil.copy(CONFIG_PATH, CONFIG_FILE)
+        COPIED_TO_NEW_DIR = True
+    CONFIG = MyConfig("./config.toml")
+
+if COPIED_TO_NEW_DIR is not None:
+    # print(f"STARTUP | {CONFIG.path} |\n{CONFIG}")
+    print(f"STARTUP")
+else:
+    print(f"STARTUP |  CONFIG_FILE={CONFIG_FILE} | CONFIG_PATH={CONFIG_PATH}")
+
+FFPROBE_AUTO_UPDATE = (
+    CONFIG.get("Settings.FFprobeAutoUpdate", fallback=True)
+    if ENVIRO_CONFIG.settings.ffprobe_auto_update is None
+    else ENVIRO_CONFIG.settings.ffprobe_auto_update
+)
+FAILED_CATEGORY = ENVIRO_CONFIG.settings.failed_category or CONFIG.get(
+    "Settings.FailedCategory", fallback="failed"
+)
+RECHECK_CATEGORY = ENVIRO_CONFIG.settings.recheck_category or CONFIG.get(
+    "Settings.RecheckCategory", fallback="recheck"
+)
+CONSOLE_LOGGING_LEVEL_STRING = ENVIRO_CONFIG.settings.console_level or CONFIG.get_or_raise(
+    "Settings.ConsoleLevel"
+)
+COMPLETED_DOWNLOAD_FOLDER = (
+    ENVIRO_CONFIG.settings.completed_download_folder
+    or CONFIG.get_or_raise("Settings.CompletedDownloadFolder")
+)
+NO_INTERNET_SLEEP_TIMER = ENVIRO_CONFIG.settings.no_internet_sleep_timer or CONFIG.get(
+    "Settings.NoInternetSleepTimer", fallback=60
+)
+LOOP_SLEEP_TIMER = ENVIRO_CONFIG.settings.loop_sleep_timer or CONFIG.get(
+    "Settings.LoopSleepTimer", fallback=5
+)
+PING_URLS = ENVIRO_CONFIG.settings.ping_urls or CONFIG.get(
+    "Settings.PingURLS", fallback=["one.one.one.one", "dns.google.com"]
+)
+IGNORE_TORRENTS_YOUNGER_THAN = ENVIRO_CONFIG.settings.ignore_torrents_younger_than or CONFIG.get(
+    "Settings.IgnoreTorrentsYoungerThan", fallback=600
+)
+QBIT_DISABLED = (
+    CONFIG.get("qBit.Disabled", fallback=False)
+    if ENVIRO_CONFIG.qbit.disabled is None
+    else ENVIRO_CONFIG.qbit.disabled
+)
+SEARCH_ONLY = ENVIRO_CONFIG.overrides.search_only
+PROCESS_ONLY = ENVIRO_CONFIG.overrides.processing_only
+
+if QBIT_DISABLED and PROCESS_ONLY:
+    print("qBittorrent is disabled yet QBITRR_OVERRIDES_PROCESSING_ONLY is enabled")
+    print(
+        "Processing monitors qBitTorrents downloads "
+        "therefore it depends on a health qBitTorrent connection"
+    )
+    print("Exiting...")
+    sys.exit(1)
+
+if SEARCH_ONLY and QBIT_DISABLED is False:
+    QBIT_DISABLED = True
+    print("QBITRR_OVERRIDES_SEARCH_ONLY is enabled, forcing qBitTorrent setting off")
+
+# Settings Config Values
+FF_VERSION = APPDATA_FOLDER.joinpath("ffprobe_info.json")
+FF_PROBE = APPDATA_FOLDER.joinpath("ffprobe")

qBitrr/env_config.py

@@ -0,0 +1,60 @@
+from distutils.util import strtobool
+from typing import Optional
+
+import environ
+
+
+class Converter:
+    @staticmethod
+    def int(value: Optional[str]) -> Optional[int]:
+        if value is None:
+            return None
+        return int(value)
+
+    @staticmethod
+    def list(value: Optional[str], delimiter=",", converter=str) -> Optional[list]:
+        if value is None:
+            return None
+        return list(map(converter, value.split(delimiter)))
+
+    @staticmethod
+    def bool(value: Optional[str]) -> Optional[bool]:
+        if value is None:
+            return None
+        return strtobool(value) == 1
+
+
+@environ.config(prefix="QBITRR", frozen=True)
+class AppConfig:
+    @environ.config(prefix="OVERRIDES", frozen=True)
+    class Overrides:
+        search_only = environ.var(None, converter=Converter.bool)
+        processing_only = environ.var(None, converter=Converter.bool)
+        data_path = environ.var(None)
+
+    @environ.config(prefix="SETTINGS", frozen=True)
+    class Settings:
+        console_level = environ.var(None)
+        completed_download_folder = environ.var(None)
+        no_internet_sleep_timer = environ.var(None, converter=Converter.int)
+        loop_sleep_timer = environ.var(None, converter=Converter.int)
+        failed_category = environ.var(None)
+        recheck_category = environ.var(None)
+        ignore_torrents_younger_than = environ.var(None, converter=Converter.int)
+        ping_urls = environ.var(None, converter=Converter.list)
+        ffprobe_auto_update = environ.var(None, converter=Converter.bool)
+
+    @environ.config(prefix="QBIT", frozen=True)
+    class qBit:
+        disabled = environ.var(None, converter=Converter.bool)
+        host = environ.var(None)
+        port = environ.var(None, converter=Converter.int)
+        username = environ.var(None)
+        password = environ.var(None)
+
+    overrides: Overrides = environ.group(Overrides)
+    settings: Settings = environ.group(Settings)
+    qbit: qBit = environ.group(qBit)
+
+
+ENVIRO_CONFIG: AppConfig = environ.to_config(AppConfig)

qBitrr/errors.py

@@ -0,0 +1,41 @@
+class qBitManagerExceptions(Exception):
+    """Base Exception"""
+
+
+class UnhandledError(qBitManagerExceptions):
+    """Use to raise when there an unhandled edge case"""
+
+
+class ConfigException(qBitManagerExceptions):
+    """Base Exception for Config related exceptions"""
+
+
+class ArrManagerException(qBitManagerExceptions):
+    """Base Exception for Arr related Exceptions"""
+
+
+class SkipException(qBitManagerExceptions):
+    """Dummy error to skip actions"""
+
+
+class RequireConfigValue(qBitManagerExceptions):
+    """Exception raised when a config value requires a value."""
+
+    def __init__(self, config_class: str, config_key: str):
+        self.message = f"Config key '{config_key}' in '{config_class}' requires a value."
+
+
+class NoConnectionrException(qBitManagerExceptions):
+    def __init__(self, message: str, type: str = "delay"):
+        self.message = message
+        self.type = type
+
+
+class DelayLoopException(qBitManagerExceptions):
+    def __init__(self, length: int, type: str):
+        self.type = type
+        self.length = length
+
+
+class RestartLoopException(ArrManagerException):
+    """Exception to trigger a loop restart"""

qBitrr/ffprobe.py

@@ -0,0 +1,105 @@
+import io
+import json
+import logging
+import os
+import platform
+import sys
+import zipfile
+
+import requests
+
+from qBitrr.config import FF_PROBE, FF_VERSION, FFPROBE_AUTO_UPDATE
+from qBitrr.logger import run_logs
+
+
+class FFprobeDownloader:
+    def __init__(self):
+        self.api = "https://ffbinaries.com/api/v1/version/latest"
+        self.version_file = FF_VERSION
+        self.logger = logging.getLogger("qBitrr.FFprobe")
+        run_logs(self.logger)
+        self.platform = platform.system()
+        if self.platform == "Windows":
+            self.probe_path = FF_PROBE.with_suffix(".exe")
+        else:
+            self.probe_path = FF_PROBE
+
+    def get_upstream_version(self) -> dict:
+        with requests.Session() as session:
+            with session.get(self.api) as response:
+                if response.status_code != 200:
+                    self.logger.warning("Failed to retrieve ffprobe version from API.")
+                    return {}
+                return response.json()
+
+    def get_current_version(self):
+        try:
+            with self.version_file.open(mode="r") as file:
+                data = json.load(file)
+            return data.get("version")
+        except Exception:  # If file can't be found or read or parsed
+            self.logger.warning("Failed to retrieve current ffprobe version.")
+            return ""
+
+    def update(self):
+        if not FFPROBE_AUTO_UPDATE:
+            return
+        current_version = self.get_current_version()
+        upstream_data = self.get_upstream_version()
+        upstream_version = upstream_data.get("version")
+        if upstream_version is None:
+            self.logger.debug(
+                "Failed to retrieve ffprobe version from API.'upstream_version' is None"
+            )
+            return
+        probe_file_exists = self.probe_path.exists()
+        if current_version == upstream_version and probe_file_exists:
+            self.logger.debug("Current FFprobe is up to date.")
+            return
+        arch_key = self.get_arch()
+        urls = upstream_data.get("bin", {}).get(arch_key)
+        if urls is None:
+            self.logger.debug("Failed to retrieve ffprobe version from API.'urls' is None")
+            return
+        ffprobe_url = urls.get("ffprobe")
+        self.logger.debug("Downloading newer FFprobe: %s", ffprobe_url)
+        self.download_and_extract(ffprobe_url)
+        self.logger.debug("Updating local version of FFprobe: %s", upstream_version)
+        self.version_file.write_text(json.dumps({"version": upstream_version}))
+        try:
+            os.chmod(self.probe_path, 0o777)
+            self.logger.debug("Successfully changed permissions for ffprobe")
+        except Exception as e:
+            self.logger.debug("Failed to change permissions for ffprobe, %s", e)
+
+    def download_and_extract(self, ffprobe_url):
+        r = requests.get(ffprobe_url)
+        z = zipfile.ZipFile(io.BytesIO(r.content))
+        self.logger.debug("Extracting downloaded FFprobe to: %s", FF_PROBE.parent)
+        z.extract(member=self.probe_path.name, path=FF_PROBE.parent)
+
+    def get_arch(self):
+        part1 = None
+        is_64bits = sys.maxsize > 2**32
+        part2 = "64" if is_64bits else "32"
+        if self.platform == "Windows":
+            part1 = "windows-"
+        elif self.platform == "Linux":
+            part1 = "linux-"
+            machine = platform.machine()
+            if machine == "armv6l":
+                part2 = "armhf"
+            elif ("arm" in machine and is_64bits) or machine == "aarch64":
+                part2 = "arm64"
+            # Else just 32/64, Not armel - because just no
+        elif self.platform == "Darwin":
+            part1 = "osx-"
+            part2 = "64"
+        if part1 is None:
+            raise RuntimeError(
+                "You are running in an unsupported platform, "
+                "if you expect this to be supported please open an issue on GitHub "
+                "https://github.com/Feramance/qBitrr."
+            )
+
+        return part1 + part2