qBitrr2 3.7.1__py3-none-any.whl

qBitrr/home_path.py

@@ -0,0 +1,23 @@
+import pathlib
+
+from jaraco.docker import is_docker
+
+from qBitrr.env_config import ENVIRO_CONFIG
+
+if (
+    ENVIRO_CONFIG.overrides.data_path is None
+    or not (p := pathlib.Path(ENVIRO_CONFIG.overrides.data_path)).exists()
+):
+    if is_docker():
+        ON_DOCKER = True
+        HOME_PATH = pathlib.Path("/config")
+        HOME_PATH.mkdir(parents=True, exist_ok=True)
+    else:
+        ON_DOCKER = False
+        HOME_PATH = pathlib.Path().absolute().joinpath(".config")
+        HOME_PATH.mkdir(parents=True, exist_ok=True)
+else:
+    HOME_PATH = p
+
+APPDATA_FOLDER = HOME_PATH.joinpath("qBitManager")
+APPDATA_FOLDER.mkdir(parents=True, exist_ok=True)

qBitrr/logger.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import logging
+import time
+from logging import Logger
+
+import coloredlogs
+
+from qBitrr.config import (
+    COMPLETED_DOWNLOAD_FOLDER,
+    CONFIG,
+    CONSOLE_LOGGING_LEVEL_STRING,
+    COPIED_TO_NEW_DIR,
+    FAILED_CATEGORY,
+    HOME_PATH,
+    IGNORE_TORRENTS_YOUNGER_THAN,
+    LOOP_SLEEP_TIMER,
+    NO_INTERNET_SLEEP_TIMER,
+    PING_URLS,
+    RECHECK_CATEGORY,
+)
+
+__all__ = ("run_logs",)
+
+TRACE = 5
+VERBOSE = 7
+NOTICE = 23
+HNOTICE = 24
+SUCCESS = 25
+
+
+class VerboseLogger(Logger):
+    def _init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.name.startswith("qBitrr"):
+            self.set_config_level()
+
+    def success(self, message, *args, **kwargs):
+        if self.isEnabledFor(SUCCESS):
+            self._log(SUCCESS, message, args, **kwargs)
+
+    def hnotice(self, message, *args, **kwargs):
+        if self.isEnabledFor(HNOTICE):
+            self._log(HNOTICE, message, args, **kwargs)
+
+    def notice(self, message, *args, **kwargs):
+        if self.isEnabledFor(NOTICE):
+            self._log(NOTICE, message, args, **kwargs)
+
+    def verbose(self, message, *args, **kwargs):
+        if self.isEnabledFor(VERBOSE):
+            self._log(VERBOSE, message, args, **kwargs)
+
+    def trace(self, message, *args, **kwargs):
+        if self.isEnabledFor(TRACE):
+            self._log(TRACE, message, args, **kwargs)
+
+    def set_config_level(self):
+        self.setLevel(CONSOLE_LOGGING_LEVEL_STRING)
+
+
+logging.addLevelName(SUCCESS, "SUCCESS")
+logging.addLevelName(HNOTICE, "HNOTICE")
+logging.addLevelName(NOTICE, "NOTICE")
+logging.addLevelName(VERBOSE, "VERBOSE")
+logging.addLevelName(TRACE, "TRACE")
+logging.setLoggerClass(VerboseLogger)
+
+
+def getLogger(name: str | None = None):
+    if name:
+        return VerboseLogger.manager.getLogger(name)
+    else:
+        return logging.root
+
+
+logging.getLogger = getLogger
+
+
+logger = logging.getLogger("qBitrr.Misc")
+
+
+HAS_RUN = False
+
+
+def run_logs(logger: Logger) -> None:
+    global HAS_RUN
+    try:
+        configkeys = {f"qBitrr.{i}" for i in CONFIG.sections()}
+        key_length = max(len(max(configkeys, key=len)), 10)
+    except BaseException:
+        key_length = 10
+    coloredlogs.install(
+        logger=logger,
+        level=logging._nameToLevel.get(CONSOLE_LOGGING_LEVEL_STRING),
+        fmt="[%(asctime)-15s] [pid:%(process)8d][tid:%(thread)8d] "
+        f"%(levelname)-8s: %(name)-{key_length}s: %(message)s",
+        level_styles=dict(
+            trace=dict(color="black", bold=True),
+            debug=dict(color="magenta", bold=True),
+            verbose=dict(color="blue", bold=True),
+            info=dict(color="white"),
+            notice=dict(color="cyan"),
+            hnotice=dict(color="cyan", bold=True),
+            warning=dict(color="yellow", bold=True),
+            success=dict(color="green", bold=True),
+            error=dict(color="red"),
+            critical=dict(color="red", bold=True),
+        ),
+        field_styles=dict(
+            asctime=dict(color="green"),
+            process=dict(color="magenta"),
+            levelname=dict(color="red", bold=True),
+            name=dict(color="blue", bold=True),
+            thread=dict(color="cyan"),
+        ),
+        reconfigure=True,
+    )
+    if HAS_RUN is False:
+        logger.debug("Log Level: %s", CONSOLE_LOGGING_LEVEL_STRING)
+        logger.debug("Ping URLs:  %s", PING_URLS)
+        logger.debug("Script Config:  FailedCategory=%s", FAILED_CATEGORY)
+        logger.debug("Script Config:  RecheckCategory=%s", RECHECK_CATEGORY)
+        logger.debug("Script Config:  CompletedDownloadFolder=%s", COMPLETED_DOWNLOAD_FOLDER)
+        logger.debug("Script Config:  LoopSleepTimer=%s", LOOP_SLEEP_TIMER)
+        logger.debug(
+            "Script Config:  NoInternetSleepTimer=%s",
+            NO_INTERNET_SLEEP_TIMER,
+        )
+        logger.debug(
+            "Script Config:  IgnoreTorrentsYoungerThan=%s",
+            IGNORE_TORRENTS_YOUNGER_THAN,
+        )
+        HAS_RUN = True
+
+
+if COPIED_TO_NEW_DIR is False and not HOME_PATH.joinpath("config.toml").exists():
+    logger.warning(
+        "Config.toml should exist in '%s', in a future update this will be a requirement.",
+        HOME_PATH,
+    )
+    time.sleep(5)
+if COPIED_TO_NEW_DIR:
+    logger.warning("Config.toml new location is %s", HOME_PATH)
+    time.sleep(5)
+run_logs(logger)

qBitrr/main.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import atexit
+import logging
+import os
+import sys
+import time
+from multiprocessing import freeze_support
+
+import pathos
+import qbittorrentapi
+import requests
+from packaging import version as version_parser
+from packaging.version import Version as VersionClass
+from qbittorrentapi import APINames
+from qbittorrentapi.decorators import login_required  # , response_text
+
+from qBitrr.arss import ArrManager
+from qBitrr.bundled_data import patched_version
+from qBitrr.config import APPDATA_FOLDER, CONFIG, QBIT_DISABLED, SEARCH_ONLY, process_flags
+from qBitrr.env_config import ENVIRO_CONFIG
+from qBitrr.ffprobe import FFprobeDownloader
+from qBitrr.logger import run_logs
+from qBitrr.utils import ExpiringSet
+
+CHILD_PROCESSES = []
+
+logger = logging.getLogger("qBitrr")
+run_logs(logger)
+
+
+class qBitManager:
+    min_supported_version = VersionClass("4.3.9")
+    soft_not_supported_supported_version = VersionClass("4.5")
+    max_supported_version = VersionClass("4.5.5")
+    _head_less_mode = False
+
+    def __init__(self):
+        self.qBit_Host = CONFIG.get("qBit.Host", fallback="localhost")
+        self.qBit_Port = CONFIG.get("qBit.Port", fallback=8105)
+        self.qBit_UserName = CONFIG.get("qBit.UserName", fallback=None)
+        self.qBit_Password = CONFIG.get("qBit.Password", fallback=None)
+        self.logger = logging.getLogger(
+            "qBitrr.Manager",
+        )
+        run_logs(self.logger)
+        self.logger.debug(
+            "qBitTorrent Config: Host: %s Port: %s, Username: %s, Password: %s",
+            self.qBit_Host,
+            self.qBit_Port,
+            self.qBit_UserName,
+            self.qBit_Password,
+        )
+        self._validated_version = False
+        self.client = None
+        self.current_qbit_version = None
+        if not any([QBIT_DISABLED, SEARCH_ONLY]):
+            self.client = qbittorrentapi.Client(
+                host=self.qBit_Host,
+                port=self.qBit_Port,
+                username=self.qBit_UserName,
+                password=self.qBit_Password,
+                SIMPLE_RESPONSES=False,
+            )
+            try:
+                self.current_qbit_version = version_parser.parse(self.client.app_version())
+                self._validated_version = True
+            except BaseException:
+                self.current_qbit_version = self.min_supported_version
+                self.logger.error(
+                    "Could not establish qBitTorrent version, "
+                    "you may experience errors, please report this error."
+                )
+            self._version_validator()
+        self.expiring_bool = ExpiringSet(max_age_seconds=10)
+        self.cache = {}
+        self.name_cache = {}
+        self.should_delay_torrent_scan = False  # If true torrent scan is delayed by 5 minutes.
+        self.child_processes = []
+        self.ffprobe_downloader = FFprobeDownloader()
+        try:
+            if not any([QBIT_DISABLED, SEARCH_ONLY]):
+                self.ffprobe_downloader.update()
+        except Exception as e:
+            self.logger.error(
+                "FFprobe manager error: %s while attempting to download/update FFprobe", e
+            )
+        self.arr_manager = ArrManager(self).build_arr_instances()
+        run_logs(self.logger)
+
+    def _version_validator(self):
+        if self.min_supported_version <= self.current_qbit_version <= self.max_supported_version:
+            if self._validated_version:
+                self.logger.info(
+                    "Current qBitTorrent version is supported: %s",
+                    self.current_qbit_version,
+                )
+            else:
+                self.logger.warning(
+                    "Could not validate current qBitTorrent version, assuming: %s",
+                    self.current_qbit_version,
+                )
+                time.sleep(10)
+        else:
+            self.logger.critical(
+                "You are currently running qBitTorrent version %s, "
+                "Supported version range is %s to < %s",
+                self.current_qbit_version,
+                self.min_supported_version,
+                self.max_supported_version,
+            )
+            sys.exit(1)
+
+    # @response_text(str)
+    @login_required
+    def app_version(self, **kwargs):
+        return self.client._get(
+            _name=APINames.Application,
+            _method="version",
+            _retries=0,
+            _retry_backoff_factor=0,
+            **kwargs,
+        )
+
+    @property
+    def is_alive(self) -> bool:
+        try:
+            if 1 in self.expiring_bool or self.client is None:
+                return True
+            self.client.app_version()
+            self.logger.trace("Successfully connected to %s:%s", self.qBit_Host, self.qBit_Port)
+            self.expiring_bool.add(1)
+            return True
+        except requests.RequestException:
+            self.logger.warning("Could not connect to %s:%s", self.qBit_Host, self.qBit_Port)
+        self.should_delay_torrent_scan = True
+        return False
+
+    def get_child_processes(self) -> list[pathos.helpers.mp.Process]:
+        run_logs(self.logger)
+        self.logger.debug("Managing %s categories", len(self.arr_manager.managed_objects))
+        count = 0
+        procs = []
+        for arr in self.arr_manager.managed_objects.values():
+            numb, processes = arr.spawn_child_processes()
+            count += numb
+            procs.extend(processes)
+        return procs
+
+    def run(self):
+        try:
+            self.logger.debug("Starting %s child processes", len(self.child_processes))
+            [p.start() for p in self.child_processes]
+            [p.join() for p in self.child_processes]
+        except KeyboardInterrupt:
+            self.logger.info("Detected Ctrl+C - Terminating process")
+            sys.exit(0)
+        except BaseException as e:
+            self.logger.info("Detected Ctrl+C - Terminating process: %r", e)
+            sys.exit(1)
+
+
+def run():
+    global CHILD_PROCESSES
+    early_exit = process_flags()
+    if early_exit is True:
+        sys.exit(0)
+    logger.info("Starting qBitrr: Version: %s.", patched_version)
+    manager = qBitManager()
+    run_logs(logger)
+    logger.debug("Environment variables: %r", ENVIRO_CONFIG)
+    try:
+        if CHILD_PROCESSES := manager.get_child_processes():
+            manager.run()
+        else:
+            logger.warning(
+                "No tasks to perform, if this is unintended double check your config file."
+            )
+    except KeyboardInterrupt:
+        logger.info("Detected Ctrl+C - Terminating process")
+        sys.exit(0)
+    except Exception:
+        logger.info("Attempting to terminate child processes, please wait a moment.")
+        for child in manager.child_processes:
+            child.kill()
+
+
+def cleanup():
+    for p in CHILD_PROCESSES:
+        p.kill()
+        p.terminate()
+
+
+atexit.register(cleanup)
+
+
+if __name__ == "__main__":
+    extensions = [".db", ".db-shm", ".db-wal"]
+    for file in os.listdir(APPDATA_FOLDER):
+        for ext in extensions:
+            if file.endswith(ext):
+                os.remove(os.path.join(APPDATA_FOLDER, file))
+    freeze_support()
+    run()

qBitrr/tables.py

@@ -0,0 +1,52 @@
+from peewee import BooleanField, CharField, DateTimeField, IntegerField, Model, TextField
+
+
+class FilesQueued(Model):
+    EntryId = IntegerField(primary_key=True, null=False, unique=True)
+
+
+class MoviesFilesModel(Model):
+    Title = CharField()
+    Monitored = BooleanField()
+    TmdbId = IntegerField()
+    Year = IntegerField()
+    EntryId = IntegerField(unique=True)
+    Searched = BooleanField(default=False)
+    MovieFileId = IntegerField()
+    IsRequest = BooleanField(default=False)
+    QualityMet = BooleanField(default=False)
+
+
+class EpisodeFilesModel(Model):
+    EntryId = IntegerField(primary_key=True)
+    SeriesTitle = TextField(null=True)
+    Title = TextField(null=True)
+    SeriesId = IntegerField(null=False)
+    EpisodeFileId = IntegerField(null=True)
+    EpisodeNumber = IntegerField(null=False)
+    SeasonNumber = IntegerField(null=False)
+    AbsoluteEpisodeNumber = IntegerField(null=True)
+    SceneAbsoluteEpisodeNumber = IntegerField(null=True)
+    LastSearchTime = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    AirDateUtc = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    Monitored = BooleanField(null=True)
+    Searched = BooleanField(default=False)
+    IsRequest = BooleanField(default=False)
+    QualityMet = BooleanField(default=False)
+
+
+class SeriesFilesModel(Model):
+    EntryId = IntegerField(primary_key=True)
+    Title = TextField(null=True)
+    Monitored = BooleanField(null=True)
+    Searched = BooleanField(default=False)
+
+
+class MovieQueueModel(Model):
+    EntryId = IntegerField(unique=True)
+    Completed = BooleanField(default=False)
+
+
+class EpisodeQueueModel(Model):
+    EntryId = IntegerField(unique=True)
+    Completed = BooleanField(default=False)

qBitrr/utils.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import random
+import socket
+import time
+from typing import Iterator
+
+import ping3
+from cachetools import TTLCache
+
+ping3.EXCEPTIONS = True
+
+logger = logging.getLogger("qBitrr.Utils")
+
+CACHE = TTLCache(maxsize=50, ttl=60)
+
+
+def absolute_file_paths(directory: pathlib.Path | str) -> Iterator[pathlib.Path]:
+    error = True
+    while error is True:
+        try:
+            yield from pathlib.Path(directory).glob("**/*")
+            error = False
+        except FileNotFoundError as e:
+            logger.warning("%s - %s", e.strerror, e.filename)
+
+
+def validate_and_return_torrent_file(file: str) -> pathlib.Path:
+    path = pathlib.Path(file)
+    if path.is_file():
+        path = path.parent.absolute()
+    count = 9
+    while not path.exists():
+        logger.debug(
+            "Attempt %s/10: File does not yet exists! (Possibly being moved?) | "
+            "%s | Sleeping for 0.1s",
+            path,
+            10 - count,
+        )
+        time.sleep(0.1)
+        if count == 0:
+            break
+        count -= 1
+    else:
+        count = 0
+    while str(path) == ".":
+        path = pathlib.Path(file)
+        if path.is_file():
+            path = path.parent.absolute()
+        while not path.exists():
+            logger.debug(
+                "Attempt %s/10:File does not yet exists! (Possibly being moved?) | "
+                "%s | Sleeping for 0.1s",
+                path,
+                10 - count,
+            )
+            time.sleep(0.1)
+            if count == 0:
+                break
+            count -= 1
+        else:
+            count = 0
+        if count == 0:
+            break
+        count -= 1
+    return path
+
+
+def has_internet():
+    from qBitrr.config import PING_URLS
+
+    url = random.choice(PING_URLS)
+    if not is_connected(url):
+        return False
+    logger.debug("Successfully connected to %s", url)
+    return True
+
+
+def _basic_ping(hostname):
+    host = "N/A"
+    try:
+        # if this hostname was called within the last 10 seconds skip it
+        # if it was previous successful
+        # Reducing the number of call to it and the likelihood of rate-limits.
+        if hostname in CACHE:
+            return CACHE[hostname]
+        # see if we can resolve the host name -- tells us if there is
+        # a DNS listening
+        host = socket.gethostbyname(hostname)
+        # connect to the host -- tells us if the host is actually
+        # reachable
+        s = socket.create_connection((host, 80), 5)
+        s.close()
+        CACHE[hostname] = True
+        return True
+    except Exception as e:
+        logger.debug(
+            "Error when connecting to host: %s %s %s",
+            hostname,
+            host,
+            e,
+        )
+        return False
+
+
+def is_connected(hostname):
+    try:
+        # if this hostname was called within the last 10 seconds skip it
+        # if it was previous successful
+        # Reducing the number of call to it and the likelihood of rate-limits.
+        if hostname in CACHE:
+            return CACHE[hostname]
+        ping3.ping(hostname, timeout=5)
+        CACHE[hostname] = True
+        return True
+    except ping3.errors.PingError as e:  # All ping3 errors are subclasses of `PingError`.
+        logger.debug(
+            "Error when connecting to host: %s %s",
+            hostname,
+            e,
+        )
+    except (
+        Exception
+    ):  # Ping3 is far more robust but may requite root access, if root access is not available then run the basic mode
+        return _basic_ping(hostname)
+
+
+class ExpiringSet:
+    def __init__(self, *args: list, **kwargs):
+        max_age_seconds = kwargs.get("max_age_seconds", 0)
+        assert max_age_seconds > 0
+        self.age = max_age_seconds
+        self.container = {}
+        for arg in args:
+            self.add(arg)
+
+    def __repr__(self):
+        self.__update__()
+        return f"{self.__class__.__name__}({', '.join(self.container.keys())})"
+
+    def extend(self, args):
+        """Add several items at once."""
+        for arg in args:
+            self.add(arg)
+
+    def add(self, value):
+        self.container[value] = time.time()
+
+    def remove(self, item):
+        del self.container[item]
+
+    def contains(self, value):
+        if value not in self.container:
+            return False
+        if time.time() - self.container[value] > self.age:
+            del self.container[value]
+            return False
+        return True
+
+    __contains__ = contains
+
+    def __getitem__(self, index):
+        self.__update__()
+        return list(self.container.keys())[index]
+
+    def __iter__(self):
+        self.__update__()
+        return iter(self.container.copy())
+
+    def __len__(self):
+        self.__update__()
+        return len(self.container)
+
+    def __copy__(self):
+        self.__update__()
+        temp = ExpiringSet(max_age_seconds=self.age)
+        temp.container = self.container.copy()
+        return temp
+
+    def __update__(self):
+        for k, b in self.container.copy().items():
+            if time.time() - b > self.age:
+                del self.container[k]
+                return False
+
+    def __hash__(self):
+        return hash(*(self.container.keys()))
+
+    def __eq__(self, other):
+        return self.__hash__() == other.__hash__()

qBitrr2-3.7.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Feramance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.