2026-06-27T0823Z

Author: Windows81

Source/pretasks/download.py

@@ -7,7 +7,7 @@
 import ssl
 
 # Third-party imports
-import tqdm_vendored as tqdm
+from vendored import tqdm
 import py7zr
 
 # Local application/library specific imports

Source/requirements.txt

@@ -3,7 +3,5 @@ urllib3>=2.7.0
 pyzstd~=0.19.1
 py7zr~=1.1.0
 lz4~=4.4.5
-tqdm_vendored @ git+https://github.com/Windows81/Vendored-Tqdm
-sqlite-worker @ git+https://github.com/Windows81/SQLite-Worker
 pywin32 ; sys_platform == 'win32'
 dracopy~=2.0.0

Source/storage/__init__.py

@@ -1,4 +1,4 @@
-import sqlite_worker
+from vendored import sqlite_worker
 import os.path
 
 from . import (

Source/storage/_logic.py

@@ -1,5 +1,5 @@
 from typing import ClassVar
-import sqlite_worker
+from vendored import sqlite_worker
 
 
 class sqlite_connector_base:

Source/vendored/sqlite_worker/__init__.py

@@ -0,0 +1,121 @@
+import logging
+import sqlite3
+import threading
+import uuid
+import queue
+
+LOGGER = logging.getLogger("SqliteWorker")
+SILENT_TOKEN_SUFFIX = '-silent'
+
+
+class SqliteWorker:
+    """Sqlite thread-safe object."""
+
+    def __init__(self, file_name, max_queue_size=100, execute_init=(), max_count=50):
+        self._file_name = file_name
+        self._sql_queue = queue.Queue(maxsize=max_queue_size)
+        self._results = {}
+        self._tokens = set()
+        self._select_events = {}
+        self._lock = threading.Lock()
+        self._close_event = threading.Event()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+        self.execute_init = execute_init
+        self.max_count = max_count
+
+    def _run(self):
+        try:
+            self._process_queries()
+        except Exception as err:
+            LOGGER.critical(
+                "Unhandled exception in query processor: %s", err, exc_info=True)
+            raise
+
+    def _process_queries(self):
+        with sqlite3.connect(self._file_name, check_same_thread=False, detect_types=sqlite3.PARSE_DECLTYPES) as conn:
+            cursor = conn.cursor()
+            for action in self.execute_init:
+                cursor.execute(action)
+            conn.commit()
+
+            count = 0
+            while not self._close_event.is_set() or not self._sql_queue.empty():
+                try:
+                    token, query, values = self._sql_queue.get(timeout=1)
+                except queue.Empty:
+                    continue
+                if query:
+                    count += 1
+                    self._execute_query(cursor, token, query, values)
+
+                if count >= self.max_count or self._sql_queue.empty():
+                    count = 0
+                    conn.commit()
+
+    def _execute_query(self, cursor, token: str, query, values):
+        try:
+            cursor.execute(query, values)
+            if not token.endswith(SILENT_TOKEN_SUFFIX):
+                with self._lock:
+                    self._results[token] = cursor.fetchall()
+        except sqlite3.Error as err:
+            LOGGER.error("Query error: %s: %s: %s", query, values, err)
+            self._handle_query_error(token, err)
+        self._notify_query_done(token)
+
+    def _is_select_query(self, query):
+        return query.lower().lstrip().startswith("select")
+
+    def _notify_query_begin(self, token):
+        self._select_events.setdefault(token, threading.Event())
+
+    def _notify_query_done(self, token):
+        self._select_events[token].set()
+
+    def _handle_query_error(self, token, err):
+        with self._lock:
+            self._results[token] = err
+
+    def close(self):
+        self._close_event.set()
+        self._sql_queue.put((None, None, None), timeout=5)
+        self._thread.join()
+
+    def execute(self, query, values=None, always_return_token=False):
+        if self._close_event.is_set():
+            raise RuntimeError("Worker is closed")
+
+        should_return_token = (
+            always_return_token or
+            self._is_select_query(query)
+        )
+
+        token = uuid.uuid4().hex
+        if should_return_token is None:
+            token += SILENT_TOKEN_SUFFIX
+
+        self._sql_queue.put((token, query, values or []), timeout=5)
+        self._notify_query_begin(token)
+
+        if should_return_token:
+            return token
+        return None
+
+    def execute_and_fetch(self, query, values=None, always_synchronous=True):
+        return self.fetch_results(self.execute(query, values, always_return_token=always_synchronous))
+
+    def fetch_results(self, token):
+        if token is None:
+            return
+        with self._lock:
+            event = self._select_events.get(token)
+        if event is None:
+            return
+        event.wait()
+        with self._lock:
+            return self._results.pop(token, None)
+
+    @property
+    def queue_size(self):
+        return self._sql_queue.qsize()

Source/vendored/tqdm/__init__.py

@@ -0,0 +1,13 @@
+from ._monitor import TMonitor, TqdmSynchronisationWarning
+from .cli import main  # TODO: remove in v5.0.0
+from .std import (
+    TqdmDeprecationWarning, TqdmExperimentalWarning, TqdmKeyError, TqdmMonitorWarning,
+    TqdmTypeError, TqdmWarning, tqdm, trange)
+from .version import __version__
+
+__all__ = ['tqdm', 'trange', 'main', 'TMonitor',
+           'TqdmTypeError', 'TqdmKeyError',
+           'TqdmWarning', 'TqdmDeprecationWarning',
+           'TqdmExperimentalWarning',
+           'TqdmMonitorWarning', 'TqdmSynchronisationWarning',
+           '__version__']

Source/vendored/tqdm/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

Source/vendored/tqdm/_main.py

@@ -0,0 +1,9 @@
+from warnings import warn
+
+from .cli import *  # NOQA
+from .cli import __all__  # NOQA
+from .std import TqdmDeprecationWarning
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.cli.*` instead of `tqdm._main.*`",
+     TqdmDeprecationWarning, stacklevel=2)

Source/vendored/tqdm/_monitor.py

@@ -0,0 +1,94 @@
+import atexit
+from threading import Event, Thread, current_thread
+from time import time
+from warnings import warn
+
+__all__ = ["TMonitor", "TqdmSynchronisationWarning"]
+
+
+class TqdmSynchronisationWarning(RuntimeWarning):
+    """tqdm multi-thread/-process errors which may cause incorrect nesting
+    but otherwise no adverse effects"""
+    pass
+
+
+class TMonitor(Thread):
+    """
+    Monitoring thread for tqdm bars.
+    Monitors if tqdm bars are taking too much time to display
+    and readjusts miniters automatically if necessary.
+
+    Parameters
+    ----------
+    tqdm_cls  : class
+        tqdm class to use (can be core tqdm or a submodule).
+    sleep_interval  : fload
+        Time to sleep between monitoring checks.
+    """
+    _test = {}  # internal vars for unit testing
+
+    def __init__(self, tqdm_cls, sleep_interval):
+        Thread.__init__(self)
+        self.daemon = True  # kill thread when main killed (KeyboardInterrupt)
+        self.woken = 0  # last time woken up, to sync with monitor
+        self.tqdm_cls = tqdm_cls
+        self.sleep_interval = sleep_interval
+        self._time = self._test.get("time", time)
+        self.was_killed = self._test.get("Event", Event)()
+        atexit.register(self.exit)
+        self.start()
+
+    def exit(self):
+        self.was_killed.set()
+        if self is not current_thread():
+            self.join()
+        return self.report()
+
+    def get_instances(self):
+        # returns a copy of started `tqdm_cls` instances
+        return [i for i in self.tqdm_cls._instances.copy()
+                # Avoid race by checking that the instance started
+                if hasattr(i, 'start_t')]
+
+    def run(self):
+        cur_t = self._time()
+        while True:
+            # After processing and before sleeping, notify that we woke
+            # Need to be done just before sleeping
+            self.woken = cur_t
+            # Sleep some time...
+            self.was_killed.wait(self.sleep_interval)
+            # Quit if killed
+            if self.was_killed.is_set():
+                return
+            # Then monitor!
+            # Acquire lock (to access _instances)
+            with self.tqdm_cls.get_lock():
+                cur_t = self._time()
+                # Check tqdm instances are waiting too long to print
+                instances = self.get_instances()
+                for instance in instances:
+                    # Check event in loop to reduce blocking time on exit
+                    if self.was_killed.is_set():
+                        return
+                    # Only if mininterval > 1 (else iterations are just slow)
+                    # and last refresh exceeded maxinterval
+                    if instance.miniters > 1 and \
+                            (cur_t - instance.last_print_t) >= \
+                            instance.maxinterval:
+                        # force bypassing miniters on next iteration
+                        # (dynamic_miniters adjusts mininterval automatically)
+                        instance.miniters = 1
+                        # Refresh now! (works only for manual tqdm)
+                        instance.refresh(nolock=True)
+                    # Remove accidental long-lived strong reference
+                    del instance
+                if instances != self.get_instances():  # pragma: nocover
+                    warn("Set changed size during iteration" +
+                         " (see https://github.com/tqdm/tqdm/issues/481)",
+                         TqdmSynchronisationWarning, stacklevel=2)
+                # Remove accidental long-lived strong references
+                del instances
+
+    def report(self):
+        return not self.was_killed.is_set()

Source/vendored/tqdm/_tqdm.py

@@ -0,0 +1,9 @@
+from warnings import warn
+
+from .std import *  # NOQA
+from .std import __all__  # NOQA
+from .std import TqdmDeprecationWarning
+
+warn("This function will be removed in tqdm==5.0.0\n"
+     "Please use `tqdm.std.*` instead of `tqdm._tqdm.*`",
+     TqdmDeprecationWarning, stacklevel=2)