seedsyncarr 1.1.1__tar.gz

seedsyncarr-1.1.1/.gitignore

@@ -0,0 +1,29 @@
+.idea
+*.pyc
+/build
+.venv
+src/python/build
+src/python/site
+htmlcov/
+.coverage
+node_modules/
+__pycache__/
+src/python/.pytest_cache/
+src/python/htmlcov/
+src/angular/dist/
+.DS_Store
+.pytest_cache/
+.ruff_cache/
+
+# SSH private keys
+id_rsa
+*.pem
+# AI tooling (local only)
+.agents/
+.aidesigner/*
+!.aidesigner/.gitkeep
+.claude/
+.mcp.json
+.planning/tmp/
+docs/superpowers/
+shield-claude-skill/

seedsyncarr-1.1.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: seedsyncarr
+Version: 1.1.1
+Summary: Fast file syncing from remote servers with a web UI, powered by LFTP
+Author: thejuran
+Requires-Python: <3.13,>=3.11
+Requires-Dist: bottle>=0.13.4
+Requires-Dist: cryptography<47,>=44.0.0
+Requires-Dist: paste>=3.10.1
+Requires-Dist: patool>=4.0.3
+Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pytz>=2025.2
+Requires-Dist: requests>=2.33.0
+Requires-Dist: tblib>=3.2.2
+Requires-Dist: timeout-decorator>=0.5.0
+Provides-Extra: dev
+Requires-Dist: mkdocs-material>=9.7.1; extra == 'dev'
+Requires-Dist: mkdocs>=1.6.1; extra == 'dev'
+Requires-Dist: parameterized>=0.9.0; extra == 'dev'
+Requires-Dist: pyinstaller>=6.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
+Requires-Dist: pytest-timeout>=2.3.1; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Requires-Dist: testfixtures>=11.0.0; extra == 'dev'
+Requires-Dist: webtest>=3.0.7; extra == 'dev'

seedsyncarr-1.1.1/common/__init__.py

@@ -0,0 +1,13 @@
+from .types import overrides as overrides
+from .job import Job as Job
+from .context import Context as Context, Args as Args
+from .error import AppError as AppError, ServiceExit as ServiceExit, ServiceRestart as ServiceRestart
+from .encryption import EncryptionError as EncryptionError, DecryptionError as DecryptionError
+from .constants import Constants as Constants
+from .config import Config as Config, ConfigError as ConfigError
+from .persist import Persist as Persist, PersistError as PersistError, Serializable as Serializable
+from .localization import Localization as Localization
+from .multiprocessing_logger import MultiprocessingLogger as MultiprocessingLogger
+from .status import Status as Status, IStatusListener as IStatusListener, StatusComponent as StatusComponent, IStatusComponentListener as IStatusComponentListener
+from .app_process import AppProcess as AppProcess, AppOneShotProcess as AppOneShotProcess
+from .bounded_ordered_set import BoundedOrderedSet as BoundedOrderedSet

seedsyncarr-1.1.1/common/app_process.py

@@ -0,0 +1,166 @@
+import logging
+import sys
+import time
+from abc import abstractmethod
+from multiprocessing import Process, Queue, Event
+import queue
+import signal
+import threading
+from datetime import datetime
+
+import tblib.pickling_support
+
+from common import overrides, ServiceExit, MultiprocessingLogger
+
+tblib.pickling_support.install()
+
+class ExceptionWrapper:
+    """
+    An exception wrapper that works across processes
+    Source: https://stackoverflow.com/a/26096355/8571324
+    """
+    def __init__(self, ee):
+        self.ee = ee
+        __,  __, self.tb = sys.exc_info()
+
+    def re_raise(self):
+        raise self.ee.with_traceback(self.tb)
+
+class AppProcess(Process):
+    """
+    Process with some additional functionality and fixes
+      * Support for a multiprocessing logger
+      * Removes signals to prevent join problems
+      * Propagates exceptions to owner process
+      * Safe terminate with timeout, followed by force terminate
+    """
+
+    # Timeout before process is force terminated
+    __DEFAULT_TERMINATE_TIMEOUT_MS = 1000
+
+    def __init__(self, name: str):
+        self.__name = name
+        super().__init__(name=self.__name)
+
+        self.mp_logger = None
+        self.logger = logging.getLogger(self.__name)
+        self.__exception_queue = Queue()
+        self._terminate = Event()
+
+    def set_multiprocessing_logger(self, mp_logger: MultiprocessingLogger):
+        self.mp_logger = mp_logger
+
+    @overrides(Process)
+    def run(self):
+        # Replace the signal handlers that may have been set by main process to
+        # default handlers. Having non-default handlers in subprocesses causes
+        # a deadlock when attempting to join the process
+        # Info: https://stackoverflow.com/a/631605
+
+        # NOTE: There is a minuscule chance of deadlock if a signal is received
+        #       between start of the method and these resets.
+        #       The ideal solution is to remove the signal before the process is
+        #       started. Unfortunately that's difficult to do here because the
+        #       subprocess is started from a job thread, and python doesn't
+        #       allow setting signals from outside the main thread.
+        #       So we accept this risk for the quick and easy solution here
+        signal.signal(signal.SIGTERM, signal.SIG_DFL)
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+        # Set the thread name for convenience
+        threading.current_thread().name = self.__name
+
+        # Configure the logger for this process
+        if self.mp_logger:
+            self.logger = self.mp_logger.get_process_safe_logger().getChild(self.__name)
+
+        self.logger.debug("Started process")
+
+        self.run_init()
+
+        try:
+            while not self._terminate.is_set():
+                self.run_loop()
+            self.logger.debug("Process received terminate flag")
+        except ServiceExit:
+            self.logger.debug("Process received a ServiceExit")
+        except Exception as e:
+            self.logger.debug("Process caught an exception")
+            self.__exception_queue.put(ExceptionWrapper(e))
+            raise
+        finally:
+            self.run_cleanup()
+
+        self.logger.debug("Exiting process")
+
+    @overrides(Process)
+    def terminate(self):
+        # Send a terminate signal, and force terminate after a timeout
+        self._terminate.set()
+
+        def elapsed_ms(start):
+            delta_in_s = (datetime.now() - start).total_seconds()
+            delta_in_ms = int(delta_in_s * 1000)
+            return delta_in_ms
+
+        timestamp_start = datetime.now()
+        while self.is_alive() and \
+                elapsed_ms(timestamp_start) < AppProcess.__DEFAULT_TERMINATE_TIMEOUT_MS:
+            time.sleep(0.01)  # 10ms polling interval to avoid CPU spin
+
+        super().terminate()
+
+    def propagate_exception(self):
+        """
+        Raises any exception that was caught by the process
+        """
+        try:
+            exc = self.__exception_queue.get(block=False)
+            exc.re_raise()
+        except queue.Empty:
+            pass
+
+    @abstractmethod
+    def run_init(self):
+        """
+        Called once before the run loop
+        """
+        pass
+
+    @abstractmethod
+    def run_cleanup(self):
+        """
+        Called once before cleanup
+        """
+        pass
+
+    @abstractmethod
+    def run_loop(self):
+        """
+        Process behaviour should be implemented here.
+        This function is repeatedly called until process exits.
+        The check for graceful shutdown is performed between the loop iterations,
+        so try to limit the run time for this method.
+        """
+        pass
+
+class AppOneShotProcess(AppProcess):
+    """
+    App process that runs only once and then exits
+    """
+    def run_loop(self):
+        self.run_once()
+        self._terminate.set()
+
+    def run_cleanup(self):
+        pass
+
+    def run_init(self):
+        pass
+
+    @abstractmethod
+    def run_once(self):
+        """
+        Process behaviour should be implemented here
+        """
+        pass

seedsyncarr-1.1.1/common/bounded_ordered_set.py

@@ -0,0 +1,203 @@
+from collections import OrderedDict
+from typing import TypeVar, Generic, Iterator, Iterable, Optional, Set
+
+T = TypeVar('T')
+
+class BoundedOrderedSet(Generic[T]):
+    """
+    A set-like container with a maximum size that evicts oldest entries.
+
+    This class provides:
+    - Set semantics (unique elements, membership testing)
+    - Insertion order preservation
+    - Automatic LRU-style eviction when maxlen is reached
+    - O(1) membership testing, add, and remove operations
+
+    When maxlen is reached and a new item is added, the oldest item
+    (first inserted that hasn't been removed) is automatically evicted.
+
+    Thread-safety: Not thread-safe. Callers must provide external synchronization.
+
+    Example:
+        >>> bset = BoundedOrderedSet(maxlen=3)
+        >>> bset.add('a')
+        >>> bset.add('b')
+        >>> bset.add('c')
+        >>> bset.add('d')  # 'a' is evicted
+        >>> list(bset)
+        ['b', 'c', 'd']
+    """
+
+    # Default maximum size (10,000 files is reasonable for most use cases)
+    DEFAULT_MAXLEN = 10000
+
+    def __init__(self, maxlen: Optional[int] = None, iterable: Optional[Iterable[T]] = None):
+        """
+        Initialize a bounded ordered set.
+
+        :param maxlen: Maximum number of elements. If None, uses DEFAULT_MAXLEN.
+                       Must be positive.
+        :param iterable: Optional iterable of initial elements.
+        """
+        self._maxlen = maxlen if maxlen is not None else self.DEFAULT_MAXLEN
+        if self._maxlen < 1:
+            raise ValueError("maxlen must be positive, got {}".format(self._maxlen))
+
+        # Use OrderedDict as backing store - keys are elements, values are ignored
+        self._data: OrderedDict[T, None] = OrderedDict()
+
+        # Track total evictions for monitoring/debugging
+        self._total_evictions = 0
+
+        if iterable is not None:
+            for item in iterable:
+                self.add(item)
+
+    @property
+    def maxlen(self) -> int:
+        """Maximum number of elements allowed."""
+        return self._maxlen
+
+    @property
+    def total_evictions(self) -> int:
+        """Total number of elements evicted since creation."""
+        return self._total_evictions
+
+    def add(self, item: T) -> Optional[T]:
+        """
+        Add an item to the set.
+
+        If the item already exists, this is a no-op (it does NOT update order).
+        If adding would exceed maxlen, the oldest item is evicted first.
+
+        :param item: Item to add
+        :return: The evicted item if eviction occurred, None otherwise
+        """
+        # If item exists, do nothing (standard set behavior)
+        if item in self._data:
+            return None
+
+        evicted = None
+
+        # Evict oldest if at capacity
+        if len(self._data) >= self._maxlen:
+            # popitem(last=False) removes the first (oldest) item
+            evicted, _ = self._data.popitem(last=False)
+            self._total_evictions += 1
+
+        self._data[item] = None
+        return evicted
+
+    def touch(self, item: T) -> bool:
+        """
+        Move an item to the end (most recent position) if it exists.
+
+        This refreshes the item's position in the LRU order, preventing
+        it from being evicted soon. If the item doesn't exist, does nothing.
+
+        :param item: Item to refresh
+        :return: True if item was found and touched, False otherwise
+        """
+        if item not in self._data:
+            return False
+        # Move to end (most recent position)
+        self._data.move_to_end(item)
+        return True
+
+    def discard(self, item: T) -> None:
+        """
+        Remove an item from the set if present.
+
+        Does not raise an error if the item is not present.
+
+        :param item: Item to remove
+        """
+        self._data.pop(item, None)
+
+    def remove(self, item: T) -> None:
+        """
+        Remove an item from the set.
+
+        :param item: Item to remove
+        :raises KeyError: If item is not in the set
+        """
+        del self._data[item]
+
+    def clear(self) -> None:
+        """Remove all items from the set."""
+        self._data.clear()
+
+    def difference_update(self, other: Iterable[T]) -> None:
+        """
+        Remove all items that are in 'other' from this set.
+
+        Equivalent to: self -= other
+
+        :param other: Iterable of items to remove
+        """
+        for item in other:
+            self.discard(item)
+
+    def __contains__(self, item: T) -> bool:
+        """Check if item is in the set."""
+        return item in self._data
+
+    def __len__(self) -> int:
+        """Return the number of items in the set."""
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[T]:
+        """Iterate over items in insertion order."""
+        return iter(self._data)
+
+    def __bool__(self) -> bool:
+        """Return True if the set is non-empty."""
+        return bool(self._data)
+
+    def __repr__(self) -> str:
+        items = list(self._data.keys())
+        return "BoundedOrderedSet({}, maxlen={})".format(items, self._maxlen)
+
+    def __eq__(self, other) -> bool:
+        """
+        Test equality with another BoundedOrderedSet or regular set.
+
+        Only compares contents, not maxlen or eviction count.
+        """
+        if isinstance(other, BoundedOrderedSet):
+            return set(self._data.keys()) == set(other._data.keys())
+        elif isinstance(other, (set, frozenset)):
+            return set(self._data.keys()) == other
+        return NotImplemented
+
+    def copy(self) -> "BoundedOrderedSet[T]":
+        """
+        Create a shallow copy of this set.
+
+        The copy has the same maxlen but eviction count is reset to 0.
+        """
+        new_set: BoundedOrderedSet[T] = BoundedOrderedSet(maxlen=self._maxlen)
+        new_set._data = self._data.copy()
+        return new_set
+
+    def as_set(self) -> Set[T]:
+        """Return a regular set containing all items."""
+        return set(self._data.keys())
+
+    def as_list(self) -> list:
+        """Return a list of items in insertion order."""
+        return list(self._data.keys())
+
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[T], maxlen: Optional[int] = None) -> "BoundedOrderedSet[T]":
+        """
+        Create a BoundedOrderedSet from an iterable.
+
+        If the iterable has more items than maxlen, only the last maxlen
+        items (in iteration order) will be retained.
+
+        :param iterable: Source iterable
+        :param maxlen: Maximum size (uses DEFAULT_MAXLEN if None)
+        :return: New BoundedOrderedSet
+        """
+        return cls(maxlen=maxlen, iterable=iterable)