Merge pull request 'exposed minio adapter' (#5) from expose-minio-adapter into main

Reviewed-on: brian/python-repositories#5

.gitea/workflows/code-quality.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Install dependencies
         env:
           UV_LINK_MODE: copy
-        run: uv sync
+        run: uv sync --all-extras
 
       - name: Type check with mypy
         run: uv run mypy .

.gitea/workflows/test.yml

@@ -24,9 +24,24 @@ jobs:
       - name: Install dependencies
         env:
           UV_LINK_MODE: copy
-        run: uv sync
+        run: uv sync --all-extras
 
       - name: Run pytest
         env:
           PYTHONPATH: .
-        run: uv run pytest
+        run: uv run pytest --cov=python_repositories --cov-report=term-missing > coverage.txt
+
+      - name: Post coverage summary to PR
+        env:
+          API_URL: ${{ vars.API_URL }}
+          REPO_OWNER: ${{ github.repository_owner }}
+          REPO_NAME: ${{ github.event.repository.name }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          CI_RUNNER_TOKEN: ${{ secrets.CI_RUNNER_TOKEN }}
+        run: |
+          COVERAGE=$(cat coverage.txt)
+          COMMENT_BODY="**Test Coverage Report:**\n\`\`\`\n$COVERAGE\n\`\`\`"
+          curl -s -X POST "$API_URL/repos/$REPO_OWNER/$REPO_NAME/issues/$PR_NUMBER/comments" \
+            -H "Authorization: token $CI_RUNNER_TOKEN" \
+            -H "Content-Type: application/json" \
+            -d "{\"body\": \"$COMMENT_BODY\"}"

README.md

@@ -1,3 +1,17 @@
 # python-repositories
 
 Various python repository interfaces exposed as a python package.
+
+## Optional dependencies
+
+This package supports interacting with multiple different backends:
+
+- Redis
+- Mongo
+- MinIO
+
+To add support for a specific backend install this package with one or more of these optional packages:
+
+```bash
+uv add python-repositories[redis, mongo, minio]
+```

pyproject.toml

@@ -13,13 +13,32 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-dependencies = []
+dependencies = [
+    "python-utils>=0.1.0",
+    "structlog>=25.4.0",
+]
+
+[project.optional-dependencies]
+redis = [
+    "redis>=6.4.0",
+]
+minio = [
+    "minio>=7.2.16",
+]
+
+[tool.uv.sources]
+python-utils = { index = "gitea" }
 
 [[tool.uv.index]]
-name = "private-cache"
+name = "threadripper-proxpi-cache"
 url = "http://10.0.0.2:5001/index/"
 default = true
 
+[[tool.uv.index]]
+name = "gitea"
+url = "https://gitea.gt-proj.com/api/packages/brian/pypi/simple/"
+explicit = true
+
 [tool.mypy]
 python_version = "3.10"
 warn_return_any = true  # nudge to use stricter types
@@ -37,12 +56,23 @@ show_error_codes = true  # show error codes in output
 explicit_package_bases = true  # reduce risk of import confusion
 namespace_packages = true  # enable namespace packages
 
+[[tool.mypy.overrides]]
+module = "testcontainers.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "minio.*"
+ignore_missing_imports = true
+
 [dependency-groups]
 dev = [
     "mypy>=1.17.1",
     "pre-commit>=4.3.0",
     "pytest>=8.4.1",
+    "pytest-cov>=7.0.0",
     "pyupgrade>=3.20.0",
     "ruff>=0.12.11",
     "safety>=3.6.0",
+    "testcontainers>=4.13.0",
+    "types-redis>=4.6.0.20241004",
 ]

python_repositories/__init__.py

@@ -0,0 +1,6 @@
+"""python_repositories: Unified repository interfaces and adapters."""
+
+from . import adapters
+from . import interfaces
+
+__all__ = ["adapters", "interfaces"]

python_repositories/adapters/__init__.py

@@ -0,0 +1,13 @@
+"""
+Adapters for various backend repositories (e.g., Redis, Minio).
+
+This module exposes concrete implementations for repository interfaces.
+"""
+
+from .redis_adapter import RedisAdapter
+from .minio_adapter import MinioAdapter
+
+__all__ = [
+    "RedisAdapter",
+    "MinioAdapter",
+]

python_repositories/adapters/minio_adapter.py

@@ -0,0 +1,214 @@
+"""Definition of MinioAdapter class."""
+
+from __future__ import annotations
+import os
+from io import BytesIO
+
+import structlog
+from minio import Minio, S3Error
+
+from python_utils import check_env
+
+from python_repositories.interfaces import (
+    ContextAwareInterface,
+    ConnectionAwareInterface,
+)
+
+
+class MinioAdapter(
+    ContextAwareInterface,
+    ConnectionAwareInterface,
+):
+    """Minio adapter exposing basic CRUD functionality."""
+
+    endpoint_env_var_name: str = "MINIO_ENDPOINT"
+    access_key_env_var_name: str = "MINIO_ACCESS_KEY"
+    secret_key_env_var_name: str = "MINIO_SECRET_KEY"
+    bucket_env_var_name: str = "MINIO_BUCKET"
+    chunk_size: int = 5 * 2**20  # 5 MiB
+
+    def __init__(self) -> None:
+        # Setup logger
+        self.logger = structlog.get_logger(
+            self.__class__.__name__,
+        )
+        # Check environment variables
+        check_env(
+            {
+                self.endpoint_env_var_name,
+                self.access_key_env_var_name,
+                self.secret_key_env_var_name,
+                self.bucket_env_var_name,
+            },
+        )
+        # Prepare internal variables
+        self._client: Minio | None = None
+        self._bucket_name: str | None = None
+
+    def __enter__(self) -> MinioAdapter:
+        """Enter the context."""
+        self.connect()
+        return self
+
+    def __exit__(
+        self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+    ) -> None:
+        """Exit the context."""
+        ctx_info = {"exc_type": exc_type, "exc_val": exc_val, "exc_tb": exc_tb}
+        if any(
+            (
+                exc_type is not None,
+                exc_val is not None,
+                exc_tb is not None,
+            ),
+        ):
+            self.logger.error("Error while exiting context", **ctx_info)
+        self.disconnect()
+
+    def connect(self) -> None:
+        """Connect to the Minio server."""
+        # Stop if already connected
+        if self.is_connected:
+            self.logger.info("Already connected to Minio")
+            return
+        # Prepare arguments
+        endpoint = str(os.getenv(self.endpoint_env_var_name))
+        access_key = str(os.getenv(self.access_key_env_var_name))
+        secret_key = str(os.getenv(self.secret_key_env_var_name))
+        bucket = str(os.getenv(self.bucket_env_var_name))
+        # Connect client
+        client = Minio(
+            endpoint=endpoint,
+            access_key=access_key,
+            secret_key=secret_key,
+            secure=False,
+        )
+        # Test the connection by listing buckets (will raise if connection fails)
+        try:
+            _ = client.list_buckets()
+        except Exception as exc:  # pylint: disable=broad-except
+            raise ConnectionError(f"Could not connect to Minio at {endpoint}") from exc
+        # Ensure bucket exists
+        if not client.bucket_exists(bucket):
+            self.logger.info(f"Creating bucket '{bucket}'")
+            client.make_bucket(bucket)
+        # Persist information
+        self._client = client
+        self._bucket_name = bucket
+
+    def disconnect(self) -> None:
+        """Disconnect from the Minio server."""
+        # Close connection
+        # N.B. Minio client does not have a close method, but we include this for symmetry with other adapters
+        # Reset client
+        self._client = None
+        self._bucket_name = None
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to Minio server."""
+        res = bool(isinstance(self._client, Minio))
+        self.logger.debug(res)
+        return res
+
+    def _put(self, object_name: str, data: BytesIO) -> None:
+        """Put an object into the Minio bucket."""
+        # Check input
+        if not isinstance(object_name, str) or len(object_name) == 0:
+            raise ValueError("object_name must be a non-empty string")
+        if not isinstance(data, BytesIO) or data.getbuffer().nbytes == 0:
+            raise ValueError("data must be a non-empty BytesIO object")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Minio")
+        # Prepare buffer for reading
+        num_bytes = data.getbuffer().nbytes
+        data.seek(0)
+        # Send data to bucket
+        # N.B. bucket name is set when connecting
+        self._client.put_object(
+            bucket_name=self._bucket_name,
+            object_name=object_name,
+            data=data,
+            length=num_bytes,
+            part_size=self.chunk_size,
+        )
+        self.logger.debug(
+            f"Put object '{object_name}' into bucket '{self._bucket_name}'"
+        )
+
+    def _get(self, object_name: str) -> BytesIO | None:
+        """Get an object from the Minio bucket."""
+        # Check input
+        if not isinstance(object_name, str) or len(object_name) == 0:
+            raise ValueError("object_name must be a non-empty string")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Minio")
+        # Get data from bucket
+        # N.B. bucket name is set when connecting
+        try:
+            response = self._client.get_object(
+                bucket_name=self._bucket_name,
+                object_name=object_name,
+            )
+            # Get buffered data
+            buffer = BytesIO()
+            while chunk := response.read(self.chunk_size):
+                buffer.write(chunk)
+            buffer.seek(0)
+            self.logger.debug(
+                f"Got object '{object_name}' from bucket '{self._bucket_name}'"
+            )
+            return buffer
+        except S3Error as exc:
+            if exc.code == "NoSuchKey":
+                self.logger.warning(
+                    f"Object '{object_name}' not found in bucket '{self._bucket_name}'"
+                )
+            else:
+                self.logger.error(repr(exc))
+        except Exception as exc:  # pylint: disable=broad-except
+            self.logger.error(repr(exc))
+        return None
+
+    def _delete(self, object_name: str) -> None:
+        """Delete an object from the Minio bucket."""
+        # Check input
+        if not isinstance(object_name, str) or len(object_name) == 0:
+            raise ValueError("object_name must be a non-empty string")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Minio")
+        # Delete object from bucket
+        # N.B. bucket name is set when connecting
+        self._client.remove_object(
+            bucket_name=self._bucket_name,
+            object_name=object_name,
+        )
+        self.logger.debug(
+            f"Deleted object '{object_name}' from bucket '{self._bucket_name}'"
+        )
+
+    def _list_objects(self, prefix: str = "") -> list[str]:
+        """List objects in the Minio bucket with an optional prefix."""
+        # Check input
+        if not isinstance(prefix, str):
+            raise ValueError("prefix must be a string")
+        # Check connection
+        # N.B. bucket name is set when connecting
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Minio")
+        # List objects in bucket
+        objects = self._client.list_objects(
+            bucket_name=self._bucket_name,
+            prefix=prefix,
+            recursive=True,
+        )
+        object_names = [
+            obj.object_name for obj in objects if obj.object_name is not None
+        ]
+        self.logger.debug(
+            f"Listed {len(object_names)} object(s) in bucket '{self._bucket_name}' with prefix '{prefix}'"
+        )
+        return object_names

python_repositories/adapters/redis_adapter.py

@@ -0,0 +1,149 @@
+"""Definition of RedisAdapter class."""
+
+from __future__ import annotations
+from typing import cast
+
+import os
+import structlog
+
+import redis
+from redis.commands.json.path import Path as RedisPath
+
+from python_utils import check_env
+
+from python_repositories.interfaces import (
+    ContextAwareInterface,
+    ConnectionAwareInterface,
+)
+
+
+class RedisAdapter(
+    ContextAwareInterface,
+    ConnectionAwareInterface,
+):
+    """Redis adapter exposing basic CRUD functionality."""
+
+    uri_env_var_name: str = "REDIS_URI"
+    path: str = RedisPath.root_path()
+    encoding: str = "UTF-8"
+
+    def __init__(self) -> None:
+        # Setup logger
+        self.logger = structlog.get_logger(
+            self.__class__.__name__,
+        )
+        # Check environment variables
+        check_env(self.uri_env_var_name)
+        # Prepare internal variables
+        self._client: redis.Redis | None = None
+
+    def __enter__(self) -> RedisAdapter:
+        """Enter the context."""
+        self.connect()
+        return self
+
+    def __exit__(
+        self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+    ) -> None:
+        """Exit the context."""
+        ctx_info = {"exc_type": exc_type, "exc_val": exc_val, "exc_tb": exc_tb}
+        if any(
+            (
+                exc_type is not None,
+                exc_val is not None,
+                exc_tb is not None,
+            ),
+        ):
+            self.logger.error("Error while exiting context", **ctx_info)
+        self.disconnect()
+
+    def connect(self) -> None:
+        """Connect to the Redis server."""
+        # Prepare arguments
+        uri = str(os.getenv(self.uri_env_var_name))
+        # Connect client
+        try:
+            client = redis.Redis.from_url(
+                url=uri,
+                socket_connect_timeout=10,
+            )
+            if not client.ping():
+                raise ConnectionError(f"Could not connect to Redis at {uri}")
+        except (redis.ConnectionError, redis.TimeoutError) as exc:
+            raise ConnectionError(f"Could not connect to Redis at {uri}") from exc
+        # Persist client
+        self._client = client
+
+    def disconnect(self) -> None:
+        """Disconnect from the Redis server."""
+        # Close connection
+        if self._client is not None:
+            self._client.close()
+        # Reset client
+        self._client = None
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if connected to Redis server."""
+        res = bool(isinstance(self._client, redis.Redis))
+        self.logger.debug(res)
+        return res
+
+    def _set(self, key: str, data: dict) -> None:
+        """Set a JSON object in Redis."""
+        # Check input
+        if not isinstance(key, str) or len(key) == 0:
+            raise ValueError("Key must be a non-empty string")
+        if not isinstance(data, dict) or len(data) == 0:
+            raise ValueError("Data must be a non-empty dictionary")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Redis")
+        # Set data
+        self._client.json().set(key, self.path, data)
+        self.logger.debug(f"Set {key} to {data}")
+
+    def _get(self, key: str) -> dict | None:
+        """Get a JSON object from Redis."""
+        # Check input
+        if not isinstance(key, str) or len(key) == 0:
+            raise ValueError("Key must be a non-empty string")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Redis")
+        # Get data
+        data = cast(
+            dict | None,
+            self._client.json().get(key),
+        )
+        self.logger.debug(f"Got {data} from {key}")
+        return data
+
+    def _delete(self, key: str) -> None:
+        """Delete data from Redis."""
+        # Check input
+        if not isinstance(key, str) or len(key) == 0:
+            raise ValueError("Key must be a non-empty string")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Redis")
+        # Delete data
+        self._client.json().delete(key)
+        self.logger.debug(f"Deleted {key}")
+
+    def _list_keys(self, pattern: str) -> list[str]:
+        """List keys in Redis matching a pattern."""
+        # Check input
+        if not isinstance(pattern, str) or len(pattern) == 0:
+            raise ValueError("Pattern must be a non-empty string")
+        # Check connection
+        if self._client is None or not self.is_connected:
+            raise ConnectionError("Not connected to Redis")
+        # List keys
+        keys_raw = cast(
+            list[bytes],
+            self._client.keys(pattern),
+        )
+        keys: list[str] = [key.decode(self.encoding) for key in keys_raw]
+        self.logger.debug(f"Got {keys} matching {pattern}")
+        return keys

python_repositories/interfaces/__init__.py

@@ -0,0 +1,9 @@
+from .connection_aware_interface import (
+    ConnectionAwareInterface as ConnectionAwareInterface,
+)
+from .context_aware_interface import ContextAwareInterface as ContextAwareInterface
+
+__all__ = [
+    "ConnectionAwareInterface",
+    "ContextAwareInterface",
+]

python_repositories/interfaces/connection_aware_interface.py

@@ -0,0 +1,23 @@
+"""Definition of ConnectionAwareInterface abstract base class."""
+
+from abc import ABC, abstractmethod
+
+
+class ConnectionAwareInterface(ABC):
+    """Interface that defines connection-related methods."""
+
+    @abstractmethod
+    def connect(self) -> None:
+        """Connect to resource."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        """Disconnect from resource."""
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def is_connected(self) -> bool:
+        """Check if connected to resource."""
+        raise NotImplementedError()

python_repositories/interfaces/context_aware_interface.py

@@ -0,0 +1,21 @@
+"""Definition of ConnectionAwareInterface abstract base class."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class ContextAwareInterface(ABC):
+    """Interface that defined context-related methods."""
+
+    @abstractmethod
+    def __enter__(self) -> ContextAwareInterface:
+        """Enter the context."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def __exit__(
+        self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+    ) -> None:
+        """Exit the context."""
+        raise NotImplementedError()

tests/integration/conftest.py

@@ -0,0 +1,141 @@
+"""Integration tests configuration."""
+
+import os
+from collections.abc import Generator
+import pytest
+import redis
+import structlog
+import logging
+from minio import Minio
+
+from testcontainers.redis import RedisContainer
+from testcontainers.minio import MinioContainer
+
+MINIO_ACCESS_KEY = "minioadmin"
+MINIO_SECRET_KEY = "minioadmin"
+MINIO_BUCKET = "test-bucket"
+
+
+@pytest.fixture(scope="session", autouse=True)
+def configure_logging() -> None:
+    """Configure logging for the test session."""
+    # Configure structlog
+    structlog.configure(
+        processors=[
+            structlog.stdlib.filter_by_level,
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.JSONRenderer(),
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+    # Set up basic logging configuration
+    logging.basicConfig(level=logging.ERROR)
+
+
+@pytest.fixture(scope="session")
+def redis_container() -> Generator[str]:
+    """Set up a Redis container for testing and yield the Redis URI."""
+    # Start container
+    container = RedisContainer(
+        image="redis/redis-stack:7.2.0-v0",
+    )
+    container.start()
+    # Set environment variable for Redis URI
+    redis_host = container.get_container_host_ip()
+    redis_port = container.get_exposed_port(6379)
+    redis_uri = f"redis://{redis_host}:{redis_port}"
+
+    yield redis_uri
+
+    # Stop container
+    container.stop()
+
+
+@pytest.fixture(scope="session")
+def minio_container() -> Generator[dict[str, str]]:
+    """Set up a Minio container for testing and yield the Minio URI."""
+    # Start container
+    container = MinioContainer(
+        image="minio/minio:latest",
+        access_key=MINIO_ACCESS_KEY,
+        secret_key=MINIO_SECRET_KEY,
+    )
+    container.start()
+    # Build environment variables dictionary
+    minio_host = container.get_container_host_ip()
+    minio_port = container.get_exposed_port(9000)
+    minio_endpoint = f"{minio_host}:{minio_port}"
+    env_vars = {
+        "MINIO_ENDPOINT": minio_endpoint,
+        "MINIO_ACCESS_KEY": MINIO_ACCESS_KEY,
+        "MINIO_SECRET_KEY": MINIO_SECRET_KEY,
+        "MINIO_BUCKET": MINIO_BUCKET,
+    }
+
+    yield env_vars
+
+    # Stop container
+    container.stop()
+
+
+@pytest.fixture(scope="session", autouse=True)
+def set_environment_variables(
+    redis_container: str,
+    minio_container: dict[str, str],
+) -> Generator[dict[str, str]]:
+    """Set environment variables needed for tests."""
+    # Build environment variables dictionary
+    env_vars = {"REDIS_URI": redis_container}
+    env_vars.update(minio_container)
+    # Set environment variables
+    for key, value in env_vars.items():
+        os.environ[key] = value
+
+    yield env_vars
+
+    # Cleanup
+    for key in env_vars:
+        _ = os.environ.pop(key, default=None)
+
+
+@pytest.fixture(scope="session")
+def raw_redis_client(redis_container: str) -> Generator[redis.Redis]:
+    """Provide a raw Redis client connected to the test Redis container."""
+    # Connect client
+    client = redis.Redis.from_url(
+        url=redis_container,
+        socket_connect_timeout=10,
+    )
+
+    yield client
+
+    # Cleanup
+    client.flushall()
+    client.close()
+
+
+@pytest.fixture(scope="session")
+def raw_minio_client(minio_container: dict[str, str]) -> Generator[Minio]:
+    """Provide a raw Minio client connected to the test Minio container."""
+    # Connect client
+    client = Minio(
+        endpoint=minio_container["MINIO_ENDPOINT"],
+        access_key=minio_container["MINIO_ACCESS_KEY"],
+        secret_key=minio_container["MINIO_SECRET_KEY"],
+        secure=False,
+    )
+    # Ensure bucket exists
+    bucket_name = minio_container["MINIO_BUCKET"]
+    if not client.bucket_exists(bucket_name):
+        client.make_bucket(bucket_name)
+
+    yield client
+
+    # Cleanup
+    objects = client.list_objects(bucket_name, recursive=True)
+    for obj in objects:
+        client.remove_object(bucket_name, obj.object_name)

tests/integration/connection_aware_interface_test.py

@@ -0,0 +1,119 @@
+"""Integration tests for ConnectionAwareInterface."""
+
+import pytest
+from python_repositories.interfaces.connection_aware_interface import (
+    ConnectionAwareInterface,
+)
+
+
+def test_instantiation_fails_when_connect_not_implemented() -> None:
+    """Test that instantiation fails if connect is not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement connect."""
+
+        def disconnect(self) -> None:
+            pass
+
+        @property
+        def is_connected(self) -> bool:
+            return False
+
+    with pytest.raises(TypeError):
+        _ = Incomplete()  # type: ignore
+
+
+def test_instantiation_fails_when_disconnect_not_implemented() -> None:
+    """Test that instantiation fails if disconnect is not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement disconnect."""
+
+        def connect(self) -> None:
+            pass
+
+        @property
+        def is_connected(self) -> bool:
+            return False
+
+    with pytest.raises(TypeError):
+        _ = Incomplete()  # type: ignore
+
+
+def test_instantiation_fails_when_is_connected_not_implemented() -> None:
+    """Test that instantiation fails if is_connected is not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement is_connected."""
+
+        def connect(self) -> None:
+            pass
+
+        def disconnect(self) -> None:
+            pass
+
+    with pytest.raises(TypeError):
+        _ = Incomplete()  # type: ignore
+
+
+def test_connect_raises_not_implemented_if_not_overwritten() -> None:
+    """Test that connect raises NotImplementedError if not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement connect."""
+
+        def connect(self) -> None:
+            super().connect()  # type: ignore
+
+        def disconnect(self) -> None:
+            pass
+
+        @property
+        def is_connected(self) -> bool:
+            return False
+
+    instance = Incomplete()
+    with pytest.raises(NotImplementedError):
+        instance.connect()
+
+
+def test_disconnect_raises_not_implemented_if_not_overwritten() -> None:
+    """Test that disconnect raises NotImplementedError if not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement disconnect."""
+
+        def connect(self) -> None:
+            pass
+
+        def disconnect(self) -> None:
+            super().disconnect()  # type: ignore
+
+        @property
+        def is_connected(self) -> bool:
+            return False
+
+    instance = Incomplete()
+    with pytest.raises(NotImplementedError):
+        instance.disconnect()
+
+
+def test_is_connected_raises_not_implemented_if_not_overwritten() -> None:
+    """Test that is_connected raises NotImplementedError if not implemented."""
+
+    class Incomplete(ConnectionAwareInterface):
+        """A class that does not implement is_connected."""
+
+        def connect(self) -> None:
+            pass
+
+        def disconnect(self) -> None:
+            pass
+
+        @property
+        def is_connected(self) -> bool:
+            return super().is_connected  # type: ignore
+
+    instance = Incomplete()
+    with pytest.raises(NotImplementedError):
+        _ = instance.is_connected

tests/integration/context_aware_interface_test.py

@@ -0,0 +1,72 @@
+"""Integration tests for ContextAwareInterface."""
+
+from __future__ import annotations
+import pytest
+from python_repositories.interfaces.context_aware_interface import ContextAwareInterface
+
+
+def test_instantiation_fails_when_enter_not_implemented() -> None:
+    """Test that instantiation fails if __enter__ is not implemented."""
+
+    class Incomplete(ContextAwareInterface):
+        """A class that does not implement __enter__."""
+
+        def __exit__(
+            self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+        ) -> None:
+            pass
+
+    with pytest.raises(TypeError):
+        _ = Incomplete()  # type: ignore
+
+
+def test_instantiation_fails_when_exit_not_implemented() -> None:
+    """Test that instantiation fails if __exit__ is not implemented."""
+
+    class Incomplete(ContextAwareInterface):
+        """A class that does not implement __exit__."""
+
+        def __enter__(self) -> Incomplete:
+            return self
+
+    with pytest.raises(TypeError):
+        _ = Incomplete()  # type: ignore
+
+
+def test_enter_raises_not_implemented_if_not_overwritten() -> None:
+    """Test that __enter__ raises NotImplementedError if not implemented."""
+
+    class Incomplete(ContextAwareInterface):
+        """A class that does not implement __enter__."""
+
+        def __enter__(self) -> Incomplete:
+            super().__enter__()  # type: ignore
+            return self
+
+        def __exit__(
+            self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+        ) -> None:
+            pass
+
+    instance = Incomplete()
+    with pytest.raises(NotImplementedError):
+        instance.__enter__()
+
+
+def test_exit_raises_not_implemented_if_not_overwritten() -> None:
+    """Test that __exit__ raises NotImplementedError if not implemented."""
+
+    class Incomplete(ContextAwareInterface):
+        """A class that does not implement __exit__."""
+
+        def __enter__(self) -> ContextAwareInterface:
+            return self
+
+        def __exit__(
+            self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+        ) -> None:
+            super().__exit__(exc_type, exc_val, exc_tb)  # type: ignore
+
+    instance = Incomplete()
+    with pytest.raises(NotImplementedError):
+        instance.__exit__(None, None, None)

tests/integration/minio_adapter_test.py

@@ -0,0 +1,488 @@
+# pylint: disable=protected-access
+# The above line disables pylint's protected member access warnings for this file,
+# allowing tests to access MinioAdapter's internal methods as needed for integration testing.
+"""Integration tests for the MinioAdapter."""
+
+from collections.abc import Generator
+import pytest
+from unittest.mock import MagicMock
+from minio import Minio
+from io import BytesIO
+import random
+import os
+import logging
+from minio import S3Error
+from python_repositories.adapters.minio_adapter import MinioAdapter
+
+
+def same_data(
+    data_a: BytesIO,
+    data_b: BytesIO,
+) -> bool:
+    """Check if two BytesIO-objects contain the same data."""
+    assert isinstance(data_a, BytesIO)
+    assert isinstance(data_b, BytesIO)
+    # prepare for being read
+    data_a.seek(0)
+    data_b.seek(0)
+    # convert to bytes
+    data_a_bytes = data_a.read()
+    data_b_bytes = data_b.read()
+    # compare size
+    if len(data_a_bytes) != len(data_b_bytes):
+        logging.error(
+            "data has different length: %s and %s",
+            len(data_a_bytes),
+            len(data_b_bytes),
+        )
+        return False
+    # compare content
+    if data_a_bytes != data_b_bytes:
+        logging.error("data has different bytes")
+        return False
+    return True
+
+
+@pytest.fixture(scope="module")
+def data() -> Generator[BytesIO]:
+    """Provide a sample data bytes for tests."""
+    # Generate random bytes
+    random_bytes = random.randbytes(2**21)  # 2 MiB
+    yield BytesIO(random_bytes)
+
+
+@pytest.fixture(scope="function")
+def data_in_minio(
+    raw_minio_client: Minio,
+    data: BytesIO,
+) -> Generator[tuple[str, BytesIO]]:
+    """Fixture to set up a known value in Minio before each test."""
+    object_name = "test_object"
+    bucket_name = str(os.getenv("MINIO_BUCKET"))
+    # Upload object
+    num_bytes = data.getbuffer().nbytes
+    data.seek(0)
+    raw_minio_client.put_object(
+        bucket_name,
+        object_name,
+        data,
+        length=num_bytes,
+        part_size=MinioAdapter.chunk_size,
+    )
+    # Reset data for reading in tests
+    data.seek(0)
+
+    yield object_name, data
+
+    # Cleanup
+    raw_minio_client.remove_object(bucket_name, object_name)
+
+
+@pytest.fixture(scope="module")
+def minio_adapter() -> Generator[MinioAdapter]:
+    """Fixture to provide a connected MinioAdapter instance."""
+    adapter = MinioAdapter()
+    adapter.connect()
+    yield adapter
+    adapter.disconnect()
+
+
+@pytest.fixture(scope="function", autouse=True)
+def clear_minio(
+    raw_minio_client: Minio,
+) -> None:
+    """Fixture to clear all Minio objects before each test."""
+    bucket_name = str(os.getenv("MINIO_BUCKET"))
+    # Clear all objects before each test
+    objects = raw_minio_client.list_objects(bucket_name, recursive=True)
+    for obj in objects:
+        if not obj.object_name:
+            continue
+        raw_minio_client.remove_object(bucket_name, obj.object_name)
+
+
+def test_should_adhere_to_interface() -> None:
+    """Test that the MinioAdapter adheres to the expected interface."""
+    # Instantiation fails if interface not adhered to
+    _ = MinioAdapter()
+
+
+def test_should_have_logger_when_instantiated() -> None:
+    """Test that the MinioAdapter has a logger when instantiated."""
+    adapter = MinioAdapter()
+    assert hasattr(adapter, "logger")
+
+
+def test_should_not_be_connected_when_instantiated() -> None:
+    """Test that the MinioAdapter is not connected when instantiated."""
+    adapter = MinioAdapter()
+    assert not adapter.is_connected
+
+
+def test_should_log_info_when_already_connected(
+    minio_adapter: MinioAdapter,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs info when connect is called while already connected."""
+    with caplog.at_level(logging.INFO):
+        minio_adapter.connect()
+    assert "Already connected to Minio" in caplog.text
+
+
+def test_should_raise_connection_error_when_unable_to_connect(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test that the MinioAdapter raises a ConnectionError when unable to connect."""
+    # Arrange
+    monkeypatch.setenv("MINIO_ENDPOINT", "invalid_uri")
+    adapter = MinioAdapter()
+    with pytest.raises(ConnectionError):
+        adapter.connect()
+    assert not adapter.is_connected
+
+
+def test_should_log_info_when_creating_expected_bucket(
+    raw_minio_client: Minio,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs info when creating the expected bucket."""
+    # Arrange
+    bucket_name = str(os.getenv("MINIO_BUCKET"))
+    raw_minio_client.remove_bucket(bucket_name)
+    adapter = MinioAdapter()
+    # Act
+    with caplog.at_level(logging.INFO):
+        adapter.connect()
+    # Assert
+    assert f"Creating bucket '{bucket_name}'" in caplog.text
+
+
+def test_should_log_error_on_exception_during_exit(
+    minio_container: dict[str, str],
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs an error if an exception occurs during __exit__."""
+    try:
+        with MinioAdapter() as adapter:
+            assert adapter.is_connected
+            raise ValueError("Simulated error")
+    except ValueError:
+        pass  # Expected
+    # Assert error was logged
+    assert "Error while exiting context" in caplog.text
+
+
+def test_should_have_context_manager() -> None:
+    """Test that the MinioAdapter can be used as a context manager."""
+    with MinioAdapter() as adapter:
+        assert adapter._client is not None
+    assert adapter._client is None
+
+
+def test_should_get_data(
+    data_in_minio: tuple[str, BytesIO],
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can get data from a bucket."""
+    # Arrange
+    object_name, expected_data = data_in_minio
+    # Act
+    received_data = minio_adapter._get(object_name)
+    # Assert
+    assert received_data is not None
+    assert same_data(expected_data, received_data)
+
+
+def test_should_get_none_for_nonexistent_object(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter returns None for a nonexistent object."""
+    # Arrange
+    object_name = "nonexistent_object"
+    # Act
+    received_data = minio_adapter._get(object_name)
+    # Assert
+    assert received_data is None
+
+
+def test_should_raise_value_error_on_invalid_get_object_name(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ValueError when getting with an invalid object name."""
+    # Arrange
+    invalid_object_names = ["", 123, None]
+    # Act & Assert
+    for object_name in invalid_object_names:
+        with pytest.raises(ValueError):
+            minio_adapter._get(object_name)  # type: ignore
+
+
+def test_should_raise_connection_error_on_get_when_not_connected(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ConnectionError when getting while not connected."""
+    # Arrange
+    adapter = MinioAdapter()  # not connected
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._get("some_object")
+
+
+def test_should_log_warning_when_getting_nonexistent_object(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs a warning when getting a nonexistent object."""
+    # Arrange
+    adapter = MinioAdapter()
+    adapter._client = MagicMock(spec=Minio)
+    adapter._client.get_object.side_effect = S3Error(
+        code="NoSuchKey",
+        message="",
+        resource="",
+        request_id="",
+        host_id="",
+        response="",
+        bucket_name="test-bucket",
+        object_name="missing-object",
+    )
+    adapter._bucket_name = "test-bucket"
+    object_name = "missing-object"
+    # Act
+    with caplog.at_level("WARNING"):
+        result = adapter._get(object_name)
+    # Assert
+    assert result is None
+    assert (
+        f"Object '{object_name}' not found in bucket '{adapter._bucket_name}'"
+        in caplog.text
+    )
+
+
+def test_should_log_error_when_getting_with_s3error_other_than_no_such_key(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs an error when getting a nonexistent object."""
+    # Arrange
+    adapter = MinioAdapter()
+    adapter._client = MagicMock(spec=Minio)
+    other_s3error = S3Error(
+        code="UnhandledError",
+        message="",
+        resource="",
+        request_id="",
+        host_id="",
+        response="",
+        bucket_name="test-bucket",
+        object_name="missing-object",
+    )
+    adapter._client.get_object.side_effect = other_s3error
+    adapter._bucket_name = "test-bucket"
+    object_name = "missing-object"
+    # Act
+    with caplog.at_level("ERROR"):
+        result = adapter._get(object_name)
+    # Assert
+    assert result is None
+    assert repr(other_s3error) in caplog.text
+
+
+def test_should_log_error_when_getting_with_general_exception(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the MinioAdapter logs an error when getting a nonexistent object."""
+    # Arrange
+    adapter = MinioAdapter()
+    adapter._client = MagicMock(spec=Minio)
+    general_exception = Exception("General failure")
+    adapter._client.get_object.side_effect = general_exception
+    adapter._bucket_name = "test-bucket"
+    object_name = "missing-object"
+    # Act
+    with caplog.at_level("ERROR"):
+        result = adapter._get(object_name)
+    # Assert
+    assert result is None
+    assert repr(general_exception) in caplog.text
+
+
+def test_should_put_data(
+    data: BytesIO,
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can put data into a bucket."""
+    # Arrange
+    object_name = "new_test_object"
+    received_data = minio_adapter._get(object_name)
+    assert received_data is None  # ensure object does not exist yet
+    # Act
+    minio_adapter._put(object_name, data)
+    # Assert
+    received_data = minio_adapter._get(object_name)
+    assert received_data is not None
+    assert same_data(data, received_data)
+    # Cleanup
+    bucket_name = str(os.getenv("MINIO_BUCKET"))
+    minio_adapter._client.remove_object(bucket_name, object_name)  # type: ignore
+
+
+def test_should_update_data(
+    data_in_minio: tuple[str, BytesIO],
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can update data in a bucket."""
+    # Arrange
+    object_name, _ = data_in_minio
+    new_data = BytesIO(random.randbytes(2**21))  # 2 MiB
+    received_data = minio_adapter._get(object_name)
+    assert received_data is not None
+    assert not same_data(received_data, new_data)
+    # Act
+    minio_adapter._put(object_name, new_data)
+    # Assert
+    received_data = minio_adapter._get(object_name)
+    assert received_data is not None
+    assert same_data(new_data, received_data)
+
+
+def test_should_raise_value_error_on_invalid_put_object_name(
+    data: BytesIO,
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ValueError when putting with an invalid object name."""
+    # Arrange
+    invalid_object_names = ["", 123, None]
+    # Act & Assert
+    for object_name in invalid_object_names:
+        with pytest.raises(ValueError):
+            minio_adapter._put(object_name, data)  # type: ignore
+
+
+def test_should_raise_value_error_on_invalid_put_data(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ValueError when putting with invalid data."""
+    # Arrange
+    object_name = "valid_object_name"
+    invalid_data = ["not_bytesio", 123, None]
+    # Act & Assert
+    for data in invalid_data:
+        with pytest.raises(ValueError):
+            minio_adapter._put(object_name, data)  # type: ignore
+
+
+def test_should_raise_connection_error_on_put_when_not_connected(
+    data: BytesIO,
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ConnectionError when putting while not connected."""
+    # Arrange
+    adapter = MinioAdapter()  # not connected
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._put("some_object", data)
+
+
+def test_should_delete_object(
+    data_in_minio: tuple[str, BytesIO],
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can delete an object from a bucket."""
+    # Arrange
+    object_name, _ = data_in_minio
+    received_data = minio_adapter._get(object_name)
+    assert received_data is not None  # ensure object exists
+    # Act
+    minio_adapter._delete(object_name)
+    # Assert
+    received_data = minio_adapter._get(object_name)
+    assert received_data is None
+
+
+def test_should_raise_value_error_on_invalid_delete_object_name(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ValueError when deleting with an invalid object name."""
+    # Arrange
+    invalid_object_names = ["", 123, None]
+    # Act & Assert
+    for object_name in invalid_object_names:
+        with pytest.raises(ValueError):
+            minio_adapter._delete(object_name)  # type: ignore
+
+
+def test_should_raise_connection_error_on_delete_when_not_connected(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ConnectionError when deleting while not connected."""
+    # Arrange
+    adapter = MinioAdapter()  # not connected
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._delete("some_object")
+
+
+def test_should_list_objects(
+    data_in_minio: tuple[str, BytesIO],
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can list objects in a bucket."""
+    # Arrange
+    object_name, _ = data_in_minio
+    new_data = BytesIO(random.randbytes(2**21))  # 2 MiB
+    new_data_name = "another_test_object"
+    minio_adapter._put(new_data_name, new_data)
+    # Act
+    objects = minio_adapter._list_objects()
+    # Assert
+    assert isinstance(objects, list)
+    assert len(objects) == 2
+    assert object_name in objects
+    assert new_data_name in objects
+
+
+def test_should_list_objects_with_prefix(
+    data_in_minio: tuple[str, BytesIO],
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter can list objects in a bucket with a prefix."""
+    # Arrange
+    object_name, _ = data_in_minio
+    new_data = BytesIO(random.randbytes(2**21))  # 2 MiB
+    new_data_name = "prefix_test_object"
+    minio_adapter._put(new_data_name, new_data)
+    prefix = "prefix_"
+    # Act
+    objects = minio_adapter._list_objects(prefix)
+    # Assert
+    assert isinstance(objects, list)
+    assert len(objects) == 1
+    assert new_data_name in objects
+    assert object_name not in objects
+
+
+def test_should_raise_value_error_on_invalid_list_objects_prefix(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ValueError when listing with an invalid prefix."""
+    # Arrange
+    invalid_prefixes = [123, None]
+    # Act & Assert
+    for prefix in invalid_prefixes:
+        with pytest.raises(ValueError):
+            minio_adapter._list_objects(prefix)  # type: ignore
+
+
+def test_should_raise_connection_error_on_list_objects_when_not_connected(
+    minio_adapter: MinioAdapter,
+) -> None:
+    """Test that the MinioAdapter raises ConnectionError when listing while not connected."""
+    # Arrange
+    adapter = MinioAdapter()  # not connected
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._list_objects()
+
+
+# allows local debugging by running file as script
+if __name__ == "__main__":
+    pytest.main(["-s", "-v", __file__])

tests/integration/redis_adapter_test.py

@@ -0,0 +1,325 @@
+# pylint: disable=protected-access
+# The above line disables pylint's protected member access warnings for this file,
+# allowing tests to access RedisAdapter's internal methods as needed for integration testing.
+"""Integration tests for the RedisAdapter."""
+
+from collections.abc import Generator
+import pytest
+import redis
+from redis.commands.json.path import Path as RedisPath
+from python_repositories.adapters.redis_adapter import RedisAdapter
+
+
+@pytest.fixture(scope="module")
+def data() -> Generator[dict[str, str]]:
+    """Provide a sample data dictionary for tests."""
+    yield {"foo": "bar"}
+
+
+@pytest.fixture(scope="function")
+def data_in_redis(
+    raw_redis_client: redis.Redis,
+    data: dict[str, str],
+) -> Generator[tuple[str, dict[str, str]]]:
+    """Fixture to set up a known value in Redis before each test."""
+    key = "test_key"
+    path = RedisPath.root_path()
+    raw_redis_client.json().set(key, path, data)
+
+    yield key, data
+
+    # Cleanup
+    raw_redis_client.delete(key)
+
+
+@pytest.fixture(scope="module")
+def redis_adapter(redis_container: str) -> Generator[RedisAdapter]:
+    """Fixture to provide a connected RedisAdapter instance."""
+    adapter = RedisAdapter()
+    adapter.connect()
+    yield adapter
+    adapter.disconnect()
+
+
+@pytest.fixture(scope="function", autouse=True)
+def clear_redis(raw_redis_client: redis.Redis) -> None:
+    """Fixture to clear all Redis keys before each test."""
+    # Clear all keys before each test
+    raw_redis_client.flushall()
+
+
+def test_should_adhere_to_interface(redis_container: str) -> None:
+    """Test that the RedisAdapter adheres to the expected interface."""
+    # Instantiation fails if interface not adhered to
+    _ = RedisAdapter()
+
+
+def test_should_have_logger_when_instantiated(redis_container: str) -> None:
+    """Test that the RedisAdapter has a logger when instantiated."""
+    adapter = RedisAdapter()
+    assert hasattr(adapter, "logger")
+    assert adapter.logger is not None
+
+
+def test_should_not_be_connected_when_instantiated(redis_container: str) -> None:
+    """Test that the RedisAdapter is not connected when instantiated."""
+    adapter = RedisAdapter()
+    assert adapter._client is None
+    assert not adapter.is_connected
+
+
+def test_should_raise_connection_error_when_unable_to_connect(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when unable to connect."""
+    # Arrange
+    monkeypatch.setenv("REDIS_URI", "redis://invalid:6379")
+    adapter = RedisAdapter()
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter.connect()
+    assert adapter._client is None
+    assert not adapter.is_connected
+
+
+def test_connect_raises_connection_error_when_unable_to_ping(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when ping fails."""
+    # Set an invalid URI
+    monkeypatch.setenv("REDIS_URI", "redis://invalid:6379")
+
+    # Monkeypatch redis.Redis.from_url to return a mock client
+    class MockRedis:
+        """A mock Redis client that simulates a failed ping."""
+
+        def ping(self) -> bool:
+            """Simulate a failed ping."""
+            return False  # Simulate failed ping
+
+    monkeypatch.setattr("redis.Redis.from_url", lambda *a, **kw: MockRedis())
+
+    adapter = RedisAdapter()
+    with pytest.raises(ConnectionError, match="Could not connect to Redis"):
+        adapter.connect()
+
+
+def test_should_log_error_on_exception_during_exit(
+    redis_container: str,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that the RedisAdapter logs an error when an exception occurs during context exit."""
+    try:
+        with RedisAdapter() as adapter:
+            assert adapter.is_connected
+            raise ValueError("Simulated error")
+    except ValueError:
+        pass  # Expected
+    # Assert error was logged
+    assert "Error while exiting context" in caplog.text
+
+
+def test_should_have_context_manager(redis_container: str) -> None:
+    """Test that the RedisAdapter can be used as a context manager."""
+    with RedisAdapter() as adapter:
+        assert adapter._client is not None
+    assert adapter._client is None
+
+
+def test_should_get_value(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can get a value."""
+    # Arrange
+    key, data = data_in_redis
+    # Act
+    value = redis_adapter._get(key)
+    # Assert
+    assert value is not None
+    assert value == data
+
+
+def test_should_get_none_for_missing_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that getting a non-existent key returns None."""
+    # Act
+    value = redis_adapter._get("nonexistent_key")
+    # Assert
+    assert value is None
+
+
+def test_should_raise_value_error_on_invalid_get_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when getting with an invalid key."""
+    # Arrange
+    invalid_keys = ["", 123, None]
+    # Act & Assert
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter._get(key)  # type: ignore
+
+
+def test_should_raise_connection_error_on_get_when_not_connected(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when getting while not connected."""
+    # Arrange
+    adapter = RedisAdapter()  # not connected
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._get("some_key")
+
+
+def test_should_set_value(
+    data: dict[str, str],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can set a value."""
+    # Arrange
+    key = "test_key"
+    received_data = redis_adapter._get(key)
+    assert received_data is None  # Ensure key does not exist
+    # Act
+    redis_adapter._set(key, data)
+    # Assert
+    received_data = redis_adapter._get(key)
+    assert received_data is not None
+    assert received_data == data
+
+
+def test_should_update_value(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter can update an existing value."""
+    # Arrange
+    key, _ = data_in_redis
+    new_data = {"new_key": "new_value"}
+    received_data = redis_adapter._get(key)
+    assert received_data is not None
+    assert received_data != new_data
+    # Act
+    redis_adapter._set(key, new_data)
+    # Assert
+    assert redis_adapter._get(key) == new_data
+
+
+def test_should_raise_value_error_on_invalid_set_key(
+    redis_adapter: RedisAdapter,
+    data: dict[str, str],
+) -> None:
+    """Test that the RedisAdapter raises ValueError when setting with an invalid key."""
+    # Arrange
+    invalid_keys = ["", 123, None]
+    # Act & Assert
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter._set(key, data)  # type: ignore
+
+
+def test_should_raise_value_error_on_invalid_set_data(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when setting with invalid data."""
+    # Arrange
+    key = "test_key"
+    invalid_data = ["", 123, None, [], {}]
+    # Act & Assert
+    for data in invalid_data:
+        with pytest.raises(ValueError):
+            redis_adapter._set(key, data)  # type: ignore
+
+
+def test_should_raise_connection_error_on_set_when_not_connected(
+    redis_adapter: RedisAdapter,
+    data: dict[str, str],
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when setting while not connected."""
+    # Arrange
+    adapter = RedisAdapter()
+    key = "test_key"
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._set(key, data)
+
+
+def test_should_delete_key(
+    data_in_redis: tuple[str, dict[str, str]],
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that deleting a key removes it from Redis."""
+    # Arrange
+    key, _ = data_in_redis
+    received_data = redis_adapter._get(key)
+    assert received_data is not None  # Ensure key exists
+    # Act
+    redis_adapter._delete(key)
+    # Assert
+    assert redis_adapter._get(key) is None
+
+
+def test_should_raise_value_error_on_invalid_delete_key(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when deleting with an invalid key."""
+    # Arrange
+    invalid_keys = ["", 123, None]
+    # Act & Assert
+    for key in invalid_keys:
+        with pytest.raises(ValueError):
+            redis_adapter._delete(key)  # type: ignore
+
+
+def test_should_raise_connection_error_on_delete_when_not_connected(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when deleting while not connected."""
+    # Arrange
+    adapter = RedisAdapter()
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._delete("some_key")
+
+
+def test_should_list_keys(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test listing keys matching a pattern returns correct keys."""
+    # Arrange
+    redis_adapter._set("key1", {"a": 1})
+    redis_adapter._set("key2", {"b": 2})
+    # Act
+    keys = redis_adapter._list_keys("key*")
+    # Assert
+    assert set(keys) == {"key1", "key2"}
+
+
+def test_should_raise_value_error_on_invalid_list_keys_pattern(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when listing keys with an invalid pattern."""
+    # Arrange
+    invalid_patterns = ["", 123, None]
+    # Act & Assert
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError):
+            redis_adapter._list_keys(pattern)  # type: ignore
+
+
+def test_should_raise_connection_error_on_list_keys_when_not_connected(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when listing keys while not connected."""
+    # Arrange
+    adapter = RedisAdapter()
+    # Act & Assert
+    with pytest.raises(ConnectionError):
+        adapter._list_keys("some_pattern")
+
+
+# allows local debugging by running file as script
+if __name__ == "__main__":
+    pytest.main(["-s", "-v", __file__])

uv.lock

@@ -2,7 +2,8 @@ version = 1
 revision = 3
 requires-python = ">=3.12"
 resolution-markers = [
-    "python_full_version >= '3.13'",
+    "python_full_version >= '3.14'",
+    "python_full_version == '3.13.*'",
     "python_full_version < '3.13'",
 ]
 
@@ -29,6 +30,49 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/anyio/anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1" },
 ]
 
+[[package]]
+name = "argon2-cffi"
+version = "25.1.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "argon2-cffi-bindings" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/argon2-cffi/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/argon2-cffi/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741" },
+]
+
+[[package]]
+name = "argon2-cffi-bindings"
+version = "25.1.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "cffi" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98" },
+    { url = "http://10.0.0.2:5001/index/argon2-cffi-bindings/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94" },
+]
+
 [[package]]
 name = "authlib"
 version = "1.6.3"
@@ -52,35 +96,59 @@ wheels = [
 
 [[package]]
 name = "cffi"
-version = "1.17.1"
+version = "2.0.0"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
-    { name = "pycparser" },
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824" }
+sdist = { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d" },
-    { url = "http://10.0.0.2:5001/index/cffi/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6" },
+    { url = "http://10.0.0.2:5001/index/cffi/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9" },
 ]
 
 [[package]]
@@ -155,39 +223,103 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/colorama/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6" },
 ]
 
+[[package]]
+name = "coverage"
+version = "7.10.6"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6.tar.gz", hash = "sha256:f644a3ae5933a552a29dbb9aa2f90c677a875f80ebea028e5a52a4f429044b90" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5b2dd6059938063a2c9fee1af729d4f2af28fd1a545e9b7652861f0d752ebcea" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:388d80e56191bf846c485c14ae2bc8898aa3124d9d35903fef7d907780477634" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:90cb5b1a4670662719591aa92d0095bb41714970c0b065b02a2610172dbf0af6" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:961834e2f2b863a0e14260a9a273aff07ff7818ab6e66d2addf5628590c628f9" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf9a19f5012dab774628491659646335b1928cfc931bf8d97b0d5918dd58033c" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:99c4283e2a0e147b9c9cc6bc9c96124de9419d6044837e9799763a0e29a7321a" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:282b1b20f45df57cc508c1e033403f02283adfb67d4c9c35a90281d81e5c52c5" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8cdbe264f11afd69841bd8c0d83ca10b5b32853263ee62e6ac6a0ab63895f972" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-win32.whl", hash = "sha256:a517feaf3a0a3eca1ee985d8373135cfdedfbba3882a5eab4362bda7c7cf518d" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-win_amd64.whl", hash = "sha256:856986eadf41f52b214176d894a7de05331117f6035a28ac0016c0f63d887629" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp312-cp312-win_arm64.whl", hash = "sha256:acf36b8268785aad739443fa2780c16260ee3fa09d12b3a70f772ef100939d80" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ffea0575345e9ee0144dfe5701aa17f3ba546f8c3bb48db62ae101afb740e7d6" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:95d91d7317cde40a1c249d6b7382750b7e6d86fad9d8eaf4fa3f8f44cf171e80" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3e23dd5408fe71a356b41baa82892772a4cefcf758f2ca3383d2aa39e1b7a003" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0f3f56e4cb573755e96a16501a98bf211f100463d70275759e73f3cbc00d4f27" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:db4a1d897bbbe7339946ffa2fe60c10cc81c43fab8b062d3fcb84188688174a4" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d8fd7879082953c156d5b13c74aa6cca37f6a6f4747b39538504c3f9c63d043d" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:28395ca3f71cd103b8c116333fa9db867f3a3e1ad6a084aa3725ae002b6583bc" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:61c950fc33d29c91b9e18540e1aed7d9f6787cc870a3e4032493bbbe641d12fc" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-win32.whl", hash = "sha256:160c00a5e6b6bdf4e5984b0ef21fc860bc94416c41b7df4d63f536d17c38902e" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-win_amd64.whl", hash = "sha256:628055297f3e2aa181464c3808402887643405573eb3d9de060d81531fa79d32" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313-win_arm64.whl", hash = "sha256:df4ec1f8540b0bcbe26ca7dd0f541847cc8a108b35596f9f91f59f0c060bfdd2" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c9a8b7a34a4de3ed987f636f71881cd3b8339f61118b1aa311fbda12741bff0b" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8dd5af36092430c2b075cee966719898f2ae87b636cefb85a653f1d0ba5d5393" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b0353b0f0850d49ada66fdd7d0c7cdb0f86b900bb9e367024fd14a60cecc1e27" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d6b9ae13d5d3e8aeca9ca94198aa7b3ebbc5acfada557d724f2a1f03d2c0b0df" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:675824a363cc05781b1527b39dc2587b8984965834a748177ee3c37b64ffeafb" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:692d70ea725f471a547c305f0d0fc6a73480c62fb0da726370c088ab21aed282" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:851430a9a361c7a8484a36126d1d0ff8d529d97385eacc8dfdc9bfc8c2d2cbe4" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d9369a23186d189b2fc95cc08b8160ba242057e887d766864f7adf3c46b2df21" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-win32.whl", hash = "sha256:92be86fcb125e9bda0da7806afd29a3fd33fdf58fba5d60318399adf40bf37d0" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6b3039e2ca459a70c79523d39347d83b73f2f06af5624905eba7ec34d64d80b5" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp313-cp313t-win_arm64.whl", hash = "sha256:3fb99d0786fe17b228eab663d16bee2288e8724d26a199c29325aac4b0319b9b" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6008a021907be8c4c02f37cdc3ffb258493bdebfeaf9a839f9e71dfdc47b018e" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5e75e37f23eb144e78940b40395b42f2321951206a4f50e23cfd6e8a198d3ceb" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0f7cb359a448e043c576f0da00aa8bfd796a01b06aa610ca453d4dde09cc1034" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c68018e4fc4e14b5668f1353b41ccf4bc83ba355f0e1b3836861c6f042d89ac1" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cd4b2b0707fc55afa160cd5fc33b27ccbf75ca11d81f4ec9863d5793fc6df56a" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4cec13817a651f8804a86e4f79d815b3b28472c910e099e4d5a0e8a3b6a1d4cb" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f2a6a8e06bbda06f78739f40bfb56c45d14eb8249d0f0ea6d4b3d48e1f7c695d" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:081b98395ced0d9bcf60ada7661a0b75f36b78b9d7e39ea0790bb4ed8da14747" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-win32.whl", hash = "sha256:6937347c5d7d069ee776b2bf4e1212f912a9f1f141a429c475e6089462fcecc5" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-win_amd64.whl", hash = "sha256:adec1d980fa07e60b6ef865f9e5410ba760e4e1d26f60f7e5772c73b9a5b0713" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314-win_arm64.whl", hash = "sha256:a80f7aef9535442bdcf562e5a0d5a5538ce8abe6bb209cfbf170c462ac2c2a32" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:0de434f4fbbe5af4fa7989521c655c8c779afb61c53ab561b64dcee6149e4c65" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6e31b8155150c57e5ac43ccd289d079eb3f825187d7c66e755a055d2c85794c6" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:98cede73eb83c31e2118ae8d379c12e3e42736903a8afcca92a7218e1f2903b0" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f863c08f4ff6b64fa8045b1e3da480f5374779ef187f07b82e0538c68cb4ff8e" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b38261034fda87be356f2c3f42221fdb4171c3ce7658066ae449241485390d5" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0e93b1476b79eae849dc3872faeb0bf7948fd9ea34869590bc16a2a00b9c82a7" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ff8a991f70f4c0cf53088abf1e3886edcc87d53004c7bb94e78650b4d3dac3b5" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ac765b026c9f33044419cbba1da913cfb82cca1b60598ac1c7a5ed6aac4621a0" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-win32.whl", hash = "sha256:441c357d55f4936875636ef2cfb3bee36e466dcf50df9afbd398ce79dba1ebb7" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-win_amd64.whl", hash = "sha256:073711de3181b2e204e4870ac83a7c4853115b42e9cd4d145f2231e12d670930" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-cp314-cp314t-win_arm64.whl", hash = "sha256:137921f2bac5559334ba66122b753db6dc5d1cf01eb7b64eb412bb0d064ef35b" },
+    { url = "http://10.0.0.2:5001/index/coverage/coverage-7.10.6-py3-none-any.whl", hash = "sha256:92c4ecf6bf11b2e85fd4d8204814dc26e6a19f0c9d938c207c5cb0eadfcabbe3" },
+]
+
 [[package]]
 name = "cryptography"
-version = "45.0.6"
+version = "45.0.7"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6.tar.gz", hash = "sha256:5c966c732cf6e4a276ce83b6e4c729edda2df6929083a952cc7da973c539c719" }
+sdist = { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7.tar.gz", hash = "sha256:4b1654dfc64ea479c242508eb8c724044f1e964a47d1d1cacc5132292d851971" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:048e7ad9e08cf4c0ab07ff7f36cc3115924e22e2266e034450a890d9e312dd74" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:44647c5d796f5fc042bbc6d61307d04bf29bccb74d188f18051b635f20a9c75f" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e40b80ecf35ec265c452eea0ba94c9587ca763e739b8e559c128d23bff7ebbbf" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:00e8724bdad672d75e6f069b27970883179bd472cd24a63f6e620ca7e41cc0c5" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a3085d1b319d35296176af31c90338eeb2ddac8104661df79f80e1d9787b8b2" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1b7fa6a1c1188c7ee32e47590d16a5a0646270921f8020efc9a511648e1b2e08" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:275ba5cc0d9e320cd70f8e7b96d9e59903c815ca579ab96c1e37278d231fc402" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f4028f29a9f38a2025abedb2e409973709c660d44319c61762202206ed577c42" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ee411a1b977f40bd075392c80c10b58025ee5c6b47a822a33c1198598a7a5f05" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e2a21a8eda2d86bb604934b6b37691585bd095c1f788530c1fcefc53a82b3453" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-win32.whl", hash = "sha256:d063341378d7ee9c91f9d23b431a3502fc8bfacd54ef0a27baa72a0843b29159" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp311-abi3-win_amd64.whl", hash = "sha256:833dc32dfc1e39b7376a87b9a6a4288a10aae234631268486558920029b086ec" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:3436128a60a5e5490603ab2adbabc8763613f638513ffa7d311c900a8349a2a0" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0d9ef57b6768d9fa58e92f4947cea96ade1233c0e236db22ba44748ffedca394" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea3c42f2016a5bbf71825537c2ad753f2870191134933196bee408aac397b3d9" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:20ae4906a13716139d6d762ceb3e0e7e110f7955f3bc3876e3a07f5daadec5f3" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dac5ec199038b8e131365e2324c03d20e97fe214af051d20c49db129844e8b3" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:18f878a34b90d688982e43f4b700408b478102dd58b3e39de21b5ebf6509c301" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5bd6020c80c5b2b2242d6c48487d7b85700f5e0038e67b29d706f98440d66eb5" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:eccddbd986e43014263eda489abbddfbc287af5cddfd690477993dbb31e31016" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:550ae02148206beb722cfe4ef0933f9352bab26b087af00e48fdfb9ade35c5b3" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5b64e668fc3528e77efa51ca70fadcd6610e8ab231e3e06ae2bab3b31c2b8ed9" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-win32.whl", hash = "sha256:780c40fb751c7d2b0c6786ceee6b6f871e86e8718a8ff4bc35073ac353c7cd02" },
-    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.6-cp37-abi3-win_amd64.whl", hash = "sha256:20d15aed3ee522faac1a39fbfdfee25d17b1284bafd808e1640a74846d7c4d1b" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:3be4f21c6245930688bd9e162829480de027f8bf962ede33d4f8ba7d67a00cee" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:67285f8a611b0ebc0857ced2081e30302909f571a46bfa7a3cc0ad303fe015c6" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:577470e39e60a6cd7780793202e63536026d9b8641de011ed9d8174da9ca5339" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:4bd3e5c4b9682bc112d634f2c6ccc6736ed3635fc3319ac2bb11d768cc5a00d8" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:465ccac9d70115cd4de7186e60cfe989de73f7bb23e8a7aa45af18f7412e75bf" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:16ede8a4f7929b4b7ff3642eba2bf79aa1d71f24ab6ee443935c0d269b6bc513" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:8978132287a9d3ad6b54fcd1e08548033cc09dc6aacacb6c004c73c3eb5d3ac3" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:b6a0e535baec27b528cb07a119f321ac024592388c5681a5ced167ae98e9fff3" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a24ee598d10befaec178efdff6054bc4d7e883f615bfbcd08126a0f4931c83a6" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:fa26fa54c0a9384c27fcdc905a2fb7d60ac6e47d14bc2692145f2b3b1e2cfdbd" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-win32.whl", hash = "sha256:bef32a5e327bd8e5af915d3416ffefdbe65ed975b646b3805be81b23580b57b8" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp311-abi3-win_amd64.whl", hash = "sha256:3808e6b2e5f0b46d981c24d79648e5c25c35e59902ea4391a0dcb3e667bf7443" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:bfb4c801f65dd61cedfc61a83732327fafbac55a47282e6f26f073ca7a41c3b2" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:81823935e2f8d476707e85a78a405953a03ef7b7b4f55f93f7c2d9680e5e0691" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3994c809c17fc570c2af12c9b840d7cea85a9fd3e5c0e0491f4fa3c029216d59" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dad43797959a74103cb59c5dac71409f9c27d34c8a05921341fb64ea8ccb1dd4" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ce7a453385e4c4693985b4a4a3533e041558851eae061a58a5405363b098fcd3" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:b04f85ac3a90c227b6e5890acb0edbaf3140938dbecf07bff618bf3638578cf1" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:48c41a44ef8b8c2e80ca4527ee81daa4c527df3ecbc9423c41a420a9559d0e27" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:f3df7b3d0f91b88b2106031fd995802a2e9ae13e02c36c1fc075b43f420f3a17" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dd342f085542f6eb894ca00ef70236ea46070c8a13824c6bde0dfdcd36065b9b" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1993a1bb7e4eccfb922b6cd414f072e08ff5816702a0bdb8941c247a6b1b287c" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-win32.whl", hash = "sha256:18fcf70f243fe07252dcb1b268a687f2358025ce32f9f88028ca5c364b123ef5" },
+    { url = "http://10.0.0.2:5001/index/cryptography/cryptography-45.0.7-cp37-abi3-win_amd64.whl", hash = "sha256:7285a89df4900ed3bfaad5679b1e668cb4b38a8de1ccbfc84b05f34512da0a90" },
 ]
 
 [[package]]
@@ -199,6 +331,20 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/distlib/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16" },
 ]
 
+[[package]]
+name = "docker"
+version = "7.1.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "requests" },
+    { name = "urllib3" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/docker/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/docker/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0" },
+]
+
 [[package]]
 name = "dparse"
 version = "0.6.4"
@@ -213,11 +359,11 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.16.1"
+version = "3.19.1"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/filelock/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435" }
+sdist = { url = "http://10.0.0.2:5001/index/filelock/filelock-3.19.1.tar.gz", hash = "sha256:66eda1888b0171c998b35be2bcc0f6d75c388a7ce20c3f3f37aa8e96c2dddf58" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/filelock/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0" },
+    { url = "http://10.0.0.2:5001/index/filelock/filelock-3.19.1-py3-none-any.whl", hash = "sha256:d38e30481def20772f5baf097c122c3babc4fcdb7e14e57049eb9d88c6dc017d" },
 ]
 
 [[package]]
@@ -259,11 +405,11 @@ wheels = [
 
 [[package]]
 name = "identify"
-version = "2.6.13"
+version = "2.6.14"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/identify/identify-2.6.13.tar.gz", hash = "sha256:da8d6c828e773620e13bfa86ea601c5a5310ba4bcd65edf378198b56a1f9fb32" }
+sdist = { url = "http://10.0.0.2:5001/index/identify/identify-2.6.14.tar.gz", hash = "sha256:663494103b4f717cb26921c52f8751363dc89db64364cd836a9bf1535f53cd6a" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/identify/identify-2.6.13-py2.py3-none-any.whl", hash = "sha256:60381139b3ae39447482ecc406944190f690d4a2997f2584062089848361b33b" },
+    { url = "http://10.0.0.2:5001/index/identify/identify-2.6.14-py2.py3-none-any.whl", hash = "sha256:11a073da82212c6646b1f39bb20d4483bfb9543bd5566fec60053c4bb309bf2e" },
 ]
 
 [[package]]
@@ -373,36 +519,52 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/mdurl/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" },
 ]
 
+[[package]]
+name = "minio"
+version = "7.2.16"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "argon2-cffi" },
+    { name = "certifi" },
+    { name = "pycryptodome" },
+    { name = "typing-extensions" },
+    { name = "urllib3" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/minio/minio-7.2.16.tar.gz", hash = "sha256:81e365c8494d591d8204a63ee7596bfdf8a7d06ad1b1507d6b9c1664a95f299a" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/minio/minio-7.2.16-py3-none-any.whl", hash = "sha256:9288ab988ca57c181eb59a4c96187b293131418e28c164392186c2b89026b223" },
+]
+
 [[package]]
 name = "mypy"
-version = "1.17.1"
+version = "1.18.1"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
     { name = "mypy-extensions" },
     { name = "pathspec" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1.tar.gz", hash = "sha256:25e01ec741ab5bb3eec8ba9cdb0f769230368a22c959c4937360efb89b7e9f01" }
+sdist = { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1.tar.gz", hash = "sha256:9e988c64ad3ac5987f43f5154f884747faf62141b7f842e87465b45299eea5a9" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:69e83ea6553a3ba79c08c6e15dbd9bfa912ec1e493bf75489ef93beb65209aeb" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b16708a66d38abb1e6b5702f5c2c87e133289da36f6a1d15f6a5221085c6403" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:89e972c0035e9e05823907ad5398c5a73b9f47a002b22359b177d40bdaee7056" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03b6d0ed2b188e35ee6d5c36b5580cffd6da23319991c49ab5556c023ccf1341" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c837b896b37cd103570d776bda106eabb8737aa6dd4f248451aecf53030cdbeb" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:665afab0963a4b39dff7c1fa563cc8b11ecff7910206db4b2e64dd1ba25aed19" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93378d3203a5c0800c6b6d850ad2f19f7a3cdf1a3701d3416dbf128805c6a6a7" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:15d54056f7fe7a826d897789f53dd6377ec2ea8ba6f776dc83c2902b899fee81" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:209a58fed9987eccc20f2ca94afe7257a8f46eb5df1fb69958650973230f91e6" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:099b9a5da47de9e2cb5165e581f158e854d9e19d2e96b6698c0d64de911dd849" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa6ffadfbe6994d724c5a1bb6123a7d27dd68fc9c059561cd33b664a79578e14" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:9a2b7d9180aed171f033c9f2fc6c204c1245cf60b0cb61cf2e7acc24eea78e0a" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:15a83369400454c41ed3a118e0cc58bd8123921a602f385cb6d6ea5df050c733" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:55b918670f692fc9fba55c3298d8a3beae295c5cded0a55dccdc5bbead814acd" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62761474061feef6f720149d7ba876122007ddc64adff5ba6f374fda35a018a0" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c49562d3d908fd49ed0938e5423daed8d407774a479b595b143a3d7f87cdae6a" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:397fba5d7616a5bc60b45c7ed204717eaddc38f826e3645402c426057ead9a91" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:9d6b20b97d373f41617bd0708fd46aa656059af57f2ef72aa8c7d6a2b73b74ed" },
-    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.17.1-py3-none-any.whl", hash = "sha256:a9f52c0351c21fe24c21d8c0eb1f62967b262d6729393397b6f443c3b773c3b9" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:502cde8896be8e638588b90fdcb4c5d5b8c1b004dfc63fd5604a973547367bb9" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7509549b5e41be279afc1228242d0e397f1af2919a8f2877ad542b199dc4083e" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5956ecaabb3a245e3f34100172abca1507be687377fe20e24d6a7557e07080e2" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8750ceb014a96c9890421c83f0db53b0f3b8633e2864c6f9bc0a8e93951ed18d" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fb89ea08ff41adf59476b235293679a6eb53a7b9400f6256272fb6029bec3ce5" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp312-cp312-win_amd64.whl", hash = "sha256:2657654d82fcd2a87e02a33e0d23001789a554059bbf34702d623dafe353eabf" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d70d2b5baf9b9a20bc9c730015615ae3243ef47fb4a58ad7b31c3e0a59b5ef1f" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b8367e33506300f07a43012fc546402f283c3f8bcff1dc338636affb710154ce" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:913f668ec50c3337b89df22f973c1c8f0b29ee9e290a8b7fe01cc1ef7446d42e" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a0e70b87eb27b33209fa4792b051c6947976f6ab829daa83819df5f58330c71" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c378d946e8a60be6b6ede48c878d145546fb42aad61df998c056ec151bf6c746" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp313-cp313-win_amd64.whl", hash = "sha256:2cd2c1e0f3a7465f22731987fff6fc427e3dcbb4ca5f7db5bbeaff2ff9a31f6d" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ba24603c58e34dd5b096dfad792d87b304fc6470cbb1c22fd64e7ebd17edcc61" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ed36662fb92ae4cb3cacc682ec6656208f323bbc23d4b08d091eecfc0863d4b5" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:040ecc95e026f71a9ad7956fea2724466602b561e6a25c2e5584160d3833aaa8" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:937e3ed86cb731276706e46e03512547e43c391a13f363e08d0fee49a7c38a0d" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1f95cc4f01c0f1701ca3b0355792bccec13ecb2ec1c469e5b85a6ef398398b1d" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-cp314-cp314-win_amd64.whl", hash = "sha256:e4f16c0019d48941220ac60b893615be2f63afedaba6a0801bdcd041b96991ce" },
+    { url = "http://10.0.0.2:5001/index/mypy/mypy-1.18.1-py3-none-any.whl", hash = "sha256:b76a4de66a0ac01da1be14ecc8ae88ddea33b8380284a9e3eae39d57ebcbe26e" },
 ]
 
 [[package]]
@@ -492,26 +654,56 @@ wheels = [
 
 [[package]]
 name = "psutil"
-version = "6.1.1"
+version = "7.0.0"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5" }
+sdist = { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53" },
-    { url = "http://10.0.0.2:5001/index/psutil/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99" },
+    { url = "http://10.0.0.2:5001/index/psutil/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553" },
 ]
 
 [[package]]
 name = "pycparser"
-version = "2.22"
+version = "2.23"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/pycparser/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6" }
+sdist = { url = "http://10.0.0.2:5001/index/pycparser/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/pycparser/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc" },
+    { url = "http://10.0.0.2:5001/index/pycparser/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934" },
+]
+
+[[package]]
+name = "pycryptodome"
+version = "3.23.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2" },
+    { url = "http://10.0.0.2:5001/index/pycryptodome/pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c" },
 ]
 
 [[package]]
@@ -574,7 +766,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "8.4.1"
+version = "8.4.2"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -583,36 +775,93 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/pytest/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c" }
+sdist = { url = "http://10.0.0.2:5001/index/pytest/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/pytest/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7" },
+    { url = "http://10.0.0.2:5001/index/pytest/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.0.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "coverage" },
+    { name = "pluggy" },
+    { name = "pytest" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/pytest-cov/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/pytest-cov/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.1.1"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/python-dotenv/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/python-dotenv/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc" },
 ]
 
 [[package]]
 name = "python-repositories"
 version = "0.1.0"
 source = { virtual = "." }
+dependencies = [
+    { name = "python-utils" },
+    { name = "structlog" },
+]
+
+[package.optional-dependencies]
+minio = [
+    { name = "minio" },
+]
+redis = [
+    { name = "redis" },
+]
 
 [package.dev-dependencies]
 dev = [
     { name = "mypy" },
     { name = "pre-commit" },
     { name = "pytest" },
+    { name = "pytest-cov" },
     { name = "pyupgrade" },
     { name = "ruff" },
     { name = "safety" },
+    { name = "testcontainers" },
+    { name = "types-redis" },
 ]
 
 [package.metadata]
+requires-dist = [
+    { name = "minio", marker = "extra == 'minio'", specifier = ">=7.2.16" },
+    { name = "python-utils", specifier = ">=0.1.0", index = "https://gitea.gt-proj.com/api/packages/brian/pypi/simple/" },
+    { name = "redis", marker = "extra == 'redis'", specifier = ">=6.4.0" },
+    { name = "structlog", specifier = ">=25.4.0" },
+]
+provides-extras = ["redis", "minio"]
 
 [package.metadata.requires-dev]
 dev = [
     { name = "mypy", specifier = ">=1.17.1" },
     { name = "pre-commit", specifier = ">=4.3.0" },
     { name = "pytest", specifier = ">=8.4.1" },
+    { name = "pytest-cov", specifier = ">=7.0.0" },
     { name = "pyupgrade", specifier = ">=3.20.0" },
     { name = "ruff", specifier = ">=0.12.11" },
     { name = "safety", specifier = ">=3.6.0" },
+    { name = "testcontainers", specifier = ">=4.13.0" },
+    { name = "types-redis", specifier = ">=4.6.0.20241004" },
+]
+
+[[package]]
+name = "python-utils"
+version = "0.1.1"
+source = { registry = "https://gitea.gt-proj.com/api/packages/brian/pypi/simple/" }
+sdist = { url = "https://gitea.gt-proj.com/api/packages/brian/pypi/files/python-utils/0.1.1/python_utils-0.1.1.tar.gz", hash = "sha256:f9e10fff2e15167260d841733bab08914803f7caeaf5f4b0534b730a0b418048" }
+wheels = [
+    { url = "https://gitea.gt-proj.com/api/packages/brian/pypi/files/python-utils/0.1.1/python_utils-0.1.1-py3-none-any.whl", hash = "sha256:ad06d94a36c828084b61b3e6b97f3c0f0fab3522ea18e603ed37c8abee49bdac" },
 ]
 
 [[package]]
@@ -627,6 +876,22 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/pyupgrade/pyupgrade-3.20.0-py2.py3-none-any.whl", hash = "sha256:cd5bf842b863f50adad324a01c30aef60b9f698a9814848094818659c92cd1f4" },
 ]
 
+[[package]]
+name = "pywin32"
+version = "311"
+source = { registry = "http://10.0.0.2:5001/index/" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87" },
+    { url = "http://10.0.0.2:5001/index/pywin32/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42" },
+]
+
 [[package]]
 name = "pyyaml"
 version = "6.0.2"
@@ -654,53 +919,62 @@ wheels = [
 ]
 
 [[package]]
-name = "regex"
-version = "2025.8.29"
+name = "redis"
+version = "6.4.0"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29.tar.gz", hash = "sha256:731ddb27a0900fa227dfba976b4efccec8c1c6fba147829bb52e71d49e91a5d7" }
+sdist = { url = "http://10.0.0.2:5001/index/redis/redis-6.4.0.tar.gz", hash = "sha256:b01bc7282b8444e28ec36b261df5375183bb47a07eb9c603f284e89cbc5ef010" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dd61f18dc4446bc3a2904559a61f32e98091cef7fb796e06fa35b9bfefe4c0c5" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f21b416be10a8348a7313ba8c610569a1ab4bf8ec70731750540842a4551cd3d" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:008947a7fa92f4cb3b28201c9aa7becc0a44c31a7c2fcb934356e1877baccc09" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e78ab1b3e68b890d7ebd69218cfbfe4a09dc00b8a47be8648510b81b932d55ff" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a848368797515bc141d3fad5fd2d81bf9e8a6a22d9ac1a4be4690dd22e997854" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8eaf3ea6631f804efcf0f5bd0e4ab62ba984fd9b70e3aef44b05cc6b951cc728" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4561aeb36b0bf3bb44826e4b61a80c6ace0d8839bf4914d78f061f9ba61444b4" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:93e077d1fbd24033fa427eab43d80ad47e449d25700cda78e8cac821a30090bf" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d92379e53d782bdb773988687300e3bccb91ad38157b754b04b1857aaeea16a3" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d41726de2040c2a487bbac70fdd6e3ff2f1aa47dc91f0a29f6955a6dfa0f06b6" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1915dfda52bd4d466f3a66b66988db1f647ee1d9c605858640ceeb779cffd908" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-win32.whl", hash = "sha256:e2ef0087ad6949918836f215480a9331f6c59ad54912a9a412f08ab1c9ccbc98" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-win_amd64.whl", hash = "sha256:c15d361fe9800bf38ef69c2e0c4b8b961ae4ce2f076fcf4f28e1fc9ea127f55a" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp312-cp312-win_arm64.whl", hash = "sha256:305577fab545e64fb84d9a24269aa3132dbe05e1d7fa74b3614e93ec598fe6e6" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:eed02e5c39f91268ea4ddf68ee19eed189d57c605530b7d32960f54325c52e7a" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:630d5c7e0a490db2fee3c7b282c8db973abcbb036a6e4e6dc06c4270965852be" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2206d3a30469e8fc8848139884168127f456efbaca8ae14809c26b98d2be15c6" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:394c492c398a9f9e17545e19f770c58b97e65963eedaa25bb879e80a03e2b327" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:db8b0e05af08ff38d78544950e844b5f159032b66dedda19b3f9b17297248be7" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cd7c1821eff911917c476d41030b422791ce282c23ee9e1b8f7681fd0993f1e4" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0b4d8a7f75da748a2d0c045600259f1899c9dd8dd9d3da1daa50bf534c3fa5ba" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5cd74545c32e0da0d489c2293101a82f4a1b88050c235e45509e4123017673b2" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:97b98ea38fc3c1034f3d7bd30288d2c5b3be8cdcd69e2061d1c86cb14644a27b" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:8decb26f271b989d612c5d99db5f8f741dcd63ece51c59029840070f5f9778bf" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:62141843d1ec079cd66604424af566e542e7e072b2d9e37165d414d2e6e271dd" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-win32.whl", hash = "sha256:dd23006c90d9ff0c2e4e5f3eaf8233dcefe45684f2acb330869ec5c2aa02b1fb" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-win_amd64.whl", hash = "sha256:d41a71342819bdfe87c701f073a14ea4bd3f847333d696c7344e9ff3412b7f70" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp313-cp313-win_arm64.whl", hash = "sha256:54018e66344d60b214f4aa151c046e0fa528221656f4f7eba5a787ccc7057312" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c03308757831a8d89e7c007abb75d1d4c9fbca003b5fb32755d4475914535f08" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0d4b71791975fc203e0e6c50db974abb23a8df30729c1ac4fd68c9f2bb8c9358" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:284fcd2dcb613e8b89b22a30cf42998c9a73ee360b8a24db8457d24f5c42282e" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b394b5157701b22cf63699c792bfeed65fbfeacbd94fea717a9e2036a51148ab" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ea197ac22396faf5e70c87836bb89f94ed5b500e1b407646a4e5f393239611f1" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:decd84f195c08b3d9d0297a7e310379aae13ca7e166473534508c81b95c74bba" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ebaf81f7344dbf1a2b383e35923648de8f78fb262cf04154c82853887ac3e684" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d82fb8a97e5ed8f1d3ed7f8e0e7fe1760faa95846c0d38b314284dfdbe86b229" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1dcec2448ed0062f63e82ca02d1d05f74d4127cb6a9d76a73df60e81298d380b" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d0ffe4a3257a235f9d39b99c6f1bc53c7a4b11f28565726b1aa00a5787950d60" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5421a2d2026e8189500f12375cfd80a9a1914466d446edd28b37eb33c1953b39" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-win32.whl", hash = "sha256:ceeeaab602978c8eac3b25b8707f21a69c0bcd179d9af72519da93ef3966158f" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-win_amd64.whl", hash = "sha256:5ba4f8b0d5b88c33fe4060e6def58001fd8334b03c7ce2126964fa8851ab5d1b" },
-    { url = "http://10.0.0.2:5001/index/regex/regex-2025.8.29-cp314-cp314-win_arm64.whl", hash = "sha256:7b4a3dc155984f09a55c64b90923cb136cd0dad21ca0168aba2382d90ea4c546" },
+    { url = "http://10.0.0.2:5001/index/redis/redis-6.4.0-py3-none-any.whl", hash = "sha256:f0544fa9604264e9464cdf4814e7d4830f74b165d52f2a330a760a88dd248b7f" },
+]
+
+[[package]]
+name = "regex"
+version = "2025.9.1"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1.tar.gz", hash = "sha256:88ac07b38d20b54d79e704e38aa3bd2c0f8027432164226bdee201a1c0c9c9ff" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:84a25164bd8dcfa9f11c53f561ae9766e506e580b70279d05a7946510bdd6f6a" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:645e88a73861c64c1af558dd12294fb4e67b5c1eae0096a60d7d8a2143a611c7" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:10a450cba5cd5409526ee1d4449f42aad38dd83ac6948cbd6d7f71ca7018f7db" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9dc5991592933a4192c166eeb67b29d9234f9c86344481173d1bc52f73a7104" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a32291add816961aab472f4fad344c92871a2ee33c6c219b6598e98c1f0108f2" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:588c161a68a383478e27442a678e3b197b13c5ba51dbba40c1ccb8c4c7bee9e9" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47829ffaf652f30d579534da9085fe30c171fa2a6744a93d52ef7195dc38218b" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e978e5a35b293ea43f140c92a3269b6ab13fe0a2bf8a881f7ac740f5a6ade85" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4cf09903e72411f4bf3ac1eddd624ecfd423f14b2e4bf1c8b547b72f248b7bf7" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d016b0f77be63e49613c9e26aaf4a242f196cd3d7a4f15898f5f0ab55c9b24d2" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:656563e620de6908cd1c9d4f7b9e0777e3341ca7db9d4383bcaa44709c90281e" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-win32.whl", hash = "sha256:df33f4ef07b68f7ab637b1dbd70accbf42ef0021c201660656601e8a9835de45" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:5aba22dfbc60cda7c0853516104724dc904caa2db55f2c3e6e984eb858d3edf3" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:ec1efb4c25e1849c2685fa95da44bfde1b28c62d356f9c8d861d4dad89ed56e9" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bc6834727d1b98d710a63e6c823edf6ffbf5792eba35d3fa119531349d4142ef" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c3dc05b6d579875719bccc5f3037b4dc80433d64e94681a0061845bd8863c025" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22213527df4c985ec4a729b055a8306272d41d2f45908d7bacb79be0fa7a75ad" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8e3f6e3c5a5a1adc3f7ea1b5aec89abfc2f4fbfba55dafb4343cd1d084f715b2" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bcb89c02a0d6c2bec9b0bb2d8c78782699afe8434493bfa6b4021cc51503f249" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b0e2f95413eb0c651cd1516a670036315b91b71767af83bc8525350d4375ccba" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a41dc039e1c97d3c2ed3e26523f748e58c4de3ea7a31f95e1cf9ff973fff5a" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f0b4258b161094f66857a26ee938d3fe7b8a5063861e44571215c44fbf0e5df" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bf70e18ac390e6977ea7e56f921768002cb0fa359c4199606c7219854ae332e0" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b84036511e1d2bb0a4ff1aec26951caa2dea8772b223c9e8a19ed8885b32dbac" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c2e05dcdfe224047f2a59e70408274c325d019aad96227ab959403ba7d58d2d7" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-win32.whl", hash = "sha256:3b9a62107a7441b81ca98261808fed30ae36ba06c8b7ee435308806bd53c1ed8" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:b38afecc10c177eb34cfae68d669d5161880849ba70c05cbfbe409f08cc939d7" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp313-cp313-win_arm64.whl", hash = "sha256:ec329890ad5e7ed9fc292858554d28d58d56bf62cf964faf0aa57964b21155a0" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:72fb7a016467d364546f22b5ae86c45680a4e0de6b2a6f67441d22172ff641f1" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c9527fa74eba53f98ad86be2ba003b3ebe97e94b6eb2b916b31b5f055622ef03" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c905d925d194c83a63f92422af7544ec188301451b292c8b487f0543726107ca" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74df7c74a63adcad314426b1f4ea6054a5ab25d05b0244f0c07ff9ce640fa597" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4f6e935e98ea48c7a2e8be44494de337b57a204470e7f9c9c42f912c414cd6f5" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4a62d033cd9ebefc7c5e466731a508dfabee827d80b13f455de68a50d3c2543d" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef971ebf2b93bdc88d8337238be4dfb851cc97ed6808eb04870ef67589415171" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d936a1db208bdca0eca1f2bb2c1ba1d8370b226785c1e6db76e32a228ffd0ad5" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:7e786d9e4469698fc63815b8de08a89165a0aa851720eb99f5e0ea9d51dd2b6a" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6b81d7dbc5466ad2c57ce3a0ddb717858fe1a29535c8866f8514d785fdb9fc5b" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cd4890e184a6feb0ef195338a6ce68906a8903a0f2eb7e0ab727dbc0a3156273" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-win32.whl", hash = "sha256:34679a86230e46164c9e0396b56cab13c0505972343880b9e705083cc5b8ec86" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:a1196e530a6bfa5f4bde029ac5b0295a6ecfaaffbfffede4bbaf4061d9455b70" },
+    { url = "http://10.0.0.2:5001/index/regex/regex-2025.9.1-cp314-cp314-win_arm64.whl", hash = "sha256:f46d525934871ea772930e997d577d48c6983e50f206ff7b66d4ac5f8941e993" },
 ]
 
 [[package]]
@@ -771,33 +1045,33 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.12.11"
+version = "0.13.0"
 source = { registry = "http://10.0.0.2:5001/index/" }
-sdist = { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11.tar.gz", hash = "sha256:c6b09ae8426a65bbee5425b9d0b82796dbb07cb1af045743c79bfb163001165d" }
+sdist = { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0.tar.gz", hash = "sha256:5b4b1ee7eb35afae128ab94459b13b2baaed282b1fb0f472a73c82c996c8ae60" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-linux_armv6l.whl", hash = "sha256:93fce71e1cac3a8bf9200e63a38ac5c078f3b6baebffb74ba5274fb2ab276065" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b8e33ac7b28c772440afa80cebb972ffd823621ded90404f29e5ab6d1e2d4b93" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d69fb9d4937aa19adb2e9f058bc4fbfe986c2040acb1a4a9747734834eaa0bfd" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:411954eca8464595077a93e580e2918d0a01a19317af0a72132283e28ae21bee" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6a2c0a2e1a450f387bf2c6237c727dd22191ae8c00e448e0672d624b2bbd7fb0" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ca4c3a7f937725fd2413c0e884b5248a19369ab9bdd850b5781348ba283f644" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:4d1df0098124006f6a66ecf3581a7f7e754c4df7644b2e6704cd7ca80ff95211" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a8dd5f230efc99a24ace3b77e3555d3fbc0343aeed3fc84c8d89e75ab2ff793" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dc75533039d0ed04cd33fb8ca9ac9620b99672fe7ff1533b6402206901c34ee" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4fc58f9266d62c6eccc75261a665f26b4ef64840887fc6cbc552ce5b29f96cc8" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:5a0113bd6eafd545146440225fe60b4e9489f59eb5f5f107acd715ba5f0b3d2f" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0d737b4059d66295c3ea5720e6efc152623bb83fde5444209b69cd33a53e2000" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:916fc5defee32dbc1fc1650b576a8fed68f5e8256e2180d4d9855aea43d6aab2" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c984f07d7adb42d3ded5be894fb4007f30f82c87559438b4879fe7aa08c62b39" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e07fbb89f2e9249f219d88331c833860489b49cdf4b032b8e4432e9b13e8a4b9" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-win32.whl", hash = "sha256:c792e8f597c9c756e9bcd4d87cf407a00b60af77078c96f7b6366ea2ce9ba9d3" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-win_amd64.whl", hash = "sha256:a3283325960307915b6deb3576b96919ee89432ebd9c48771ca12ee8afe4a0fd" },
-    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.12.11-py3-none-win_arm64.whl", hash = "sha256:bae4d6e6a2676f8fb0f98b74594a048bae1b944aab17e9f5d504062303c6dbea" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-linux_armv6l.whl", hash = "sha256:137f3d65d58ee828ae136a12d1dc33d992773d8f7644bc6b82714570f31b2004" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:21ae48151b66e71fd111b7d79f9ad358814ed58c339631450c66a4be33cc28b9" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:64de45f4ca5441209e41742d527944635a05a6e7c05798904f39c85bafa819e3" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b2c653ae9b9d46e0ef62fc6fbf5b979bda20a0b1d2b22f8f7eb0cde9f4963b8" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4cec632534332062bc9eb5884a267b689085a1afea9801bf94e3ba7498a2d207" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dcd628101d9f7d122e120ac7c17e0a0f468b19bc925501dbe03c1cb7f5415b24" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:afe37db8e1466acb173bb2a39ca92df00570e0fd7c94c72d87b51b21bb63efea" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f96a8d90bb258d7d3358b372905fe7333aaacf6c39e2408b9f8ba181f4b6ef2" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b5e3d883e4f924c5298e3f2ee0f3085819c14f68d1e5b6715597681433f153" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03447f3d18479df3d24917a92d768a89f873a7181a064858ea90a804a7538991" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:fbc6b1934eb1c0033da427c805e27d164bb713f8e273a024a7e86176d7f462cf" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a8ab6a3e03665d39d4a25ee199d207a488724f022db0e1fe4002968abdb8001b" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d2a5c62f8ccc6dd2fe259917482de7275cecc86141ee10432727c4816235bc41" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b7b85ca27aeeb1ab421bc787009831cffe6048faae08ad80867edab9f2760945" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:79ea0c44a3032af768cabfd9616e44c24303af49d633b43e3a5096e009ebe823" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-win32.whl", hash = "sha256:4e473e8f0e6a04e4113f2e1de12a5039579892329ecc49958424e5568ef4f768" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-win_amd64.whl", hash = "sha256:48e5c25c7a3713eea9ce755995767f4dcd1b0b9599b638b12946e892123d1efb" },
+    { url = "http://10.0.0.2:5001/index/ruff/ruff-0.13.0-py3-none-win_arm64.whl", hash = "sha256:ab80525317b1e1d38614addec8ac954f1b3e662de9d59114ecbf771d00cf613e" },
 ]
 
 [[package]]
 name = "safety"
-version = "3.6.0"
+version = "3.6.1"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
     { name = "authlib" },
@@ -820,9 +1094,9 @@ dependencies = [
     { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/safety/safety-3.6.0.tar.gz", hash = "sha256:a820f827699f83d3d5c2faab24c0ac4d094911931503180847d97942c0a6f7e3" }
+sdist = { url = "http://10.0.0.2:5001/index/safety/safety-3.6.1.tar.gz", hash = "sha256:4d021e61cb8be527274560e5729616155b42e5442ca54e62c57da40076d80fd4" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/safety/safety-3.6.0-py3-none-any.whl", hash = "sha256:9cddbfd7a578b35e4d29df4fb6e3808425ed792a09d81400a5b7f4b4535ef666" },
+    { url = "http://10.0.0.2:5001/index/safety/safety-3.6.1-py3-none-any.whl", hash = "sha256:22bc89d4e6471aa0fce41952bb5f7cb5f2f126127976024fe55c641c5447ce0b" },
 ]
 
 [[package]]
@@ -868,6 +1142,15 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/sniffio/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2" },
 ]
 
+[[package]]
+name = "structlog"
+version = "25.4.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/structlog/structlog-25.4.0.tar.gz", hash = "sha256:186cd1b0a8ae762e29417095664adf1d6a31702160a46dacb7796ea82f7409e4" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/structlog/structlog-25.4.0-py3-none-any.whl", hash = "sha256:fe809ff5c27e557d14e613f45ca441aabda051d119ee5a0102aaba6ce40eed2c" },
+]
+
 [[package]]
 name = "tenacity"
 version = "9.1.2"
@@ -877,6 +1160,22 @@ wheels = [
     { url = "http://10.0.0.2:5001/index/tenacity/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138" },
 ]
 
+[[package]]
+name = "testcontainers"
+version = "4.13.0"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "docker" },
+    { name = "python-dotenv" },
+    { name = "typing-extensions" },
+    { name = "urllib3" },
+    { name = "wrapt" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/testcontainers/testcontainers-4.13.0.tar.gz", hash = "sha256:ee2bc39324eeeeb710be779208ae070c8373fa9058861859203f536844b0f412" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/testcontainers/testcontainers-4.13.0-py3-none-any.whl", hash = "sha256:784292e0a3f3a4588fbbf5d6649adda81fea5fd61ad3dc73f50a7a903904aade" },
+]
+
 [[package]]
 name = "tokenize-rt"
 version = "6.2.0"
@@ -909,7 +1208,7 @@ wheels = [
 
 [[package]]
 name = "typer"
-version = "0.17.3"
+version = "0.17.4"
 source = { registry = "http://10.0.0.2:5001/index/" }
 dependencies = [
     { name = "click" },
@@ -917,9 +1216,56 @@ dependencies = [
     { name = "shellingham" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "http://10.0.0.2:5001/index/typer/typer-0.17.3.tar.gz", hash = "sha256:0c600503d472bcf98d29914d4dcd67f80c24cc245395e2e00ba3603c9332e8ba" }
+sdist = { url = "http://10.0.0.2:5001/index/typer/typer-0.17.4.tar.gz", hash = "sha256:b77dc07d849312fd2bb5e7f20a7af8985c7ec360c45b051ed5412f64d8dc1580" }
 wheels = [
-    { url = "http://10.0.0.2:5001/index/typer/typer-0.17.3-py3-none-any.whl", hash = "sha256:643919a79182ab7ac7581056d93c6a2b865b026adf2872c4d02c72758e6f095b" },
+    { url = "http://10.0.0.2:5001/index/typer/typer-0.17.4-py3-none-any.whl", hash = "sha256:015534a6edaa450e7007eba705d5c18c3349dcea50a6ad79a5ed530967575824" },
+]
+
+[[package]]
+name = "types-cffi"
+version = "1.17.0.20250914"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "types-setuptools" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/types-cffi/types_cffi-1.17.0.20250914.tar.gz", hash = "sha256:b0d051a5d7cfc22a5195f2167e0130ee4755baa6f045f4efa2bf3dc12916679f" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/types-cffi/types_cffi-1.17.0.20250914-py3-none-any.whl", hash = "sha256:f563d7ac8faa664be9e828222bea5cc9cdda9e3fcdc9f077434c5a1fda9c802a" },
+]
+
+[[package]]
+name = "types-pyopenssl"
+version = "24.1.0.20240722"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "types-cffi" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/types-pyopenssl/types-pyOpenSSL-24.1.0.20240722.tar.gz", hash = "sha256:47913b4678a01d879f503a12044468221ed8576263c1540dcb0484ca21b08c39" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/types-pyopenssl/types_pyOpenSSL-24.1.0.20240722-py3-none-any.whl", hash = "sha256:6a7a5d2ec042537934cfb4c9d4deb0e16c4c6250b09358df1f083682fe6fda54" },
+]
+
+[[package]]
+name = "types-redis"
+version = "4.6.0.20241004"
+source = { registry = "http://10.0.0.2:5001/index/" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "types-pyopenssl" },
+]
+sdist = { url = "http://10.0.0.2:5001/index/types-redis/types-redis-4.6.0.20241004.tar.gz", hash = "sha256:5f17d2b3f9091ab75384153bfa276619ffa1cf6a38da60e10d5e6749cc5b902e" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/types-redis/types_redis-4.6.0.20241004-py3-none-any.whl", hash = "sha256:ef5da68cb827e5f606c8f9c0b49eeee4c2669d6d97122f301d3a55dc6a63f6ed" },
+]
+
+[[package]]
+name = "types-setuptools"
+version = "80.9.0.20250822"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/types-setuptools/types_setuptools-80.9.0.20250822.tar.gz", hash = "sha256:070ea7716968ec67a84c7f7768d9952ff24d28b65b6594797a464f1b3066f965" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/types-setuptools/types_setuptools-80.9.0.20250822-py3-none-any.whl", hash = "sha256:53bf881cb9d7e46ed12c76ef76c0aaf28cfe6211d3fab12e0b83620b1a8642c3" },
 ]
 
 [[package]]
@@ -953,3 +1299,52 @@ sdist = { url = "http://10.0.0.2:5001/index/virtualenv/virtualenv-20.34.0.tar.gz
 wheels = [
     { url = "http://10.0.0.2:5001/index/virtualenv/virtualenv-20.34.0-py3-none-any.whl", hash = "sha256:341f5afa7eee943e4984a9207c025feedd768baff6753cd660c857ceb3e36026" },
 ]
+
+[[package]]
+name = "wrapt"
+version = "1.17.3"
+source = { registry = "http://10.0.0.2:5001/index/" }
+sdist = { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0" }
+wheels = [
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6" },
+    { url = "http://10.0.0.2:5001/index/wrapt/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22" },
+]