chore: release v2.0.2 [skip ci]

Merge pull request '[patch] Use dict[str, Any] for JSON repository document types' (#38 ) from cursor/json-dict-str-any-typing into main
Reviewed-on: https://gitea.lille-vemmelund.dk/brian/python-repositories/pulls/38
2026-07-09 16:45:24 +00:00 · 2026-07-09 18:45:10 +02:00 · 2026-07-09 18:41:23 +02:00 · 2026-07-09 14:38:25 +00:00 · 2026-07-09 16:38:05 +02:00 · 2026-07-09 15:57:07 +02:00
42 changed files with 2056 additions and 784 deletions
@@ -0,0 +1,10 @@
+# Redis (requires redis extra)
+REDIS_URI=redis://localhost:6379
+
+# MinIO (requires minio extra)
+MINIO_ENDPOINT=localhost:9000
+MINIO_ACCESS_KEY=minioadmin
+MINIO_SECRET_KEY=minioadmin
+MINIO_BUCKET=my-bucket
+MINIO_SECURE=false
+MINIO_CREATE_BUCKET_IF_MISSING=true
@@ -2,9 +2,11 @@

 If this PR changes files under `python_repositories/`, the **title must** start with one of:

- `[patch]` or `[fix]` — bug fix (0.3.1 → 0.3.2)
- `[minor]` or `[feat]` — new feature (0.3.1 → 0.4.0)
- `[major]` or `[breaking]` — breaking change (0.3.1 → 1.0.0)
+- `[patch]` or `[fix]` — bug fix (`1.2.3` → `1.2.4`)
+- `[minor]` or `[feat]` — new feature (`1.2.3` → `1.3.0`)
+- `[major]` or `[breaking]` — breaking change (`1.2.3` → `2.0.0`)
+
+Current version: see [`pyproject.toml`](pyproject.toml) on `main`.

 Docs-, CI-, or test-only PRs do not need a prefix.

@@ -16,8 +16,14 @@ jobs:

      - name: Check PR title when source files change
        env:
-          PR_TITLE: ${{ github.event.pull_request.title }}
+          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: |
          git fetch origin "${{ github.base_ref }}"
+          PR_TITLE=$(scripts/ci/fetch-pr-title.sh)
+          echo "Live PR title: ${PR_TITLE}"
          git diff --name-only "origin/${{ github.base_ref }}...HEAD" \
            | scripts/ci/check-pr-title.sh "$PR_TITLE"
@@ -22,6 +22,16 @@ jobs:
          COMMIT_MSG: ${{ github.event.head_commit.message }}
        run: scripts/ci/parse-merge-commit.sh "$COMMIT_MSG"

+      - name: Set up Python
+        if: steps.meta.outputs.bump != 'skip'
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: .python-version
+
+      - name: Install uv
+        if: steps.meta.outputs.bump != 'skip'
+        run: pip install uv
+
      - name: Bump version
        if: steps.meta.outputs.bump != 'skip'
        id: bump
@@ -45,7 +55,7 @@ jobs:
        run: |
          git config user.name "CI Bot"
          git config user.email "[email protected]"
-          git add pyproject.toml
+          git add pyproject.toml uv.lock
          git commit -m "chore: release v${VERSION} [skip ci]"
          git tag "v${VERSION}"
          git remote set-url origin "https://x-access-token:${CI_RUNNER_TOKEN}@${GITHUB_SERVER_URL#https://}/${GITHUB_REPOSITORY}.git"
@@ -7,7 +7,7 @@ on:
  pull_request:

 jobs:
-  test:
+  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
@@ -26,10 +26,114 @@ jobs:
          UV_LINK_MODE: copy
        run: uv sync --all-extras

-      - name: Run pytest
+      - name: Run unit tests
+        run: |
+          # --cov-fail-under=0: partial coverage only; floor is checked in coverage-report.
+          uv run pytest tests/unit/ -m "not integration" \
+            --cov=python_repositories \
+            --cov-report= \
+            --cov-fail-under=0
+
+      - name: Upload unit coverage
+        uses: https://github.com/christopherHX/gitea-upload-artifact@v4
+        with:
+          name: coverage-unit
+          path: .coverage
+          retention-days: 1
+          compression-level: 0
+
+  integration-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: .python-version
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Install dependencies
        env:
-          PYTHONPATH: .
-        run: uv run pytest --cov=python_repositories --cov-report=term-missing > coverage.txt
+          UV_LINK_MODE: copy
+        run: uv sync --all-extras
+
+      - name: Verify Docker
+        run: docker info
+
+      - name: Run integration tests
+        run: |
+          # --cov-fail-under=0: partial coverage only; floor is checked in coverage-report.
+          uv run pytest -m integration \
+            --cov=python_repositories \
+            --cov-report= \
+            --cov-fail-under=0
+
+      - name: Upload integration coverage
+        uses: https://github.com/christopherHX/gitea-upload-artifact@v4
+        with:
+          name: coverage-integration
+          path: .coverage
+          retention-days: 1
+          compression-level: 0
+
+  coverage-report:
+    # Merges unit + integration coverage and enforces fail_under from pyproject.toml.
+    needs: [unit-tests, integration-tests]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request' || github.event_name == 'push'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: .python-version
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Install dependencies
+        env:
+          UV_LINK_MODE: copy
+        run: uv sync --all-extras
+
+      - name: Download unit coverage
+        uses: https://github.com/christopherHX/gitea-download-artifact@v4
+        with:
+          name: coverage-unit
+          path: coverage-unit
+
+      - name: Download integration coverage
+        uses: https://github.com/christopherHX/gitea-download-artifact@v4
+        with:
+          name: coverage-integration
+          path: coverage-integration
+
+      - name: Combine coverage report
+        run: |
+          # --fail-under=0 so the full report is always written before the floor check.
+          uv run coverage combine coverage-unit/.coverage coverage-integration/.coverage
+          uv run coverage report -m --include='python_repositories/*' --fail-under=0 > coverage.txt
+
+      - name: Show coverage report
+        run: cat coverage.txt
+
+      - name: Enforce coverage floor
+        run: |
+          # Reads fail_under from pyproject.toml; only combined coverage is evaluated here.
+          FAIL_UNDER=$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml', 'rb'))['tool']['coverage']['report']['fail_under'])")
+          echo "Checking combined coverage against ${FAIL_UNDER}% floor..."
+          if uv run coverage report --fail-under="$FAIL_UNDER" --include='python_repositories/*'; then
+            echo "Coverage floor met."
+          else
+            echo "::error::Combined coverage is below the ${FAIL_UNDER}% floor"
+            exit 1
+          fi

      - name: Post coverage summary to PR
        if: github.event_name == 'pull_request'
@@ -12,6 +12,8 @@ Subclass an adapter in your own repository to add domain-specific methods while
 | **Adapters**     | Technology-specific base classes (`RedisAdapter`, `MinioAdapter`) |
 | **Your project** | Subclass an adapter and add domain methods                        |

+Connection adapters expose `connect()`, `disconnect()`, and `is_connected()`. The latter verifies backend reachability with a cached health probe (default TTL: 1 second). Subclasses may override `health_check_ttl_seconds`. `connect()` is idempotent: calling it while already connected and healthy is a no-op.
+
 ## Optional dependencies

 Repository **interfaces** import with the base package. **Adapters** require the matching extra; importing an adapter without its extra raises `ImportError` with install instructions.
@@ -32,14 +34,64 @@ Requires Redis with the RedisJSON module (e.g. redis-stack).
 | -------------------- | ---------------------------------------------------- |
 | `REDIS_URI`          | Redis connection URL (e.g. `redis://localhost:6379`) |

+For key discovery:
+
+- `list_keys(pattern)` is simple and returns a `list[str]`, but it uses Redis `KEYS` and may block on large datasets.
+- `scan_keys(pattern, *, count=None)` is preferred for production use and yields keys incrementally via Redis `SCAN`.
+
+Example:
+
+```python
+for key in repo.scan_keys("user:*"):
+    print(key)
+```
+
 ### MinIO (`ObjectRepositoryInterface`)

 | Environment variable             | Description                                                              |
-| -------------------- | ------------------------------------------- |
+| -------------------------------- | ------------------------------------------------------------------------ |
 | `MINIO_ENDPOINT`                 | MinIO server endpoint                                                    |
 | `MINIO_ACCESS_KEY`               | Access key                                                               |
 | `MINIO_SECRET_KEY`               | Secret key                                                               |
-| `MINIO_BUCKET`       | Bucket name (created on connect if missing) |
+| `MINIO_BUCKET`                   | Bucket name                                                              |
+| `MINIO_SECURE`                   | Use HTTPS (`true`/`false`; default: `true`)                              |
+| `MINIO_CREATE_BUCKET_IF_MISSING` | Auto-create `MINIO_BUCKET` on connect (`true`/`false`; default: `false`) |
+
+Copy [`.env.example`](.env.example) to `.env` for local development. `RedisConfig.from_env()` and `MinioConfig.from_env()` load `.env` automatically when resolving configuration from the environment.
+
+For production, it is recommended to leave `MINIO_CREATE_BUCKET_IF_MISSING` unset so that `connect()` fails fast if the expected bucket is missing. For local development, you will often want `MINIO_SECURE=false` and `MINIO_CREATE_BUCKET_IF_MISSING=true`.
+
+## Configuration injection
+
+Adapters accept optional `config` and `client` keyword arguments for explicit setup and testing:
+
+```python
+from python_repositories import RedisAdapter, RedisConfig, MinioAdapter, MinioConfig
+
+redis = RedisAdapter(config=RedisConfig(uri="redis://localhost:6379"))
+minio = MinioAdapter(
+    config=MinioConfig(
+        endpoint="localhost:9000",
+        access_key="minioadmin",
+        secret_key="minioadmin",
+        bucket="my-bucket",
+        secure=False,
+        # create_bucket_if_missing=True,  # convenient for local dev
+    )
+)
+```
+
+When both `config` and `client` are provided, `connect()` skips client creation (the caller owns the client lifecycle). `config` is required whenever `client` is injected.
+
+Load a `.env` file explicitly:
+
+```python
+from python_repositories import load_dotenv
+
+load_dotenv()  # optional — from_env() also loads .env by default
+```
+
+Calling `RedisAdapter()` or `MinioAdapter()` with no arguments still loads configuration from environment variables (and `.env` if present).

 ## Quick start

@@ -71,16 +123,18 @@ with ArtifactObjectRepository() as repo:
 ### Subclassing in your own project

 ```python
+from typing import Any
+
 from python_repositories import RedisAdapter

 class UserRepository(RedisAdapter):
    def _key(self, user_id: str) -> str:
        return f"user:{user_id}"

-    def get_user(self, user_id: str) -> dict | None:
+    def get_user(self, user_id: str) -> dict[str, Any] | None:
        return self.get(self._key(user_id))

-    def save_user(self, user_id: str, user: dict) -> None:
+    def save_user(self, user_id: str, user: dict[str, Any]) -> None:
        self.set(self._key(user_id), user)
 ```

@@ -91,9 +145,12 @@ from python_repositories import (
    ConnectionAwareInterface,
    ContextAwareInterface,
    JsonRepositoryInterface,
+    MinioAdapter,
+    MinioConfig,
    ObjectRepositoryInterface,
    RedisAdapter,
-    MinioAdapter,
+    RedisConfig,
+    load_dotenv,
 )
 ```

@@ -102,7 +159,20 @@ from python_repositories import (
 ```bash
 uv sync --all-extras
 uv run pre-commit install   # once per clone — runs hooks on git commit
-uv run pytest tests/integration/ -v
+uv run pytest tests/unit/ -v                          # fast, no Docker
+uv run pytest -m "not integration" -v                 # all non-Docker tests
+uv run pytest -v                                      # full suite (requires Docker)
+```
+
+Integration tests are marked with `@pytest.mark.integration` and require Docker (testcontainers). Run unit tests alone for quick local feedback.
+
+CI runs unit and integration tests in parallel with coverage, then merges `.coverage` artifacts in a follow-up job (via [christopherhx/gitea-\*-artifact@v4](https://github.com/christopherHX/gitea-upload-artifact) for Gitea 1.26 compatibility). Combined coverage must be at least **90%**; the floor is set by [`fail_under` in `pyproject.toml`](pyproject.toml#L45-L48) and enforced after merging unit and integration coverage, not on unit-only runs.
+
+To check coverage locally (requires Docker for the full suite):
+
+```bash
+uv run pytest --cov=python_repositories --cov-report=
+uv run coverage report
 ```

 `pre-commit` is included in the dev dependency group. `uv sync` installs the CLI, but git does not run hooks until you install them with `pre-commit install` (one time per clone). After that, commits run the checks defined in [`.pre-commit-config.yaml`](.pre-commit-config.yaml) (ruff, mypy, pyupgrade, prettier, and general file hygiene).
@@ -113,8 +183,6 @@ To run all hooks manually without committing:
 uv run pre-commit run --all-files
 ```

-Integration tests require Docker (testcontainers).
-
 ## Releases

 Releases are automated when a pull request is merged to `main`. CI reads the **merged PR title** to decide whether and how to bump the version.
@@ -123,7 +191,7 @@ Releases are automated when a pull request is merged to `main`. CI reads the **m

 1. Open a PR targeting `main` (see [`.gitea/PULL_REQUEST_TEMPLATE.md`](.gitea/PULL_REQUEST_TEMPLATE.md)).
 2. If the PR changes files under `python_repositories/`, the title **must** start with a version bump prefix (enforced by CI).
-3. On merge, [`release.yml`](.gitea/workflows/release.yml) bumps [`pyproject.toml`](pyproject.toml), commits, tags `vX.Y.Z`, creates a Gitea release with auto-generated notes, and pushes the tag.
+3. On merge, [`release.yml`](.gitea/workflows/release.yml) bumps [`pyproject.toml`](pyproject.toml) and syncs [`uv.lock`](uv.lock), commits, tags `vX.Y.Z`, creates a Gitea release with auto-generated notes, and pushes the tag.
 4. [`publish.yml`](.gitea/workflows/publish.yml) builds and publishes the package to the Gitea Package Registry.

 Docs-, CI-, and test-only PRs do not need a prefix and will not trigger a release.
@@ -132,9 +200,9 @@ Docs-, CI-, and test-only PRs do not need a prefix and will not trigger a releas

 | Prefix                    | Bump       | Example               |
 | ------------------------- | ---------- | --------------------- |
-| `[patch]` or `[fix]`      | patch      | `0.3.1` → `0.3.2`     |
-| `[minor]` or `[feat]`     | minor      | `0.3.1` → `0.4.0`     |
-| `[major]` or `[breaking]` | major      | `0.3.1` → `1.0.0`     |
+| `[patch]` or `[fix]`      | patch      | `1.2.3` → `1.2.4`     |
+| `[minor]` or `[feat]`     | minor      | `1.2.3` → `1.3.0`     |
+| `[major]` or `[breaking]` | major      | `1.2.3` → `2.0.0`     |
 | _(none)_                  | no release | docs / CI / deps only |

 Example titles:
@@ -148,4 +216,4 @@ Release notes are generated from commits since the previous tag (see [`scripts/c

 ### Manual release

-You can still push a `v*.*.*` tag manually; `publish.yml` will build and publish. The current baseline version is **0.3.1**.
+You can still push a `v*.*.*` tag manually; `publish.yml` will build and publish. The current released version is in [`pyproject.toml`](pyproject.toml) (and on the latest `v*.*.*` tag).
@@ -1,6 +1,6 @@
 [project]
 name = "python-repositories"
-version = "0.3.2"
+version = "2.0.2"
 description = "Various python repository interfaces exposed as a python package."
 authors = [
    { name = "Brian Bjarke Jensen", email = "[email protected]" }
@@ -14,6 +14,7 @@ classifiers = [
    "Operating System :: OS Independent",
 ]
 dependencies = [
+    "python-dotenv>=1.0.0",
    "python-utils>=0.1.0",
    "structlog>=25.4.0",
 ]
@@ -33,6 +34,18 @@ build-backend = "hatchling.build"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 pythonpath = ["."]
+addopts = "--import-mode=importlib"
+markers = [
+    "integration: tests requiring Docker containers (deselect with '-m \"not integration\"')",
+]
+
+[tool.coverage.run]
+source = ["python_repositories"]
+
+[tool.coverage.report]
+fail_under = 100
+show_missing = true
+precision = 2

 [tool.uv.sources]
 python-utils = { index = "gitea" }
@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING

 # Interfaces are always available; they have no optional backend dependencies.
 from . import adapters
+from .config import MinioConfig, RedisConfig, load_dotenv
 from .interfaces import (
    ConnectionAwareInterface,
    ContextAwareInterface,
@@ -22,7 +23,10 @@ __all__ = [
    "ConnectionAwareInterface",
    "ContextAwareInterface",
    "JsonRepositoryInterface",
+    "MinioConfig",
    "ObjectRepositoryInterface",
+    "RedisConfig",
+    "load_dotenv",
    *adapters.__all__,
 ]

@@ -0,0 +1,102 @@
+"""Shared connection lifecycle behavior for repository adapters."""
+
+from __future__ import annotations
+
+import time
+from abc import abstractmethod
+from typing import Self
+
+import structlog
+
+from python_repositories.interfaces import (
+    ConnectionAwareInterface,
+    ContextAwareInterface,
+)
+
+
+class ConnectionAwareAdapter(ConnectionAwareInterface, ContextAwareInterface):
+    """Base adapter with context-manager and TTL-cached connection health checks."""
+
+    health_check_ttl_seconds: float = 1.0
+    connection_name: str = ""
+
+    def __init__(self) -> None:
+        self.logger = structlog.get_logger(self.__class__.__name__)
+        self._client_injected = False
+        self._health_check_at: float | None = None
+        self._health_check_ok: bool = False
+
+    def __enter__(self) -> Self:
+        """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 _invalidate_health_cache(self) -> None:
+        self._health_check_at = None
+        self._health_check_ok = False
+
+    @abstractmethod
+    def _is_client_ready(self) -> bool:
+        """Return True when internal state is sufficient for a probe."""
+
+    @abstractmethod
+    def _probe_connection(self) -> bool:
+        """Backend-specific liveness check; called only when client is ready."""
+
+    @abstractmethod
+    def _validate_injected_client(self) -> None:
+        """Verify an injected client is reachable; raise ConnectionError on failure."""
+
+    @abstractmethod
+    def _establish_connection(self) -> None:
+        """Create a backend client and set internal connection state."""
+
+    def connect(self) -> None:
+        """Connect to the backend; idempotent when already connected and healthy."""
+        if self._client_injected:
+            self._validate_injected_client()
+            self._invalidate_health_cache()
+            return
+        if self._is_client_ready() and self.is_connected():
+            self.logger.info(f"Already connected to {self.connection_name}")
+            return
+        self.disconnect()
+        self._establish_connection()
+        self._invalidate_health_cache()
+
+    def is_connected(self) -> bool:
+        """Check if connected to the backend."""
+        if not self._is_client_ready():
+            return False
+        now = time.monotonic()
+        if self._health_check_at is not None:
+            seconds_since_last_health_check = now - self._health_check_at
+            cache_is_fresh = (
+                seconds_since_last_health_check < self.health_check_ttl_seconds
+            )
+            if cache_is_fresh:
+                return self._health_check_ok
+        result = self._probe_connection()
+        self._health_check_at = now
+        self._health_check_ok = result
+        self.logger.debug("Connection status", connected=result)
+        return result
+
+    def _require_connected(self) -> None:
+        if not self.is_connected():
+            raise ConnectionError(f"Not connected to {self.connection_name}")
@@ -1,17 +1,13 @@
 """Definition of MinioAdapter class."""

 from __future__ import annotations
-import os
 from io import BytesIO
-from typing import Self
-import structlog
-from python_utils import check_env

-from python_repositories.interfaces import (
-    ConnectionAwareInterface,
-    ContextAwareInterface,
-    ObjectRepositoryInterface,
+from python_repositories.adapters.connection_aware_adapter import (
+    ConnectionAwareAdapter,
 )
+from python_repositories.config import MinioConfig
+from python_repositories.interfaces import ObjectRepositoryInterface

 try:
    import minio
@@ -22,102 +18,94 @@ except ImportError as exc:
    ) from exc


-class MinioAdapter(
-    ObjectRepositoryInterface,
-    ContextAwareInterface,
-    ConnectionAwareInterface,
-):
+class MinioAdapter(ObjectRepositoryInterface, ConnectionAwareAdapter):
    """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"
+    secure_env_var_name: str = "MINIO_SECURE"
+    create_bucket_if_missing_env_var_name: str = "MINIO_CREATE_BUCKET_IF_MISSING"
    chunk_size: int = 5 * 2**20  # 5 MiB
+    connection_name: str = "Minio"

-    def __init__(self) -> None:
-        # Setup logger
-        self.logger = structlog.get_logger(
-            self.__class__.__name__,
-        )
-        # Check environment variables
-        check_env(
-            {
+    def __init__(
+        self,
+        *,
+        config: MinioConfig | None = None,
+        client: minio.Minio | None = None,
+    ) -> None:
+        super().__init__()
+        if client is not None and config is None:
+            raise ValueError("config is required when client is provided")
+        if config is None:
+            config = MinioConfig.from_env(
                self.endpoint_env_var_name,
                self.access_key_env_var_name,
                self.secret_key_env_var_name,
                self.bucket_env_var_name,
-            },
+                self.secure_env_var_name,
+                self.create_bucket_if_missing_env_var_name,
            )
-        # Prepare internal variables
-        self._client: minio.Minio | None = None
-        self._bucket_name: str | None = None
+        self._config = config
+        self._client_injected = client is not None
+        self._client: minio.Minio | None = client
+        self._bucket_name: str | None = config.bucket if client is not None else None
+        if self._client_injected:
+            self._invalidate_health_cache()

-    def __enter__(self) -> Self:
-        """Enter the context."""
-        self.connect()
-        return self
+    def _is_client_ready(self) -> bool:
+        return self._client is not None and self._bucket_name is not None

-    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")
+    def _validate_injected_client(self) -> None:
+        if self._client is None:
            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
+        try:
+            _ = self._client.list_buckets()
+        except Exception as exc:  # pylint: disable=broad-except
+            raise ConnectionError(
+                f"Could not connect to Minio at {self._config.endpoint}"
+            ) from exc
+
+    def _establish_connection(self) -> None:
+        endpoint = self._config.endpoint
+        access_key = self._config.access_key
+        secret_key = self._config.secret_key
+        bucket = self._config.bucket
        client = minio.Minio(
            endpoint=endpoint,
            access_key=access_key,
            secret_key=secret_key,
-            secure=False,
+            secure=self._config.secure,
        )
-        # 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):
+            if not self._config.create_bucket_if_missing:
+                raise ConnectionError(
+                    f"Bucket '{bucket}' does not exist on Minio at {endpoint}"
+                )
            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
+        # N.B. Minio client does not have a close method, but we include this for symmetry
        self._client = None
        self._bucket_name = None
+        self._invalidate_health_cache()

-    @property
-    def is_connected(self) -> bool:
-        """Check if connected to Minio server."""
-        res = self._client is not None
-        self.logger.debug(res)
-        return res
+    def _probe_connection(self) -> bool:
+        assert self._client is not None and self._bucket_name is not None
+        try:
+            return bool(self._client.bucket_exists(self._bucket_name))
+        except Exception:  # pylint: disable=broad-except
+            return False

    def put(
        self,
@@ -134,8 +122,8 @@ class MinioAdapter(
        if not isinstance(content_type, str) or len(content_type) == 0:
            raise ValueError("content_type must be a non-empty string")
        # Check connection
-        if self._client is None or self._bucket_name is None or not self.is_connected:
-            raise ConnectionError("Not connected to Minio")
+        self._require_connected()
+        assert self._client is not None and self._bucket_name is not None
        # Prepare buffer for reading
        num_bytes = data.getbuffer().nbytes
        data.seek(0)
@@ -159,10 +147,11 @@ class MinioAdapter(
        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 self._bucket_name is None or not self.is_connected:
-            raise ConnectionError("Not connected to Minio")
+        self._require_connected()
+        assert self._client is not None and self._bucket_name is not None
        # Get data from bucket
        # N.B. bucket name is set when connecting
+        response = None
        try:
            response = self._client.get_object(
                bucket_name=self._bucket_name,
@@ -182,11 +171,12 @@ class MinioAdapter(
                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
+            raise
+        finally:
+            if response is not None:
+                response.close()
+                response.release_conn()

    def delete(self, object_name: str) -> None:
        """Delete an object from the Minio bucket."""
@@ -194,8 +184,8 @@ class MinioAdapter(
        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 self._bucket_name is None or not self.is_connected:
-            raise ConnectionError("Not connected to Minio")
+        self._require_connected()
+        assert self._client is not None and self._bucket_name is not None
        # Delete object from bucket
        # N.B. bucket name is set when connecting
        self._client.remove_object(
@@ -213,8 +203,8 @@ class MinioAdapter(
            raise ValueError("prefix must be a string")
        # Check connection
        # N.B. bucket name is set when connecting
-        if self._client is None or self._bucket_name is None or not self.is_connected:
-            raise ConnectionError("Not connected to Minio")
+        self._require_connected()
+        assert self._client is not None and self._bucket_name is not None
        # List objects in bucket
        objects = self._client.list_objects(
            bucket_name=self._bucket_name,
@@ -1,17 +1,14 @@
 """Definition of RedisAdapter class."""

 from __future__ import annotations
-from typing import Self, cast
-import os
-import structlog
+from collections.abc import Iterator
+from typing import Any, cast

-from python_utils import check_env
-
-from python_repositories.interfaces import (
-    ConnectionAwareInterface,
-    ContextAwareInterface,
-    JsonRepositoryInterface,
+from python_repositories.adapters.connection_aware_adapter import (
+    ConnectionAwareAdapter,
 )
+from python_repositories.config import RedisConfig
+from python_repositories.interfaces import JsonRepositoryInterface

 try:
    import redis
@@ -23,53 +20,50 @@ except ImportError as exc:
    ) from exc


-class RedisAdapter(
-    JsonRepositoryInterface,
-    ContextAwareInterface,
-    ConnectionAwareInterface,
-):
+class RedisAdapter(JsonRepositoryInterface, ConnectionAwareAdapter):
    """Redis adapter exposing basic CRUD functionality."""

    uri_env_var_name: str = "REDIS_URI"
    path: str = "."  # JSON root path, updated in __init__
    encoding: str = "UTF-8"
+    connection_name: str = "Redis"

-    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
-        self.path: str = RedisPath.root_path()
-
-    def __enter__(self) -> Self:
-        """Enter the context."""
-        self.connect()
-        return self
-
-    def __exit__(
-        self, exc_type: type | None, exc_val: object | None, exc_tb: object | None
+    def __init__(
+        self,
+        *,
+        config: RedisConfig | None = None,
+        client: redis.Redis | None = 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()
+        super().__init__()
+        if client is not None and config is None:
+            raise ValueError("config is required when client is provided")
+        if config is None:
+            config = RedisConfig.from_env(self.uri_env_var_name)
+        self._config = config
+        self._client_injected = client is not None
+        self._client: redis.Redis | None = client
+        self.path: str = RedisPath.root_path()
+        if self._client_injected:
+            self._invalidate_health_cache()

-    def connect(self) -> None:
-        """Connect to the Redis server."""
-        # Prepare arguments
-        uri = str(os.getenv(self.uri_env_var_name))
-        # Connect client
+    def _is_client_ready(self) -> bool:
+        return self._client is not None
+
+    def _validate_injected_client(self) -> None:
+        if self._client is None:
+            return
+        try:
+            if not self._client.ping():
+                raise ConnectionError(
+                    f"Could not connect to Redis at {self._config.uri}"
+                )
+        except (redis.ConnectionError, redis.TimeoutError) as exc:
+            raise ConnectionError(
+                f"Could not connect to Redis at {self._config.uri}"
+            ) from exc
+
+    def _establish_connection(self) -> None:
+        uri = self._config.uri
        try:
            client = redis.Redis.from_url(
                url=uri,
@@ -79,25 +73,23 @@ class RedisAdapter(
                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:
+        if self._client is not None and not self._client_injected:
            self._client.close()
-        # Reset client
        self._client = None
+        self._invalidate_health_cache()

-    @property
-    def is_connected(self) -> bool:
-        """Check if connected to Redis server."""
-        res = self._client is not None
-        self.logger.debug(res)
-        return res
+    def _probe_connection(self) -> bool:
+        assert self._client is not None
+        try:
+            return bool(self._client.ping())
+        except (redis.ConnectionError, redis.TimeoutError):
+            return False

-    def set(self, key: str, data: dict) -> None:
+    def set(self, key: str, data: dict[str, Any]) -> None:
        """Set a JSON object in Redis."""
        # Check input
        if not isinstance(key, str) or len(key) == 0:
@@ -105,23 +97,23 @@ class RedisAdapter(
        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")
+        self._require_connected()
+        assert self._client is not None
        # 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:
+    def get(self, key: str) -> dict[str, Any] | 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")
+        self._require_connected()
+        assert self._client is not None
        # Get data
        data = cast(
-            dict | None,
+            dict[str, Any] | None,
            self._client.json().get(key),
        )
        self.logger.debug(f"Got {data} from {key}")
@@ -133,20 +125,22 @@ class RedisAdapter(
        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")
+        self._require_connected()
+        assert self._client is not None
        # 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
+    def _validate_pattern(self, pattern: str) -> None:
        if not isinstance(pattern, str) or len(pattern) == 0:
            raise ValueError("Pattern must be a non-empty string")
+
+    def list_keys(self, pattern: str) -> list[str]:
+        """List keys in Redis using KEYS; may block on large datasets."""
+        self._validate_pattern(pattern)
        # Check connection
-        if self._client is None or not self.is_connected:
-            raise ConnectionError("Not connected to Redis")
+        self._require_connected()
+        assert self._client is not None
        # List keys
        keys_raw = cast(
            list[bytes],
@@ -155,3 +149,29 @@ class RedisAdapter(
        keys: list[str] = [key.decode(self.encoding) for key in keys_raw]
        self.logger.debug(f"Got {keys} matching {pattern}")
        return keys
+
+    def scan_keys(
+        self,
+        pattern: str,
+        *,
+        count: int | None = None,
+    ) -> Iterator[str]:
+        """Yield keys in Redis using SCAN to avoid blocking large datasets."""
+        self._validate_pattern(pattern)
+        self._require_connected()
+        assert self._client is not None
+        client = self._client
+
+        def _decode(key: bytes | str) -> str:
+            return key if isinstance(key, str) else key.decode(self.encoding)
+
+        def _iter() -> Iterator[str]:
+            scan_iter = (
+                client.scan_iter(match=pattern, count=count)
+                if count is not None
+                else client.scan_iter(match=pattern)
+            )
+            for key_raw in scan_iter:
+                yield _decode(key_raw)
+
+        return _iter()
@@ -0,0 +1,9 @@
+from .dotenv_loader import load_dotenv as load_dotenv
+from .minio_config import MinioConfig as MinioConfig
+from .redis_config import RedisConfig as RedisConfig
+
+__all__ = [
+    "MinioConfig",
+    "RedisConfig",
+    "load_dotenv",
+]
@@ -0,0 +1,14 @@
+"""Load environment variables from a .env file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from dotenv import load_dotenv as _load_dotenv
+
+
+def load_dotenv(path: str | Path | None = None) -> bool:
+    """Load .env into os.environ. Idempotent; returns True if a file was loaded."""
+    if path is None:
+        return bool(_load_dotenv())
+    return bool(_load_dotenv(path))
@@ -0,0 +1,21 @@
+"""Parse boolean values from environment variables."""
+
+from __future__ import annotations
+
+import os
+
+_TRUTHY = frozenset({"1", "true", "yes", "on"})
+_FALSY = frozenset({"0", "false", "no", "off"})
+
+
+def env_bool(name: str, default: bool) -> bool:
+    """Parse an environment variable as a boolean value."""
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    normalized = raw.strip().lower()
+    if normalized in _TRUTHY:
+        return True
+    if normalized in _FALSY:
+        return False
+    raise ValueError(f"Invalid boolean value for {name}: {raw!r}")
@@ -0,0 +1,57 @@
+"""MinIO connection configuration."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from python_utils import check_env
+
+from python_repositories.config.dotenv_loader import load_dotenv
+from python_repositories.config.env_bool import env_bool
+
+
+@dataclass(frozen=True)
+class MinioConfig:
+    """Configuration for connecting to MinIO."""
+
+    endpoint: str
+    access_key: str
+    secret_key: str
+    bucket: str
+    secure: bool = True
+    create_bucket_if_missing: bool = False
+
+    @classmethod
+    def from_env(
+        cls,
+        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",
+        secure_env_var_name: str = "MINIO_SECURE",
+        create_bucket_if_missing_env_var_name: str = ("MINIO_CREATE_BUCKET_IF_MISSING"),
+        *,
+        use_dotenv: bool = True,
+    ) -> MinioConfig:
+        """Load configuration from environment variables."""
+        if use_dotenv:
+            load_dotenv()
+        env_var_names = {
+            endpoint_env_var_name,
+            access_key_env_var_name,
+            secret_key_env_var_name,
+            bucket_env_var_name,
+        }
+        check_env(env_var_names)
+        return cls(
+            endpoint=str(os.getenv(endpoint_env_var_name)),
+            access_key=str(os.getenv(access_key_env_var_name)),
+            secret_key=str(os.getenv(secret_key_env_var_name)),
+            bucket=str(os.getenv(bucket_env_var_name)),
+            secure=env_bool(secure_env_var_name, default=True),
+            create_bucket_if_missing=env_bool(
+                create_bucket_if_missing_env_var_name,
+                default=False,
+            ),
+        )
@@ -0,0 +1,30 @@
+"""Redis connection configuration."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from python_utils import check_env
+
+from python_repositories.config.dotenv_loader import load_dotenv
+
+
+@dataclass(frozen=True)
+class RedisConfig:
+    """Configuration for connecting to Redis."""
+
+    uri: str
+
+    @classmethod
+    def from_env(
+        cls,
+        uri_env_var_name: str = "REDIS_URI",
+        *,
+        use_dotenv: bool = True,
+    ) -> RedisConfig:
+        """Load configuration from environment variables."""
+        if use_dotenv:
+            load_dotenv()
+        check_env(uri_env_var_name)
+        return cls(uri=str(os.getenv(uri_env_var_name)))
@@ -1,5 +1,7 @@
 """Example domain repository backed by Redis JSON."""

+from typing import Any
+
 from python_repositories.adapters.redis_adapter import RedisAdapter


@@ -9,10 +11,10 @@ class UserJsonRepository(RedisAdapter):
    def _key(self, user_id: str) -> str:
        return f"user:{user_id}"

-    def get_user(self, user_id: str) -> dict | None:
+    def get_user(self, user_id: str) -> dict[str, Any] | None:
        return self.get(self._key(user_id))

-    def save_user(self, user_id: str, user: dict) -> None:
+    def save_user(self, user_id: str, user: dict[str, Any]) -> None:
        self.set(self._key(user_id), user)

    def delete_user(self, user_id: str) -> None:
@@ -8,7 +8,11 @@ class ConnectionAwareInterface(ABC):

    @abstractmethod
    def connect(self) -> None:
-        """Connect to resource."""
+        """Connect to resource.
+
+        Implementations should be idempotent: calling connect while already
+        connected and healthy is a no-op.
+        """
        ...

    @abstractmethod
@@ -16,8 +20,10 @@ class ConnectionAwareInterface(ABC):
        """Disconnect from resource."""
        ...

-    @property
    @abstractmethod
    def is_connected(self) -> bool:
-        """Check if connected to resource."""
+        """Return whether the adapter has an active, reachable connection.
+
+        Implementations may perform a cached network probe to verify liveness.
+        """
        ...
@@ -1,18 +1,20 @@
 """Definition of JsonRepositoryInterface abstract base class."""

+from collections.abc import Iterator
 from abc import ABC, abstractmethod
+from typing import Any


 class JsonRepositoryInterface(ABC):
    """Interface that defines JSON document CRUD methods."""

    @abstractmethod
-    def get(self, key: str) -> dict | None:
+    def get(self, key: str) -> dict[str, Any] | None:
        """Get a JSON object by key."""
        ...

    @abstractmethod
-    def set(self, key: str, data: dict) -> None:
+    def set(self, key: str, data: dict[str, Any]) -> None:
        """Set a JSON object by key."""
        ...

@@ -25,3 +27,13 @@ class JsonRepositoryInterface(ABC):
    def list_keys(self, pattern: str) -> list[str]:
        """List keys matching a glob pattern."""
        ...
+
+    def scan_keys(
+        self,
+        pattern: str,
+        *,
+        count: int | None = None,
+    ) -> Iterator[str]:
+        """Yield keys matching a glob pattern incrementally."""
+        del count
+        yield from self.list_keys(pattern)
@@ -9,7 +9,11 @@ class ObjectRepositoryInterface(ABC):

    @abstractmethod
    def get(self, object_name: str) -> BytesIO | None:
-        """Get an object by name."""
+        """Get an object by name.
+
+        Returns None when the object does not exist. Raises ConnectionError when
+        not connected. Other backend errors propagate to the caller.
+        """
        ...

    @abstractmethod
@@ -28,10 +28,17 @@ fi

 set_pyproject_version "$VERSION"

+if command -v uv >/dev/null 2>&1; then
+  uv lock
+else
+  echo "uv not found; uv.lock was not updated" >&2
+  exit 1
+fi
+
 if [[ -n "${GITHUB_OUTPUT:-}" ]]; then
  echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
 else
  echo "version=${VERSION}"
 fi

-echo "Updated pyproject.toml to version ${VERSION}" >&2
+echo "Updated pyproject.toml and uv.lock to version ${VERSION}" >&2
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Fetch the current PR title from the Gitea API.
+# Requires: API_URL, REPO_OWNER, REPO_NAME, PR_NUMBER, CI_RUNNER_TOKEN
+
+: "${API_URL:?API_URL is required}"
+: "${REPO_OWNER:?REPO_OWNER is required}"
+: "${REPO_NAME:?REPO_NAME is required}"
+: "${PR_NUMBER:?PR_NUMBER is required}"
+: "${CI_RUNNER_TOKEN:?CI_RUNNER_TOKEN is required}"
+
+curl -sf \
+  "${API_URL}/repos/${REPO_OWNER}/${REPO_NAME}/pulls/${PR_NUMBER}" \
+  -H "Authorization: token ${CI_RUNNER_TOKEN}" \
+  | python3 -c 'import json, sys; print(json.load(sys.stdin)["title"])'
@@ -0,0 +1,12 @@
+"""Shared test configuration constants."""
+
+from python_repositories.config import MinioConfig, RedisConfig
+
+TEST_REDIS_CONFIG = RedisConfig(uri="redis://localhost:6379")
+TEST_MINIO_CONFIG = MinioConfig(
+    endpoint="localhost:9000",
+    access_key="minioadmin",
+    secret_key="minioadmin",
+    bucket="test-bucket",
+    secure=False,
+)
@@ -1,28 +1,56 @@
 """Integration tests configuration."""

 import logging
-import os
 from collections.abc import Generator
+from typing import Any, cast

 import pytest
 import redis
 import structlog
 from minio import Minio
+from testcontainers.core.container import DockerContainer
+from testcontainers.core.waiting_utils import WaitStrategy, WaitStrategyTarget
 from testcontainers.minio import MinioContainer

-from tests.integration.redis_container_test import REDIS_PORT, RedisTestContainer
+from python_repositories.config import MinioConfig, RedisConfig

-collect_ignore = ["redis_container_test.py"]
+REDIS_PORT = 6379

 MINIO_ACCESS_KEY = "minioadmin"
 MINIO_SECRET_KEY = "minioadmin"
 MINIO_BUCKET = "test-bucket"


+class _RedisPingWaitStrategy(WaitStrategy):
+    def __init__(self) -> None:
+        super().__init__()
+        self.with_transient_exceptions(redis.exceptions.ConnectionError)
+
+    def wait_until_ready(self, container: WaitStrategyTarget) -> None:
+        redis_container = cast("RedisTestContainer", container)
+        if not self._poll(lambda: redis_container.get_client().ping()):
+            raise redis.exceptions.ConnectionError("Could not connect to Redis")
+
+
+class RedisTestContainer(DockerContainer):
+    """Redis container using wait strategies instead of the deprecated decorator."""
+
+    def __init__(self, image: str, port: int = REDIS_PORT) -> None:
+        super().__init__(image, _wait_strategy=_RedisPingWaitStrategy())
+        self.port = port
+        self.with_exposed_ports(self.port)
+
+    def get_client(self, **kwargs: Any) -> redis.Redis:
+        return redis.Redis(
+            host=self.get_container_host_ip(),
+            port=self.get_exposed_port(self.port),
+            **kwargs,
+        )
+
+
@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,
@@ -35,40 +63,34 @@ def configure_logging() -> None:
        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, None, None]:
    """Set up a Redis container for testing and yield the Redis URI."""
-    # Start container
    container = RedisTestContainer(
        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(REDIS_PORT)
    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], None, None]:
-    """Set up a Minio container for testing and yield the Minio URI."""
-    # Start container
+    """Set up a Minio container for testing and yield connection settings."""
    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}"
@@ -77,38 +99,35 @@ def minio_container() -> Generator[dict[str, str], None, None]:
        "MINIO_ACCESS_KEY": MINIO_ACCESS_KEY,
        "MINIO_SECRET_KEY": MINIO_SECRET_KEY,
        "MINIO_BUCKET": MINIO_BUCKET,
+        "MINIO_SECURE": "false",
    }

    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], None, None]:
-    """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
+@pytest.fixture(scope="session")
+def redis_config(redis_container: str) -> RedisConfig:
+    """Provide RedisConfig built from the test container."""
+    return RedisConfig(uri=redis_container)

-    yield env_vars

-    # Cleanup
-    for key in env_vars:
-        _ = os.environ.pop(key, default=None)
+@pytest.fixture(scope="session")
+def minio_config(minio_container: dict[str, str]) -> MinioConfig:
+    """Provide MinioConfig built from the test container."""
+    return MinioConfig(
+        endpoint=minio_container["MINIO_ENDPOINT"],
+        access_key=minio_container["MINIO_ACCESS_KEY"],
+        secret_key=minio_container["MINIO_SECRET_KEY"],
+        bucket=minio_container["MINIO_BUCKET"],
+        secure=False,
+    )


@pytest.fixture(scope="session")
 def raw_redis_client(redis_container: str) -> Generator[redis.Redis, None, None]:
    """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,
@@ -116,7 +135,6 @@ def raw_redis_client(redis_container: str) -> Generator[redis.Redis, None, None]

    yield client

-    # Cleanup
    client.flushall()
    client.close()

@@ -124,21 +142,18 @@ def raw_redis_client(redis_container: str) -> Generator[redis.Redis, None, None]
@pytest.fixture(scope="session")
 def raw_minio_client(minio_container: dict[str, str]) -> Generator[Minio, None, None]:
    """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)
@@ -2,29 +2,49 @@

 from collections.abc import Generator
 from io import BytesIO
+import os
 import random

 import pytest
+from minio import Minio
+
 from python_repositories.examples.artifact_object_repository import (
    ArtifactObjectRepository,
 )
 from python_repositories.examples.user_json_repository import UserJsonRepository

+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture(scope="module", autouse=True)
+def set_example_env(
+    redis_container: str,
+    minio_container: dict[str, str],
+    raw_minio_client: Minio,
+) -> Generator[None, None, None]:
+    """Set env vars so example repositories can use from_env() defaults."""
+    _ = raw_minio_client
+    env_vars = {"REDIS_URI": redis_container, **minio_container}
+    for key, value in env_vars.items():
+        os.environ[key] = value
+    yield
+    for key in env_vars:
+        _ = os.environ.pop(key, default=None)
+

@pytest.fixture(scope="module")
-def user_data() -> Generator[dict[str, str]]:
+def user_data() -> Generator[dict[str, str], None, None]:
    """Provide sample user data for tests."""
    yield {"name": "Alice", "email": "[email protected]"}


@pytest.fixture(scope="module")
-def artifact_data() -> Generator[BytesIO]:
+def artifact_data() -> Generator[BytesIO, None, None]:
    """Provide sample artifact data for tests."""
    yield BytesIO(random.randbytes(2**20))


 def test_user_json_repository_save_and_get(
-    redis_container: str,
    user_data: dict[str, str],
 ) -> None:
    """Test that UserJsonRepository can save and retrieve a user."""
@@ -34,7 +54,6 @@ def test_user_json_repository_save_and_get(


 def test_user_json_repository_delete(
-    redis_container: str,
    user_data: dict[str, str],
 ) -> None:
    """Test that UserJsonRepository can delete a user."""
@@ -45,7 +64,6 @@ def test_user_json_repository_delete(


 def test_artifact_object_repository_store_and_get(
-    minio_container: dict[str, str],
    artifact_data: BytesIO,
 ) -> None:
    """Test that ArtifactObjectRepository can store and retrieve an artifact."""
@@ -1,17 +1,21 @@
 """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
+from dataclasses import replace
 import logging
-from minio import S3Error
+import random
+from io import BytesIO
+from unittest.mock import MagicMock
+
+import pytest
+from minio import Minio, S3Error
 from urllib3.response import BaseHTTPResponse
+
 from python_repositories.adapters.minio_adapter import MinioAdapter
-from python_repositories.interfaces import ObjectRepositoryInterface
+from python_repositories.config import MinioConfig
+from tests.conftest import TEST_MINIO_CONFIG
+
+pytestmark = pytest.mark.integration


 def same_data(
@@ -19,15 +23,10 @@ def same_data(
    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",
@@ -35,7 +34,6 @@ def same_data(
            len(data_b_bytes),
        )
        return False
-    # compare content
    if data_a_bytes != data_b_bytes:
        logging.error("data has different bytes")
        return False
@@ -45,20 +43,19 @@ def same_data(
@pytest.fixture(scope="module")
 def data() -> Generator[BytesIO, None, None]:
    """Provide a sample data bytes for tests."""
-    # Generate random bytes
-    random_bytes = random.randbytes(2**21)  # 2 MiB
+    random_bytes = random.randbytes(2**21)
    yield BytesIO(random_bytes)


@pytest.fixture(scope="function")
 def data_in_minio(
    raw_minio_client: Minio,
+    minio_config: MinioConfig,
    data: BytesIO,
 ) -> Generator[tuple[str, BytesIO], None, None]:
    """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
+    bucket_name = minio_config.bucket
    num_bytes = data.getbuffer().nbytes
    data.seek(0)
    raw_minio_client.put_object(
@@ -68,19 +65,17 @@ def data_in_minio(
        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, None, None]:
+def minio_adapter(minio_config: MinioConfig) -> Generator[MinioAdapter, None, None]:
    """Fixture to provide a connected MinioAdapter instance."""
-    adapter = MinioAdapter()
+    adapter = MinioAdapter(config=minio_config)
    adapter.connect()
    yield adapter
    adapter.disconnect()
@@ -89,10 +84,10 @@ def minio_adapter() -> Generator[MinioAdapter, None, None]:
@pytest.fixture(scope="function", autouse=True)
 def clear_minio(
    raw_minio_client: Minio,
+    minio_config: MinioConfig,
 ) -> None:
    """Fixture to clear all Minio objects before each test."""
-    bucket_name = str(os.getenv("MINIO_BUCKET"))
-    # Clear all objects before each test
+    bucket_name = minio_config.bucket
    objects = raw_minio_client.list_objects(bucket_name, recursive=True)
    for obj in objects:
        if not obj.object_name:
@@ -100,24 +95,6 @@ def clear_minio(
        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."""
-    assert issubclass(MinioAdapter, ObjectRepositoryInterface)
-    _ = 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,
@@ -128,52 +105,71 @@ def test_should_log_info_when_already_connected(
    assert "Already connected to Minio" in caplog.text


-def test_should_raise_connection_error_when_unable_to_connect(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
+def test_should_raise_connection_error_when_unable_to_connect() -> None:
    """Test that the MinioAdapter raises a ConnectionError when unable to connect."""
-    # Arrange
-    monkeypatch.setenv("MINIO_ENDPOINT", "invalid_uri")
-    adapter = MinioAdapter()
+    config = MinioConfig(
+        endpoint="invalid_uri",
+        access_key="minioadmin",
+        secret_key="minioadmin",
+        bucket="test-bucket",
+    )
+    adapter = MinioAdapter(config=config)
    with pytest.raises(ConnectionError):
        adapter.connect()
-    assert not adapter.is_connected
+    assert not adapter.is_connected()


-def test_should_log_info_when_creating_expected_bucket(
+def test_connect_raises_when_bucket_missing(
    raw_minio_client: Minio,
+    minio_config: MinioConfig,
+) -> None:
+    """Test that connect fails when the configured bucket is missing."""
+    bucket_name = minio_config.bucket
+    raw_minio_client.remove_bucket(bucket_name)
+    adapter = MinioAdapter(config=minio_config)
+
+    try:
+        with pytest.raises(ConnectionError, match="does not exist"):
+            adapter.connect()
+        assert not adapter.is_connected()
+    finally:
+        raw_minio_client.make_bucket(bucket_name)
+
+
+def test_connect_creates_bucket_when_create_bucket_if_missing_enabled(
+    raw_minio_client: Minio,
+    minio_config: MinioConfig,
    caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """Test that the MinioAdapter logs info when creating the expected bucket."""
-    # Arrange
-    bucket_name = str(os.getenv("MINIO_BUCKET"))
+    """Test that connect can create the configured bucket when enabled."""
+    bucket_name = minio_config.bucket
    raw_minio_client.remove_bucket(bucket_name)
-    adapter = MinioAdapter()
-    # Act
+    config = replace(minio_config, create_bucket_if_missing=True)
+    adapter = MinioAdapter(config=config)
+
    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],
+    minio_config: MinioConfig,
    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
+        with MinioAdapter(config=minio_config) as adapter:
+            assert adapter.is_connected()
            raise ValueError("Simulated error")
    except ValueError:
-        pass  # Expected
-    # Assert error was logged
+        pass
    assert "Error while exiting context" in caplog.text


-def test_should_have_context_manager() -> None:
+def test_should_have_context_manager(minio_config: MinioConfig) -> None:
    """Test that the MinioAdapter can be used as a context manager."""
-    with MinioAdapter() as adapter:
+    with MinioAdapter(config=minio_config) as adapter:
        assert adapter._client is not None
    assert adapter._client is None

@@ -183,11 +179,8 @@ def test_should_get_data(
    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)

@@ -196,11 +189,7 @@ 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
+    received_data = minio_adapter.get("nonexistent_object")
    assert received_data is None


@@ -208,21 +197,17 @@ 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,
+    minio_config: MinioConfig,
 ) -> None:
    """Test that the MinioAdapter raises ConnectionError when getting while not connected."""
-    # Arrange
-    adapter = MinioAdapter()  # not connected
-    # Act & Assert
+    adapter = MinioAdapter(config=minio_config)
    with pytest.raises(ConnectionError):
        adapter.get("some_object")

@@ -231,10 +216,9 @@ 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(
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    mock_client.get_object.side_effect = S3Error(
        MagicMock(spec=BaseHTTPResponse),
        "NoSuchKey",
        "",
@@ -244,12 +228,10 @@ def test_should_log_warning_when_getting_nonexistent_object(
        bucket_name="test-bucket",
        object_name="missing-object",
    )
-    adapter._bucket_name = "test-bucket"
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
    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}'"
@@ -257,13 +239,10 @@ def test_should_log_warning_when_getting_nonexistent_object(
    )


-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)
+def test_should_reraise_s3error_other_than_no_such_key() -> None:
+    """Test that the MinioAdapter re-raises unhandled S3 errors."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
    other_s3error = S3Error(
        MagicMock(spec=BaseHTTPResponse),
        "UnhandledError",
@@ -274,54 +253,38 @@ def test_should_log_error_when_getting_with_s3error_other_than_no_such_key(
        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
+    mock_client.get_object.side_effect = other_s3error
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+    with pytest.raises(S3Error) as exc_info:
+        adapter.get("missing-object")
+    assert exc_info.value.code == "UnhandledError"


-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)
+def test_should_reraise_general_exception() -> None:
+    """Test that the MinioAdapter re-raises general exceptions during get."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
    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
+    mock_client.get_object.side_effect = general_exception
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+    with pytest.raises(Exception, match="General failure"):
+        adapter.get("missing-object")


 def test_should_put_data(
    data: BytesIO,
    minio_adapter: MinioAdapter,
+    minio_config: MinioConfig,
 ) -> 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
+    assert received_data is None
    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
+    minio_adapter._client.remove_object(minio_config.bucket, object_name)  # type: ignore[union-attr]


 def test_should_update_data(
@@ -329,15 +292,12 @@ def test_should_update_data(
    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
+    new_data = BytesIO(random.randbytes(2**21))
    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)
@@ -348,9 +308,7 @@ def test_should_raise_value_error_on_invalid_put_object_name(
    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
@@ -360,13 +318,11 @@ 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:
+    for invalid in invalid_data:
        with pytest.raises(ValueError):
-            minio_adapter.put(object_name, data)  # type: ignore
+            minio_adapter.put(object_name, invalid)  # type: ignore


 def test_should_raise_value_error_on_invalid_put_content_type(
@@ -374,23 +330,19 @@ def test_should_raise_value_error_on_invalid_put_content_type(
    minio_adapter: MinioAdapter,
 ) -> None:
    """Test that the MinioAdapter raises ValueError when putting with an invalid content type."""
-    # Arrange
    object_name = "valid_object_name"
    invalid_content_types = ["", 123, None]
-    # Act & Assert
    for content_type in invalid_content_types:
        with pytest.raises(ValueError):
            minio_adapter.put(object_name, data, content_type)  # type: ignore


 def test_should_raise_connection_error_on_put_when_not_connected(
+    minio_config: MinioConfig,
    data: BytesIO,
-    minio_adapter: MinioAdapter,
 ) -> None:
    """Test that the MinioAdapter raises ConnectionError when putting while not connected."""
-    # Arrange
-    adapter = MinioAdapter()  # not connected
-    # Act & Assert
+    adapter = MinioAdapter(config=minio_config)
    with pytest.raises(ConnectionError):
        adapter.put("some_object", data)

@@ -400,36 +352,28 @@ def test_should_delete_object(
    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
+    assert received_data is not None
    minio_adapter.delete(object_name)
-    # Assert
-    received_data = minio_adapter.get(object_name)
-    assert received_data is None
+    assert minio_adapter.get(object_name) 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,
+    minio_config: MinioConfig,
 ) -> None:
    """Test that the MinioAdapter raises ConnectionError when deleting while not connected."""
-    # Arrange
-    adapter = MinioAdapter()  # not connected
-    # Act & Assert
+    adapter = MinioAdapter(config=minio_config)
    with pytest.raises(ConnectionError):
        adapter.delete("some_object")

@@ -439,14 +383,11 @@ def test_should_list_objects(
    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 = BytesIO(random.randbytes(2**21))
    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
@@ -458,15 +399,12 @@ def test_should_list_objects_with_prefix(
    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 = BytesIO(random.randbytes(2**21))
    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
@@ -477,25 +415,20 @@ 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,
+    minio_config: MinioConfig,
 ) -> None:
    """Test that the MinioAdapter raises ConnectionError when listing while not connected."""
-    # Arrange
-    adapter = MinioAdapter()  # not connected
-    # Act & Assert
+    adapter = MinioAdapter(config=minio_config)
    with pytest.raises(ConnectionError):
        adapter.list_objects()


-# allows local debugging by running file as script
 if __name__ == "__main__":
    pytest.main(["-s", "-v", __file__])
@@ -1,15 +1,20 @@
 """Integration tests for the RedisAdapter."""

 from collections.abc import Generator
+import logging
+
 import pytest
 import redis
 from redis.commands.json.path import Path as RedisPath
+
 from python_repositories.adapters.redis_adapter import RedisAdapter
-from python_repositories.interfaces import JsonRepositoryInterface
+from python_repositories.config import RedisConfig
+
+pytestmark = pytest.mark.integration


@pytest.fixture(scope="module")
-def data() -> Generator[dict[str, str]]:
+def data() -> Generator[dict[str, str], None, None]:
    """Provide a sample data dictionary for tests."""
    yield {"foo": "bar"}

@@ -18,7 +23,7 @@ def data() -> Generator[dict[str, str]]:
 def data_in_redis(
    raw_redis_client: redis.Redis,
    data: dict[str, str],
-) -> Generator[tuple[str, dict[str, str]]]:
+) -> Generator[tuple[str, dict[str, str]], None, None]:
    """Fixture to set up a known value in Redis before each test."""
    key = "test_key"
    path = RedisPath.root_path()
@@ -26,14 +31,13 @@ def data_in_redis(

    yield key, data

-    # Cleanup
    raw_redis_client.delete(key)


@pytest.fixture(scope="module")
-def redis_adapter(redis_container: str) -> Generator[RedisAdapter]:
+def redis_adapter(redis_config: RedisConfig) -> Generator[RedisAdapter, None, None]:
    """Fixture to provide a connected RedisAdapter instance."""
-    adapter = RedisAdapter()
+    adapter = RedisAdapter(config=redis_config)
    adapter.connect()
    yield adapter
    adapter.disconnect()
@@ -42,84 +46,63 @@ def redis_adapter(redis_container: str) -> Generator[RedisAdapter]:
@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."""
-    assert issubclass(RedisAdapter, JsonRepositoryInterface)
-    _ = 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,
+def test_should_log_info_when_already_connected(
+    redis_adapter: RedisAdapter,
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
+    """Test that the RedisAdapter logs info when connect is called while already connected."""
+    with caplog.at_level(logging.INFO):
+        redis_adapter.connect()
+    assert "Already connected to Redis" in caplog.text
+
+
+def test_should_raise_connection_error_when_unable_to_connect() -> None:
    """Test that the RedisAdapter raises ConnectionError when unable to connect."""
-    # Arrange
-    monkeypatch.setenv("REDIS_URI", "redis://invalid:6379")
-    adapter = RedisAdapter()
-    # Act & Assert
+    adapter = RedisAdapter(config=RedisConfig(uri="redis://invalid:6379"))
    with pytest.raises(ConnectionError):
        adapter.connect()
    assert adapter._client is None
-    assert not adapter.is_connected
+    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
+            return False

    monkeypatch.setattr("redis.Redis.from_url", lambda *a, **kw: MockRedis())

-    adapter = RedisAdapter()
+    adapter = RedisAdapter(config=RedisConfig(uri="redis://invalid:6379"))
    with pytest.raises(ConnectionError, match="Could not connect to Redis"):
        adapter.connect()


 def test_should_log_error_on_exception_during_exit(
-    redis_container: str,
+    redis_config: RedisConfig,
    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
+        with RedisAdapter(config=redis_config) as adapter:
+            assert adapter.is_connected()
            raise ValueError("Simulated error")
    except ValueError:
-        pass  # Expected
-    # Assert error was logged
+        pass
    assert "Error while exiting context" in caplog.text


-def test_should_have_context_manager(redis_container: str) -> None:
+def test_should_have_context_manager(redis_config: RedisConfig) -> None:
    """Test that the RedisAdapter can be used as a context manager."""
-    with RedisAdapter() as adapter:
+    with RedisAdapter(config=redis_config) as adapter:
        assert adapter._client is not None
    assert adapter._client is None

@@ -129,11 +112,8 @@ def test_should_get_value(
    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

@@ -142,9 +122,7 @@ 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


@@ -152,21 +130,17 @@ 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,
+    redis_config: RedisConfig,
 ) -> None:
    """Test that the RedisAdapter raises ConnectionError when getting while not connected."""
-    # Arrange
-    adapter = RedisAdapter()  # not connected
-    # Act & Assert
+    adapter = RedisAdapter(config=redis_config)
    with pytest.raises(ConnectionError):
        adapter.get("some_key")

@@ -176,13 +150,10 @@ def test_should_set_value(
    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
+    assert received_data is None
    redis_adapter.set(key, data)
-    # Assert
    received_data = redis_adapter.get(key)
    assert received_data is not None
    assert received_data == data
@@ -193,15 +164,12 @@ def test_should_update_value(
    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


@@ -210,9 +178,7 @@ def test_should_raise_value_error_on_invalid_set_key(
    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
@@ -222,26 +188,21 @@ 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,
+    redis_config: RedisConfig,
    data: dict[str, str],
 ) -> None:
    """Test that the RedisAdapter raises ConnectionError when setting while not connected."""
-    # Arrange
-    adapter = RedisAdapter()
-    key = "test_key"
-    # Act & Assert
+    adapter = RedisAdapter(config=redis_config)
    with pytest.raises(ConnectionError):
-        adapter.set(key, data)
+        adapter.set("test_key", data)


 def test_should_delete_key(
@@ -249,13 +210,10 @@ def test_should_delete_key(
    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
+    assert received_data is not None
    redis_adapter.delete(key)
-    # Assert
    assert redis_adapter.get(key) is None


@@ -263,21 +221,17 @@ 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,
+    redis_config: RedisConfig,
 ) -> None:
    """Test that the RedisAdapter raises ConnectionError when deleting while not connected."""
-    # Arrange
-    adapter = RedisAdapter()
-    # Act & Assert
+    adapter = RedisAdapter(config=redis_config)
    with pytest.raises(ConnectionError):
        adapter.delete("some_key")

@@ -286,12 +240,9 @@ 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"}


@@ -299,25 +250,49 @@ 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,
+    redis_config: RedisConfig,
 ) -> None:
    """Test that the RedisAdapter raises ConnectionError when listing keys while not connected."""
-    # Arrange
-    adapter = RedisAdapter()
-    # Act & Assert
+    adapter = RedisAdapter(config=redis_config)
    with pytest.raises(ConnectionError):
        adapter.list_keys("some_pattern")


-# allows local debugging by running file as script
+def test_should_scan_keys(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test scanning keys matching a pattern returns correct keys."""
+    redis_adapter.set("key1", {"a": 1})
+    redis_adapter.set("key2", {"b": 2})
+    keys = set(redis_adapter.scan_keys("key*"))
+    assert keys == {"key1", "key2"}
+
+
+def test_should_raise_value_error_on_invalid_scan_keys_pattern(
+    redis_adapter: RedisAdapter,
+) -> None:
+    """Test that the RedisAdapter raises ValueError when scanning keys with an invalid pattern."""
+    invalid_patterns = ["", 123, None]
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError):
+            list(redis_adapter.scan_keys(pattern))  # type: ignore[arg-type]
+
+
+def test_should_raise_connection_error_on_scan_keys_when_not_connected(
+    redis_config: RedisConfig,
+) -> None:
+    """Test that the RedisAdapter raises ConnectionError when scanning keys while not connected."""
+    adapter = RedisAdapter(config=redis_config)
+    with pytest.raises(ConnectionError):
+        list(adapter.scan_keys("some_pattern"))
+
+
 if __name__ == "__main__":
    pytest.main(["-s", "-v", __file__])
@@ -1,36 +0,0 @@
-"""Redis test container without testcontainers' deprecated wait decorator."""
-
-from typing import Any, cast
-
-import redis
-from testcontainers.core.container import DockerContainer
-from testcontainers.core.waiting_utils import WaitStrategy, WaitStrategyTarget
-
-REDIS_PORT = 6379
-
-
-class _RedisPingWaitStrategy(WaitStrategy):
-    def __init__(self) -> None:
-        super().__init__()
-        self.with_transient_exceptions(redis.exceptions.ConnectionError)
-
-    def wait_until_ready(self, container: WaitStrategyTarget) -> None:
-        redis_container = cast("RedisTestContainer", container)
-        if not self._poll(lambda: redis_container.get_client().ping()):
-            raise redis.exceptions.ConnectionError("Could not connect to Redis")
-
-
-class RedisTestContainer(DockerContainer):
-    """Redis container using wait strategies instead of the deprecated decorator."""
-
-    def __init__(self, image: str, port: int = REDIS_PORT) -> None:
-        super().__init__(image, _wait_strategy=_RedisPingWaitStrategy())
-        self.port = port
-        self.with_exposed_ports(self.port)
-
-    def get_client(self, **kwargs: Any) -> redis.Redis:
-        return redis.Redis(
-            host=self.get_container_host_ip(),
-            port=self.get_exposed_port(self.port),
-            **kwargs,
-        )
@@ -1,4 +1,4 @@
-"""Tests for optional dependency import behavior."""
+"""Unit tests for lazy adapter loading in adapters subpackage."""

 from __future__ import annotations

@@ -117,3 +117,24 @@ def test_adapters_subpackage_lazy_import_succeeds() -> None:
    from python_repositories.adapters import RedisAdapter

    assert RedisAdapter.__name__ == "RedisAdapter"
+
+
+def test_adapters_dir_exposes_lazy_exports() -> None:
+    """dir(adapters) includes lazy adapter names for tab completion."""
+    import python_repositories.adapters as adapters
+
+    assert {"RedisAdapter", "MinioAdapter"}.issubset(set(dir(adapters)))
+
+
+def test_adapters_getattr_raises_for_unknown() -> None:
+    """Unknown adapter names raise AttributeError."""
+    import python_repositories.adapters as adapters
+
+    with pytest.raises(AttributeError, match="has no attribute 'NoSuchAdapter'"):
+        _ = adapters.NoSuchAdapter
+
+
+def test_top_level_dir_exposes_lazy_exports() -> None:
+    """dir(python_repositories) includes lazy adapter names for tab completion."""
+    assert "RedisAdapter" in dir(python_repositories)
+    assert "MinioAdapter" in dir(python_repositories)
@@ -0,0 +1,27 @@
+"""Unit test fixtures for mocked adapters."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+import redis
+from minio import Minio
+
+from python_repositories.adapters.minio_adapter import MinioAdapter
+from python_repositories.adapters.redis_adapter import RedisAdapter
+from tests.conftest import TEST_MINIO_CONFIG, TEST_REDIS_CONFIG
+
+
+@pytest.fixture
+def redis_adapter() -> RedisAdapter:
+    """Provide a RedisAdapter with an injected mock client."""
+    mock_client = MagicMock(spec=redis.Redis)
+    return RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+
+@pytest.fixture
+def minio_adapter() -> MinioAdapter:
+    """Provide a MinioAdapter with an injected mock client."""
+    mock_client = MagicMock(spec=Minio)
+    return MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
@@ -0,0 +1,163 @@
+"""Unit tests for TTL-cached connection health checks on ConnectionAwareAdapter."""
+
+from __future__ import annotations
+
+from typing import cast
+from unittest.mock import MagicMock, patch
+
+import redis
+
+from python_repositories.adapters.minio_adapter import MinioAdapter
+from python_repositories.adapters.redis_adapter import RedisAdapter
+from tests.conftest import TEST_MINIO_CONFIG, TEST_REDIS_CONFIG
+
+
+class TestRedisConnectionHealth:
+    def test_not_connected_when_no_client(self) -> None:
+        adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+        assert not adapter.is_connected()
+
+    def test_connected_when_probe_succeeds(self, redis_adapter: RedisAdapter) -> None:
+        mock_client = cast(MagicMock, redis_adapter._client)
+        mock_client.ping.return_value = True
+
+        assert redis_adapter.is_connected()
+        mock_client.ping.assert_called_once()
+
+    def test_stale_connection_when_probe_fails(
+        self, redis_adapter: RedisAdapter
+    ) -> None:
+        cast(MagicMock, redis_adapter._client).ping.side_effect = redis.ConnectionError(
+            "connection lost"
+        )
+
+        assert not redis_adapter.is_connected()
+
+    def test_cache_hit_avoids_second_probe(self, redis_adapter: RedisAdapter) -> None:
+        mock_client = cast(MagicMock, redis_adapter._client)
+        mock_client.ping.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert redis_adapter.is_connected()
+            assert redis_adapter.is_connected()
+
+        mock_client.ping.assert_called_once()
+
+    def test_cache_miss_runs_probe_again(self, redis_adapter: RedisAdapter) -> None:
+        mock_client = cast(MagicMock, redis_adapter._client)
+        mock_client.ping.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            side_effect=[100.0, 102.0],
+        ):
+            assert redis_adapter.is_connected()
+            assert redis_adapter.is_connected()
+
+        assert mock_client.ping.call_count == 2
+
+    def test_disconnect_clears_cache(self, redis_adapter: RedisAdapter) -> None:
+        mock_client = cast(MagicMock, redis_adapter._client)
+        mock_client.ping.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert redis_adapter.is_connected()
+
+        redis_adapter.disconnect()
+        reinjected = RedisAdapter(
+            config=redis_adapter._config,
+            client=mock_client,
+        )
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert reinjected.is_connected()
+
+        assert mock_client.ping.call_count == 2
+
+
+class TestMinioConnectionHealth:
+    def test_not_connected_when_no_client(self) -> None:
+        adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+        assert not adapter.is_connected()
+
+    def test_not_connected_when_bucket_name_missing(
+        self, minio_adapter: MinioAdapter
+    ) -> None:
+        minio_adapter._bucket_name = None
+
+        assert not minio_adapter.is_connected()
+
+    def test_connected_when_probe_succeeds(self, minio_adapter: MinioAdapter) -> None:
+        mock_client = cast(MagicMock, minio_adapter._client)
+        mock_client.bucket_exists.return_value = True
+
+        assert minio_adapter.is_connected()
+        mock_client.bucket_exists.assert_called_once_with("test-bucket")
+
+    def test_stale_connection_when_probe_fails(
+        self, minio_adapter: MinioAdapter
+    ) -> None:
+        cast(MagicMock, minio_adapter._client).bucket_exists.side_effect = Exception(
+            "connection lost"
+        )
+
+        assert not minio_adapter.is_connected()
+
+    def test_cache_hit_avoids_second_probe(self, minio_adapter: MinioAdapter) -> None:
+        mock_client = cast(MagicMock, minio_adapter._client)
+        mock_client.bucket_exists.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert minio_adapter.is_connected()
+            assert minio_adapter.is_connected()
+
+        mock_client.bucket_exists.assert_called_once()
+
+    def test_cache_miss_runs_probe_again(self, minio_adapter: MinioAdapter) -> None:
+        mock_client = cast(MagicMock, minio_adapter._client)
+        mock_client.bucket_exists.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            side_effect=[100.0, 102.0],
+        ):
+            assert minio_adapter.is_connected()
+            assert minio_adapter.is_connected()
+
+        assert mock_client.bucket_exists.call_count == 2
+
+    def test_disconnect_clears_cache(self, minio_adapter: MinioAdapter) -> None:
+        mock_client = cast(MagicMock, minio_adapter._client)
+        mock_client.bucket_exists.return_value = True
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert minio_adapter.is_connected()
+
+        minio_adapter.disconnect()
+        reinjected = MinioAdapter(
+            config=minio_adapter._config,
+            client=mock_client,
+        )
+
+        with patch(
+            "python_repositories.adapters.connection_aware_adapter.time.monotonic",
+            return_value=100.0,
+        ):
+            assert reinjected.is_connected()
+
+        assert mock_client.bucket_exists.call_count == 2
@@ -1,4 +1,4 @@
-"""Integration tests for ConnectionAwareInterface."""
+"""Unit tests for ConnectionAwareInterface."""

 import pytest
 from python_repositories.interfaces.connection_aware_interface import (
@@ -15,7 +15,6 @@ def test_instantiation_fails_when_connect_not_implemented() -> None:
        def disconnect(self) -> None:
            pass

-        @property
        def is_connected(self) -> bool:
            return False

@@ -32,7 +31,6 @@ def test_instantiation_fails_when_disconnect_not_implemented() -> None:
        def connect(self) -> None:
            pass

-        @property
        def is_connected(self) -> bool:
            return False

@@ -1,4 +1,4 @@
-"""Integration tests for ContextAwareInterface."""
+"""Unit tests for ContextAwareInterface."""

 from __future__ import annotations

@@ -0,0 +1,26 @@
+"""Unit tests for dotenv_loader."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import pytest
+
+from python_repositories.config.dotenv_loader import load_dotenv
+
+
+def test_load_dotenv_loads_file(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    env_file = tmp_path / ".env"
+    env_file.write_text("DOTENV_TEST_VAR=loaded_value\n")
+    monkeypatch.delenv("DOTENV_TEST_VAR", raising=False)
+    loaded = load_dotenv(env_file)
+    assert loaded is True
+    assert os.getenv("DOTENV_TEST_VAR") == "loaded_value"
+
+
+def test_load_dotenv_returns_false_for_missing_file(tmp_path: Path) -> None:
+    missing = tmp_path / "missing.env"
+    assert load_dotenv(missing) is False
@@ -0,0 +1,43 @@
+"""Unit tests for env_bool."""
+
+from __future__ import annotations
+
+import pytest
+
+from python_repositories.config.env_bool import env_bool
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("true", True),
+        ("1", True),
+        ("yes", True),
+        ("on", True),
+        ("false", False),
+        ("0", False),
+        ("no", False),
+        ("off", False),
+    ],
+)
+def test_env_bool_parses_truthy_and_falsy(
+    monkeypatch: pytest.MonkeyPatch,
+    value: str,
+    expected: bool,
+) -> None:
+    monkeypatch.setenv("TEST_BOOL", value)
+    assert env_bool("TEST_BOOL", default=not expected) is expected
+
+
+def test_env_bool_returns_default_when_unset(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("TEST_BOOL", raising=False)
+    assert env_bool("TEST_BOOL", default=True) is True
+    assert env_bool("TEST_BOOL", default=False) is False
+
+
+def test_env_bool_raises_for_invalid_value(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("TEST_BOOL", "not-a-bool")
+    with pytest.raises(ValueError, match="TEST_BOOL"):
+        env_bool("TEST_BOOL", default=False)
@@ -1,4 +1,6 @@
-"""Integration tests for JsonRepositoryInterface."""
+"""Unit tests for JsonRepositoryInterface."""
+
+from typing import Any

 import pytest
 from python_repositories.interfaces.json_repository_interface import (
@@ -12,7 +14,7 @@ def test_instantiation_fails_when_get_not_implemented() -> None:
    class Incomplete(JsonRepositoryInterface):
        """A class that does not implement get."""

-        def set(self, key: str, data: dict) -> None:
+        def set(self, key: str, data: dict[str, Any]) -> None:
            pass

        def delete(self, key: str) -> None:
@@ -31,7 +33,7 @@ def test_instantiation_fails_when_set_not_implemented() -> None:
    class Incomplete(JsonRepositoryInterface):
        """A class that does not implement set."""

-        def get(self, key: str) -> dict | None:
+        def get(self, key: str) -> dict[str, Any] | None:
            return None

        def delete(self, key: str) -> None:
@@ -50,10 +52,10 @@ def test_instantiation_fails_when_delete_not_implemented() -> None:
    class Incomplete(JsonRepositoryInterface):
        """A class that does not implement delete."""

-        def get(self, key: str) -> dict | None:
+        def get(self, key: str) -> dict[str, Any] | None:
            return None

-        def set(self, key: str, data: dict) -> None:
+        def set(self, key: str, data: dict[str, Any]) -> None:
            pass

        def list_keys(self, pattern: str) -> list[str]:
@@ -69,10 +71,10 @@ def test_instantiation_fails_when_list_keys_not_implemented() -> None:
    class Incomplete(JsonRepositoryInterface):
        """A class that does not implement list_keys."""

-        def get(self, key: str) -> dict | None:
+        def get(self, key: str) -> dict[str, Any] | None:
            return None

-        def set(self, key: str, data: dict) -> None:
+        def set(self, key: str, data: dict[str, Any]) -> None:
            pass

        def delete(self, key: str) -> None:
@@ -80,3 +82,24 @@ def test_instantiation_fails_when_list_keys_not_implemented() -> None:

    with pytest.raises(TypeError):
        _ = Incomplete()  # type: ignore
+
+
+def test_scan_keys_defaults_to_list_keys() -> None:
+    """Test that the default scan_keys implementation delegates to list_keys."""
+
+    class Complete(JsonRepositoryInterface):
+        def get(self, key: str) -> dict[str, Any] | None:
+            return None
+
+        def set(self, key: str, data: dict[str, Any]) -> None:
+            pass
+
+        def delete(self, key: str) -> None:
+            pass
+
+        def list_keys(self, pattern: str) -> list[str]:
+            return [f"{pattern}-1", f"{pattern}-2"]
+
+    repository = Complete()
+
+    assert list(repository.scan_keys("user")) == ["user-1", "user-2"]
@@ -0,0 +1,252 @@
+"""Unit tests for MinioAdapter instantiation and injection."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from unittest.mock import MagicMock
+
+import pytest
+from minio import Minio, S3Error
+from urllib3.response import BaseHTTPResponse
+
+from python_repositories.adapters.minio_adapter import MinioAdapter
+from python_repositories.interfaces import ObjectRepositoryInterface
+from tests.conftest import TEST_MINIO_CONFIG
+
+
+def test_should_adhere_to_interface() -> None:
+    assert issubclass(MinioAdapter, ObjectRepositoryInterface)
+    _ = MinioAdapter(config=TEST_MINIO_CONFIG)
+
+
+def test_should_have_logger_when_instantiated() -> None:
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+    assert hasattr(adapter, "logger")
+    assert adapter.logger is not None
+
+
+def test_should_not_be_connected_when_instantiated() -> None:
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+    assert not adapter.is_connected()
+
+
+def test_constructs_with_injected_config_without_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    for var in (
+        "MINIO_ENDPOINT",
+        "MINIO_ACCESS_KEY",
+        "MINIO_SECRET_KEY",
+        "MINIO_BUCKET",
+    ):
+        monkeypatch.delenv(var, raising=False)
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+    assert adapter._config == TEST_MINIO_CONFIG
+
+
+def test_injected_client_sets_bucket_name() -> None:
+    mock_client = MagicMock(spec=Minio)
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+    assert adapter._bucket_name == "test-bucket"
+    assert adapter._client is mock_client
+
+
+def test_raises_when_client_provided_without_config() -> None:
+    mock_client = MagicMock(spec=Minio)
+    with pytest.raises(ValueError, match="config is required"):
+        MinioAdapter(client=mock_client)
+
+
+def test_connect_with_injected_client_succeeds() -> None:
+    mock_client = MagicMock(spec=Minio)
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    adapter.connect()
+
+    mock_client.list_buckets.assert_called_once()
+
+
+def test_connect_with_injected_client_raises_on_failure() -> None:
+    mock_client = MagicMock(spec=Minio)
+    mock_client.list_buckets.side_effect = Exception("connection lost")
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    with pytest.raises(ConnectionError, match="Could not connect to Minio"):
+        adapter.connect()
+
+
+def test_connect_with_injected_client_skips_validation_when_client_cleared() -> None:
+    mock_client = MagicMock(spec=Minio)
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+    adapter.disconnect()
+
+    adapter.connect()
+
+    mock_client.list_buckets.assert_not_called()
+
+
+def test_connect_disconnects_before_reconnect(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stale_client = MagicMock(spec=Minio)
+    new_client = MagicMock(spec=Minio)
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+    adapter._client = stale_client
+    adapter._bucket_name = None
+
+    monkeypatch.setattr(
+        "python_repositories.adapters.minio_adapter.minio.Minio",
+        lambda *args, **kwargs: new_client,
+    )
+
+    adapter.connect()
+
+    assert adapter._client is new_client
+    new_client.list_buckets.assert_called_once()
+
+
+def test_connect_skips_reconnect_when_already_connected(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stale_client = MagicMock(spec=Minio)
+    stale_client.bucket_exists.return_value = True
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+    adapter._client = stale_client
+    adapter._bucket_name = TEST_MINIO_CONFIG.bucket
+
+    minio_ctor = MagicMock()
+    monkeypatch.setattr(
+        "python_repositories.adapters.minio_adapter.minio.Minio",
+        minio_ctor,
+    )
+
+    adapter.connect()
+
+    minio_ctor.assert_not_called()
+    assert adapter._client is stale_client
+
+
+def test_connect_raises_when_bucket_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = False
+
+    monkeypatch.setattr(
+        "python_repositories.adapters.minio_adapter.minio.Minio",
+        lambda *args, **kwargs: mock_client,
+    )
+
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG)
+
+    with pytest.raises(ConnectionError, match="does not exist"):
+        adapter.connect()
+
+    mock_client.make_bucket.assert_not_called()
+
+
+def test_connect_creates_bucket_when_create_bucket_if_missing_enabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = False
+    config = replace(TEST_MINIO_CONFIG, create_bucket_if_missing=True)
+
+    monkeypatch.setattr(
+        "python_repositories.adapters.minio_adapter.minio.Minio",
+        lambda *args, **kwargs: mock_client,
+    )
+
+    adapter = MinioAdapter(config=config)
+    adapter.connect()
+
+    mock_client.bucket_exists.assert_called_once_with(config.bucket)
+    mock_client.make_bucket.assert_called_once_with(config.bucket)
+
+
+def test_get_closes_response_on_success() -> None:
+    """get() must close and release the get_object HTTP response."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    mock_response = MagicMock()
+    mock_response.read.side_effect = [b"data", b""]
+    mock_client.get_object.return_value = mock_response
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    result = adapter.get("some-object")
+
+    assert result is not None
+    assert result.read() == b"data"
+    mock_response.close.assert_called_once()
+    mock_response.release_conn.assert_called_once()
+
+
+def test_get_closes_response_when_read_fails() -> None:
+    """get() must close and release the response even if read() raises."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    mock_response = MagicMock()
+    mock_response.read.side_effect = OSError("connection reset")
+    mock_client.get_object.return_value = mock_response
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    with pytest.raises(OSError, match="connection reset"):
+        adapter.get("some-object")
+
+    mock_response.close.assert_called_once()
+    mock_response.release_conn.assert_called_once()
+
+
+def test_get_returns_none_for_no_such_key() -> None:
+    """get() returns None when the object does not exist."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    mock_client.get_object.side_effect = S3Error(
+        MagicMock(spec=BaseHTTPResponse),
+        "NoSuchKey",
+        "",
+        "",
+        "",
+        "",
+        bucket_name="test-bucket",
+        object_name="missing-object",
+    )
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    result = adapter.get("missing-object")
+
+    assert result is None
+
+
+def test_get_reraises_other_s3_errors() -> None:
+    """get() re-raises S3 errors other than NoSuchKey."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    other_s3error = S3Error(
+        MagicMock(spec=BaseHTTPResponse),
+        "AccessDenied",
+        "",
+        "",
+        "",
+        "",
+        bucket_name="test-bucket",
+        object_name="some-object",
+    )
+    mock_client.get_object.side_effect = other_s3error
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    with pytest.raises(S3Error) as exc_info:
+        adapter.get("some-object")
+
+    assert exc_info.value.code == "AccessDenied"
+
+
+def test_get_reraises_general_exception_from_get_object() -> None:
+    """get() re-raises unexpected exceptions from get_object."""
+    mock_client = MagicMock(spec=Minio)
+    mock_client.bucket_exists.return_value = True
+    mock_client.get_object.side_effect = Exception("General failure")
+    adapter = MinioAdapter(config=TEST_MINIO_CONFIG, client=mock_client)
+
+    with pytest.raises(Exception, match="General failure"):
+        adapter.get("some-object")
@@ -0,0 +1,68 @@
+"""Unit tests for MinioConfig."""
+
+from __future__ import annotations
+
+import pytest
+
+from python_repositories.config import MinioConfig
+
+
+def _set_required_minio_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("MINIO_ENDPOINT", "localhost:9000")
+    monkeypatch.setenv("MINIO_ACCESS_KEY", "access")
+    monkeypatch.setenv("MINIO_SECRET_KEY", "secret")
+    monkeypatch.setenv("MINIO_BUCKET", "my-bucket")
+
+
+def test_from_env_loads_all_fields(monkeypatch: pytest.MonkeyPatch) -> None:
+    _set_required_minio_env(monkeypatch)
+    config = MinioConfig.from_env(use_dotenv=False)
+    assert config.endpoint == "localhost:9000"
+    assert config.access_key == "access"
+    assert config.secret_key == "secret"
+    assert config.bucket == "my-bucket"
+    assert config.secure is True
+    assert config.create_bucket_if_missing is False
+
+
+def test_from_env_defaults_secure_to_true_when_unset(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _set_required_minio_env(monkeypatch)
+    monkeypatch.delenv("MINIO_SECURE", raising=False)
+    config = MinioConfig.from_env(use_dotenv=False)
+    assert config.secure is True
+
+
+def test_from_env_reads_secure_from_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    _set_required_minio_env(monkeypatch)
+    monkeypatch.setenv("MINIO_SECURE", "false")
+    assert MinioConfig.from_env(use_dotenv=False).secure is False
+
+
+def test_from_env_reads_create_bucket_if_missing_from_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _set_required_minio_env(monkeypatch)
+    monkeypatch.setenv("MINIO_CREATE_BUCKET_IF_MISSING", "true")
+    assert MinioConfig.from_env(use_dotenv=False).create_bucket_if_missing is True
+
+
+def test_from_env_defaults_create_bucket_if_missing_to_false_when_unset(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _set_required_minio_env(monkeypatch)
+    monkeypatch.delenv("MINIO_CREATE_BUCKET_IF_MISSING", raising=False)
+    config = MinioConfig.from_env(use_dotenv=False)
+    assert config.create_bucket_if_missing is False
+
+
+def test_from_env_raises_when_endpoint_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("MINIO_ENDPOINT", raising=False)
+    monkeypatch.setenv("MINIO_ACCESS_KEY", "access")
+    monkeypatch.setenv("MINIO_SECRET_KEY", "secret")
+    monkeypatch.setenv("MINIO_BUCKET", "my-bucket")
+    with pytest.raises(Exception):
+        MinioConfig.from_env(use_dotenv=False)
@@ -1,4 +1,4 @@
-"""Integration tests for ObjectRepositoryInterface."""
+"""Unit tests for ObjectRepositoryInterface."""

 from io import BytesIO

@@ -0,0 +1,195 @@
+"""Unit tests for RedisAdapter instantiation and injection."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+import redis
+
+from python_repositories.adapters.redis_adapter import RedisAdapter
+from python_repositories.interfaces import JsonRepositoryInterface
+from tests.conftest import TEST_REDIS_CONFIG
+
+
+def test_should_adhere_to_interface() -> None:
+    assert issubclass(RedisAdapter, JsonRepositoryInterface)
+    _ = RedisAdapter(config=TEST_REDIS_CONFIG)
+
+
+def test_should_have_logger_when_instantiated() -> None:
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+    assert hasattr(adapter, "logger")
+    assert adapter.logger is not None
+
+
+def test_should_not_be_connected_when_instantiated() -> None:
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+    assert adapter._client is None
+    assert not adapter.is_connected()
+
+
+def test_constructs_with_injected_config_without_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("REDIS_URI", raising=False)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+    assert adapter._config == TEST_REDIS_CONFIG
+
+
+def test_constructs_with_injected_client_without_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("REDIS_URI", raising=False)
+    mock_client = MagicMock(spec=redis.Redis)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+    assert adapter._client is mock_client
+    assert adapter._client_injected is True
+
+
+def test_raises_when_client_provided_without_config() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    with pytest.raises(ValueError, match="config is required"):
+        RedisAdapter(client=mock_client)
+
+
+def test_disconnect_does_not_close_injected_client() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+    adapter.disconnect()
+    mock_client.close.assert_not_called()
+    assert adapter._client is None
+
+
+class CustomEnvRedisAdapter(RedisAdapter):
+    uri_env_var_name = "CUSTOM_REDIS_URI"
+
+
+def test_subclass_custom_env_var_name(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("CUSTOM_REDIS_URI", "redis://custom:6379")
+    adapter = CustomEnvRedisAdapter()
+    assert adapter._config.uri == "redis://custom:6379"
+
+
+def test_connect_with_injected_client_succeeds_when_ping_ok() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    mock_client.ping.return_value = True
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    adapter.connect()
+
+    mock_client.ping.assert_called_once()
+
+
+def test_connect_with_injected_client_raises_when_ping_false() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    mock_client.ping.return_value = False
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    with pytest.raises(ConnectionError, match="Could not connect to Redis"):
+        adapter.connect()
+
+
+def test_connect_with_injected_client_raises_on_redis_error() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    mock_client.ping.side_effect = redis.ConnectionError("connection lost")
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    with pytest.raises(ConnectionError, match="Could not connect to Redis"):
+        adapter.connect()
+
+
+def test_connect_with_injected_client_skips_validation_when_client_cleared() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+    adapter.disconnect()
+
+    adapter.connect()
+
+    mock_client.ping.assert_not_called()
+
+
+def test_connect_reconnects_when_existing_client_unhealthy(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stale_client = MagicMock(spec=redis.Redis)
+    stale_client.ping.side_effect = redis.ConnectionError("connection lost")
+    new_client = MagicMock(spec=redis.Redis)
+    new_client.ping.return_value = True
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+    adapter._client = stale_client
+
+    monkeypatch.setattr("redis.Redis.from_url", lambda *args, **kwargs: new_client)
+
+    adapter.connect()
+
+    stale_client.close.assert_called_once()
+    assert adapter._client is new_client
+
+
+def test_connect_skips_reconnect_when_already_connected(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    stale_client = MagicMock(spec=redis.Redis)
+    stale_client.ping.return_value = True
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+    adapter._client = stale_client
+
+    from_url = MagicMock()
+    monkeypatch.setattr("redis.Redis.from_url", from_url)
+
+    adapter.connect()
+
+    stale_client.close.assert_not_called()
+    from_url.assert_not_called()
+    assert adapter._client is stale_client
+
+
+def test_scan_keys_yields_decoded_keys() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    mock_client.scan_iter.return_value = iter([b"key1", b"key2"])
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    keys = list(adapter.scan_keys("key*"))
+
+    assert keys == ["key1", "key2"]
+    mock_client.scan_iter.assert_called_once_with(match="key*")
+    mock_client.keys.assert_not_called()
+
+
+def test_scan_keys_forwards_count() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    mock_client.scan_iter.return_value = iter([b"key1"])
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    keys = list(adapter.scan_keys("key*", count=50))
+
+    assert keys == ["key1"]
+    mock_client.scan_iter.assert_called_once_with(match="key*", count=50)
+
+
+def test_list_keys_raises_value_error_on_invalid_pattern() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    invalid_patterns = ["", 123, None]
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError, match="Pattern must be a non-empty string"):
+            adapter.list_keys(pattern)  # type: ignore[arg-type]
+
+
+def test_scan_keys_raises_value_error_on_invalid_pattern() -> None:
+    mock_client = MagicMock(spec=redis.Redis)
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG, client=mock_client)
+
+    invalid_patterns = ["", 123, None]
+    for pattern in invalid_patterns:
+        with pytest.raises(ValueError, match="Pattern must be a non-empty string"):
+            list(adapter.scan_keys(pattern))  # type: ignore[arg-type]
+
+
+def test_scan_keys_raises_connection_error_when_not_connected() -> None:
+    adapter = RedisAdapter(config=TEST_REDIS_CONFIG)
+
+    with pytest.raises(ConnectionError):
+        list(adapter.scan_keys("key*"))
@@ -0,0 +1,27 @@
+"""Unit tests for RedisConfig."""
+
+from __future__ import annotations
+
+import pytest
+
+from python_repositories.config import RedisConfig
+
+
+def test_from_env_loads_uri(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("REDIS_URI", "redis://example:6379")
+    config = RedisConfig.from_env(use_dotenv=False)
+    assert config.uri == "redis://example:6379"
+
+
+def test_from_env_raises_when_uri_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("REDIS_URI", raising=False)
+    with pytest.raises(Exception):
+        RedisConfig.from_env(use_dotenv=False)
+
+
+def test_from_env_respects_custom_env_var_name(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CUSTOM_REDIS_URI", "redis://custom:6379")
+    config = RedisConfig.from_env("CUSTOM_REDIS_URI", use_dotenv=False)
+    assert config.uri == "redis://custom:6379"
@@ -83,42 +83,43 @@ wheels = [

 [[package]]
 name = "ast-serialize"
-version = "0.5.0"
+version = "0.6.0"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0.tar.gz", hash = "sha256:5880091bfe6f4f986f22866375c2e884843e7a0b6343ae41aeea659613d879b6" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0.tar.gz", hash = "sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8f5c14f169eb0972c0c21bada5358b23d6047c76583b005234f865b11f1fa00a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7d1a2de9de5be04652f0ed60738356ef94f66db37924a9499fffe98dc491aa0b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be5173fb66f9b49026d9d5a2ff0fc7c7009077107c0eb285b2d60fdf1fe10bd1" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8015cd071ac1339924ee2b8098c93e00e155f30a16f40ec9816fcf84f4753f6" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5499e8797edff2a9186aa313ed382c6b422e798e9332d9953badcee6e69a88f2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6848f2a093fb5548751a9a09bff8fcd229e2bbeb0e3331f391b6ae6d26cd9903" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:832d4c998e0b091fd60a6d6bceee535483c4d490de9ba85003af835225719261" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:16db7c62ec0b8efe1d7afd283a388d8f74f2605d56032e5a37747d2de8dba027" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:baf5eb061eb5bccade4128ad42da33787d72f6013809cd1b590376ece8b3c937" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:104e4a35bd7c124173c41760ef9aaea17ddb3f86c65cb643671d59afbe3ee94c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:36be371028fc1675acb38a331bde160dbab7ff907fdf00b67eb6911aa106951b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:061ee58bdb52341c8201a6df41182a977736bae3b7ded87ca7176ca25a8a47ab" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b15219e9cdc9f53f6f4cb51c009203507228226148c05c5e8fe451c28b435eb3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-win32.whl", hash = "sha256:842d1c004bb466c7df036f95fabef789570541922b10976b12f5592a69cf0b38" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b0c06d760909b095cc466356dfccd05a1c7233a6ca191c020dca2c6a6f16c24c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:787baedb0262cc49e8ce37cc15c00ae818e46a165a3b36f5e21ed174998104cb" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0668aa9459cfa8c9c49ddd2163ebcf43088ba045ef7492af6fe22e0098303101" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bf683d6363edf2b39eed6b6d4fe22d34b6203867a67e27134d9e2a2680c4bc4a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc22cf0c9be65e71cf88fda130af60d61eb4a79370ad4cfe7900d48a4aa2211" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f66173891548c9f2726bf27957b41cabce12fa679dc6da505ddbde4d4b3b31cf" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e42d729ef2be96a14efbad355093284739e3670ece3e534f82cc8832790911d9" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b725026bafa801dbd7310eb13a75f0a2e370e7e51b2cb225f9d21fcfadf919ee" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b54f60c1d78767a53b67eaa663f0dfac3afe606aa07f1301572f588b73d64809" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:27d51654fc240a1e87e742d353d98eb45b75f62f129086b3596ab53df2ac2a43" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c36237c46dd1674542f2109740ea5ea485a169bf1431939ada0434e17934" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1943db345233cc7194a470f13afa9c59772c0b123dea0c9414c4d4ca54369759" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df1c00022cbbcb064bfaa505aa9c9295362443ce5dacb459d1331d3da353f887" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:cae65289fc456fde04af979a2be09302ef5d8ab92ef23e596d6746dc267ada27" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:239a4c354e8d676e9d94631d1d4a64edc6b266f86ff3a5a80aedd344f342c01d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-win32.whl", hash = "sha256:143a4ef63285a075871908fda3672dc21864b83a8ec3ee12304aa3e4c5387b9a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:cf25572c526add400f26a4750dc6ce0c3bb93fc1f75e7ae0cad4ce4f2cd5c590" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:92a31c9c20d25a076edaeec76b128a3535d74a24f340b9a8a7e96c9b86dc9642" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:a7520b672827885bafeae7501f684d14d47d17e5f45256f9df547686cca52264" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a14191beec7e0c078d2fc1f6edc0aee88bcd4db9f18e1bc9f8052b559c22dddc" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32ef62ec34cf6be20ad77d4799556638fbdf187f3ae10698dfb20ef9f2c89516" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:13b7769970a39983b0adf2f38917b1cd3b8946f76df045756c3d741bc689f089" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f7a408601bb3edaefb3bc67a4c01f5235e3253653b6a5729a2ee2382b35341c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8670bfa51208a2c0c8d138928e40e998fab158f9200d53bb80c088b5b8eda7b8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a4826809eb8597a8cd59fd924b6d7c285b8969a1e0007e2cb652cab62376270f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:577a6c189068686869f5f1ddc38363f3ae1808a4753b577266f9202071a7bb66" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:085de7f62dc9cc247eb01e965a362707d1d90b1d89a82c5bf78301a60a3c417b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9f8a8b78b13173de6a9ec22111d9be674874cd5bdccda04f14ae5ebc2bef403a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f2ff3baffc3a29c1f15bc9098aa0c09763410262d5e6cef42116f7356c184554" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0067b25fce104eaae5b88383de9ab803faeb671831e14ca698b771b356e2600f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c617417f9cbb0cb144f6283c3cbe0d2e0f01beaf9f608f662b21191058a626ec" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-win32.whl", hash = "sha256:5337cb256dcea3df9288205213d1601581536526b8f4da44b6974f1180f3252a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2d947e45cafc4b09bd7528917fa84c517654a43de173c79785574b7b3068ac24" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6e15ec740436e1a0d62de848641abe5f3a2f89a7f94907d534795ac91bbacf14" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-win32.whl", hash = "sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-win_amd64.whl", hash = "sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/ast-serialize/ast_serialize-0.6.0-cp39-abi3-win_arm64.whl", hash = "sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e" },
 ]

 [[package]]
@@ -305,71 +306,71 @@ wheels = [

 [[package]]
 name = "coverage"
-version = "7.14.3"
+version = "7.15.0"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3.tar.gz", hash = "sha256:1a7563a443f3d53fdeb040ec8c9f7466aed7ca3dc5891aa09d3ca3625fa4387f" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0.tar.gz", hash = "sha256:9ac3fe7a1435986463eaa8ee253ae2f2a268709ba4ae5c7dd1f52a05391ad78f" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3d74ff26299c4879ce3a4d826f9d3d4d556fd285fde7bbce3c0ef5a8ab1cec24" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:96150a9cf3468ea20f0bc5d0e21b3df8972c31480ef90fa7614b773cc6429665" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:27d07a46500ba23515b838dbcf52512026af04090755cf6cc64166d88c9b9a1a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:621e13c6108234d7960aaf5762ab5c3c00f33c30c15af06dcbff0c73bf112727" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4b60ca6d8af70473491a15a343cbabab2e8f9ea66a4376e81c7aa24876a6f977" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c90a7cdd5e380e1ce02f19792e2ac2fbfbf177e35a27e69fd3e873b30d895c0c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5d788e5fd55347eef06ca0732c77d04a264de67e8ff24631270cdff3767a60cf" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62c7f79db2851c95ef020e5d28b97afde3daf9f7febcd35b53e05638f729063f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:90f7608aeb5d9b60b523b9fb2a4ee1973867cc4865a3f26fe6c7577073b70205" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1e3b91f9c4740aeb571ecf82e5e8d8e4ab62d34fcb5a5d4e5baa38c6f7d2857c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c946099774a7699de03cbd0ff0a64e21aed4525eed9d959adde4afe6d15758ef" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:16b206e521feb8b7133a45754643dead0538489cf8b783b90cf5f4e3299625fd" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-win32.whl", hash = "sha256:ea3169c7116eb6cdf7608c6c7da9ecfcb3da40688e3a510fac2d1d2bafd6dc35" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:7ea52fc08f007bcc494d4bb3df3851e95843d881860ba38fe2c64dc100db5e7d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:8cec0ad652ec57790970d817490105bd917d783c2f7b38d6b58a0ca312e1a336" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:47968988b367990ae4ab17523790c38cd125e02c6bfd379b6022be2d40bdc38c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0ee68f5c34812780f3a7063382c0a9fcbb99985b7ddcdcaa626e4f3fb2e0783a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fa9e5c6857a7e80fa22ace5cf3550ae392bbfc322f1d8dd2d2d5a8be38cec027" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:98a0859b0e98e43e1178a9402e19c8127766b14f7109a374d976e5a62c0e5c73" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69918344541ed9c8368566c2adc03c0e33d4550d7faa87d1b35e49b6a3286ea9" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b7f300ac92cd4b570724c8ffbbd0c130fee298d2447f41d5a3abf58976fae1de" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:11a7ec9f97ab950f4c5af62229befc7faf208fdbc0116d3902d7e306cf2c5abd" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a571bd889cd36c5922ce8e42e059f9d37d02301531d11374afa4c87a578625d5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:de76caefc8deabb0dd1678b6a980be97d14c8d87e213ac194dbf8b09e96d63fb" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d20a15c622194234161535459affa8f7905830391c9ccfa060d495dbfe3a1c7f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:b488bd4b23397db62e7a9459129d01ff06a846582a732efd24834b24a6ada498" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6a3693b4153394d265f44fb855fdc80e72403024d4d6f91c4871b334d028e4e0" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-win32.whl", hash = "sha256:338b19131ab1a6b767b462bfcbaa692e7ae22f24463e39d49b02a83410ff6b37" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:b3d77f7f196abdef7e01415de1bce09f216189e83e58159cfeef2b92d0464994" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:e6230e688c7c3e65cedd41a774eb4ec221adc6bfee13768231015b702d5e4150" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:605ab2b566a22bd94834529d66d295c364aba84afd3e5498285c7a524017b1fc" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a3c2134809e80fac091bfed18a6991b5a5eb5df5ae32b17ac4f4f99864b73dd7" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c02efd507227bde9969cab0db8f48890eb3b5dcad6afac57a4792df4133543ce" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1bb93c2aa61d2a5b38f1526546d95cf4132cb681e541a337bf8dfd092be816e5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f502e948e03e866538048bba081c075caaa62e5bda6ea5b7432e45f587eb462a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9973ef2463f8e6cfb61a6324126bb3e17d67a85f22f58d856e583ea2e3ca6501" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9be4e7d4c5ca0427889f8f9d614bd630c2be741b1de7699bca3b2b6c0e41003e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a574912f3bde4b0619f6e97d01aa590b70998859244793769eb3a6df78ee56d3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:e343fb086c9cd780b38622fea7c369acd64c1a0724312149b5d769c387a2b1f5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:3c68df8e61f1e09633fefc7538297145623957a048534368c9d212782aa5e845" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3e5b550a128419373c2f6cec28a244207013ef15f5cbcff6a5ca09d1dfaaf027" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2bfc4dd0a912329eccc7484a7d0b2a38032b38c40663b1e1ac595f10c457954b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-win32.whl", hash = "sha256:0423d64c013057a06e70f070f073cec4b0cbc7d2b27f3c7007292f2ff1d52965" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:92c22e19ce64ca3f2ad751f16f14df1468b4c231bd6af97185063a9c292a0cb3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:41de778bd41780586e2b04912079c73089ab5d839624e28db3bdb26de638da92" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8427f370ca67db4c975d2a26acfc0e5783ca0b52444dbc50278ace0f35445949" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d8e88f335544a47e22ae2e45b344772925ec65166555c958720d5ed971880891" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:beaab199b9e5ceaf5a225e16a9d4df136f2a1eae0a5c20de1e277c8a5225f388" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3ff255799f5a1676c71c1c32ec01fd043aa09d57b3d95764b24992757184784" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:878832eaac515b62decfa76965aed558775f86bf1fc8cca76993c0c84ae31aed" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:611e62cb9386096d81b63e0a05330750268617231e7bd598e1fe77482a2c58a5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:02c41de2a88011b893050fc9830267d927a50a215f7ad5ec17349db7090ccf26" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:526ce9721116af23b1065089f0b75046fe521e7772ab94b641cd66b7a0421889" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:e4ed44705ca4bead6fc977a8b741f2145608289b33c8a9b42a95d0f15aedbf4d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2415902f385a23dcc4ccd26e0ba803249a169af6a930c003a4c715eeb9a5444e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b75ee850fc2d7c831e883220c445b035f2224de2ba6103f1e56dbd237ab913f7" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dc9b4e35e7c3920e925ba7f14886fd5fbe481232754624e832ddba66c7535635" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-win32.whl", hash = "sha256:7b27c822a8161afbe48e99f1adfb098d270ae7e0f7d7b0555ce110529bdb69cc" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:39e1dbbb6ff2c338e0196a482558a792a1de3aa64261196f5cdb3da016ad9cda" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:68520c90babfa2d560eca6d497921ed3a4f469623bd709733124491b2aa8ef3f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.14.3-py3-none-any.whl", hash = "sha256:fb7e18afb6e903c1a92401a2f0501ac277dca527bb9ca6fe1f691a8a0026a0e8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b75ee5e8cb7575636ac598719b4307ac529ec8fcd79608a35c3cd4d4dada812d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffb31267816b93b075302248cc1737506081b4f163df4401e9df1a6424aafabe" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e4d0bb73455bf97ab243a8f12c37c686ccf1c13bb614b7b85f1d062f06f42b2c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:20d9ccc4ebd0edc434d86dfd2a1dd2a8efa6b6b3073d0485a394fee86459ebb4" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20c8a976c365c8cb12f0cbd099508772ea41fb5fa80657a8506df0e11bd278c5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f948fd5ba1b9cbca91f0ae08b4c1ce2b139509149a435e2585d056d57d70bf01" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f58185f06edf6ad68ec9fb155d63ef650c82f3fbd7e1770e2867751fb13158f4" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02adc79a920c73c647c5d117f55747df7f2de94571884758ce8bc58e04f0a796" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6eb7c300fbed667fd6e3588eba71c1904cdb06110ca6fdf908c26bdd88b8e382" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b5fb23fa2de9dce1f5c36c09066d8fcda16cd96e8e26686caa2d7cb9b567d65c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cec79341dbe6281484024979976d0c7f22beae08b4a254655decd25d42cbe766" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c664c5444b1d970b1b2a450e21fb19ee5c9cfdf151ded2dda37260031cca0da" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-win32.whl", hash = "sha256:5f764a3fa339bde6b3aa97657f5a6a3a9451e4a5b4ea98a2892c773a43525f77" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:52f9a4d2c4c56c8848bc2f524916698354b0211488b38c49ad9ae54f6cafbff6" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:31e5c3e70c85307ea35a12964e2e40f56ca2ee4b1c8c721ccf4609d17071080b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5be4caf3b28836f078abe700f8944dac4a65d78f16d6c600c89cb624e5535782" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dd58ad1404704303ca8d4f4b8a1095e7cbc7040ef17a66df1e6619aa10176430" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bbcbb317c2e5ded5b21104af81c29f391be2af98d065693ffbe8d23949b948e5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:27f31ecb458da3f859aab3f15ada871eb7a7768807d88df4a9f186bb17737970" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fb759be317fdc62e0f56bffdf61cfcb45c7761ad6b71e3e583e71a67ae753c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5cf007add5ab4bb8fa9f4c77e3732127c9e6cad501d7db43355fbfafca0be84" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cc78d9843bd576fbe2118248258d485e968dc535f95ed504a7b0867ba9b51389" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a263060f1de0b4b74b4e089c2a70b8003b3781c733329a9c8fd54995328f9950" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c48decf16e0dfd5b049c7d5e82200c23c08126719142998d4f172444e3d0529e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:08fb028000ed0aaa0a4cbdfbb98be7cb42f370db973fbbb469733505ab20e13e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb7dc0c3b7d8a1077abea0b8546ebc5e26d6ef6ecefc2f0f5ad2b8a53bdad837" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cb3602054ccbe9f0d8c2dc04bbeba90d5719236e2cd06e042ddd6d3fc7b6e37" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-win32.whl", hash = "sha256:0bf781da64326b677be344df505171435b6f58716108606621d5d27d964fff8b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:2c57a275078ee3fa185f83e400f765bc764a549de66d99b47881645cbd4ea629" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:3812c61afc6685c7999b39320779ab8f43b7a3081fdb0def39976e56fbdb9a21" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:41cb79af843222e11da87127ad0ecbfa878abadd0f770a4a99391a27d3887324" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7d2008989ef8fe54188d3f3bfa2e3099b025af11e90a6a1b9e7dc433d04263d8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:769e8ece11a596315ebf5aa7ec383aeeed016c091d2bf6363ffb996d41529092" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:65a6b6164ee5c39e2f3803f314292d6c61a607ba7fee253d1e03c42dc3903502" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75128817f95a5c45bb01d65fd2d8b9cb54bbe03d81608fb70e3e14b437ad56c2" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9887bb428fe2d4cd4bee89bac1a6c9932f484afd5b36fbd4ff6ea5f825bb1f5e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0bfc0be1f702042207a93a00523b1065ee1fe951e96edf311581c0bbc2e34888" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f64627d55def5a43282d70e08396672692f77e4da610a5bb8bb4060b432b6859" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:2c6f0fa473003905c6d5bac328ee4eba9fbea654f15bc24b8a3274b23363fa99" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2bcf9afaf064172c6ec3c58a325a9957ad1178c05dd934e25f253321776e0676" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:baf06bc987115d6fb938d403f7eab684a057766c490367999a2b71a6883110c6" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f0405f2ff97b1c4c0e782cb32e02f32369bcf2e6b618b591d67e1ea754575dfe" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-win32.whl", hash = "sha256:ab282853ed5fbd64bbb162f19cb8fcb7087187508a6374b4f9c34ec1577c4e8f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:3bb3040e9f4bbe26fcb0cd7cc85ac63e630d3f3a9c74f027abf4caa27e706663" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:346771144d34f7fa84ec28386f78e0f31653f33cf35e19d253d5b35f9e8201da" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d34a010905fb6401324ba016b5da03d574967f7b21ce48ea41e66f0f1f95f641" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bb25d825d885ca8036795dacfc3924d33091fc76d71ebc99420c6b79e77d96fa" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:94c9686bfe8a9a6810297aecbd99beaa3445f9e8dc2f80b1382cca0d86b64461" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9bd671c25f9d85f09d7ec481d0e43d5139f486c06a37139847a7ce569788af72" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:110cbdf8d2e216577312cf06ccf85539c0e5a5420ef747e4a4719b5e483c88cd" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2c5d4619214f1d9993e7b00a8600d14614b7e9d84e89507460b126aa5e6559e5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:781a704516e2d8346fbbd5be6c6f3412dd824785146528b3a01816f26c081007" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd4a1b44bcb65ee29e947ac92bbee04956df3a6bfc6143641bb6cae7ede00fc9" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0e4950c9d6d3e39c64c991814ff315e2d0b9cb8152363594212c9e55208c0a8f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:fe9c87ff42e5472d80d21704972e1f96e104a0a599d77c5e35db5a3c562e2571" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f00d5ae1dd2fe13fb8186e3e7d37bcbd8b25c0d764ff7d1b32cef9be058510a8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:363ab38cc78b615f11c9cac3cf1d7eef950c18b9fdedfb9066f59461dcf84d68" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-win32.whl", hash = "sha256:54fd9c53a5fafff509195f1b6a3f9be615d8e8362a3629ff1de23d270c03c86b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:87b47553097ba185ed964866078e7e63adea9f5f51b5f39691c34f30afd21080" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aeefb2dd178fe7eee79f0ad25d75855cb35ee9ed472db2c5ea06f5b4fd00cec5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/coverage/coverage-7.15.0-py3-none-any.whl", hash = "sha256:56da6a4cbe8f7e9e80bd072ca9cefe67d7106a440a7ec06519ec6507ac94ad19" },
 ]

 [[package]]
@@ -459,11 +460,11 @@ wheels = [

 [[package]]
 name = "filelock"
-version = "3.29.4"
+version = "3.29.5"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/filelock/filelock-3.29.4.tar.gz", hash = "sha256:10cdb3656fc44541cdf30652a93fb10ec6b05325620eb316bd26893e4201538a" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/filelock/filelock-3.29.5.tar.gz", hash = "sha256:6e6034c57a00a020e767f2614a5539863f056de7e7991d6d1473aef7ff73f156" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/filelock/filelock-3.29.4-py3-none-any.whl", hash = "sha256:dac1648087d5115554850d113e7dd8c83ab2d38e3435dde2d4f163847e57b767" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/filelock/filelock-3.29.5-py3-none-any.whl", hash = "sha256:8af830889ba3a0ffcefbd6c7d2af8a54012058103771f2e10848222f476a1693" },
 ]

 [[package]]
@@ -553,74 +554,76 @@ wheels = [

 [[package]]
 name = "joserfc"
-version = "1.7.1"
+version = "1.7.2"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
 dependencies = [
    { name = "cryptography" },
 ]
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/joserfc/joserfc-1.7.1.tar.gz", hash = "sha256:77d0b76514879c68c6f433bc5b7357a4ab72008ff1e33d8379fd11d72bd8ca81" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/joserfc/joserfc-1.7.2.tar.gz", hash = "sha256:537ffb8888b2df039cb5b6d017d7cff6f09d521ce65d89cc9b8ab752b1cff947" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/joserfc/joserfc-1.7.1-py3-none-any.whl", hash = "sha256:b3e3d655612e2e1ef67b2600f2f420e12e537b020208fab1761fad647319c164" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/joserfc/joserfc-1.7.2-py3-none-any.whl", hash = "sha256:ddd818c0ca9b4f17bbc2d72cb3966e6ded7502be089316c62c3cc64ae86132b5" },
 ]

 [[package]]
 name = "librt"
-version = "0.11.0"
+version = "0.12.0"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0.tar.gz", hash = "sha256:cb26faedbd09c6130e9c1b64d8000efec5076ffd18d606c6cd1cf02730e6d8b0" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b87504f1690a23b9a2cca841191a04f83895d4fc2dd04df91d82b1a04ca2ad46" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40071fc5fe0ce8daa6de616702314a01e1250711682b0523d6ab8d4525910cb3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:137e79445c896a0ea7b265f52d23954e05b64222ee1af69e2cb34219067cbb67" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:cca6644054e78746d8d4ef238681f9c34ff8b584fe6b988ecebb8db3b15e622a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5b0eea49f5562861ee8d757a32ef7d559c1d35be2aaaa1ec28941d74c9ffc8a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d1029d7e1ae1a7e647ed6fb5df8c4ce2dffefb7a9f5fd1376a4554d96dac09f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc3ce6b33c5828d9e80592011a5c584cb2ce86edbc4088405f70da47dc1d1b3b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:936c5995f3514a42111f20099397d8177c79b4d7e70961e396c6f5a0a3566766" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9bc0ca6ad9381cbe8e4aa6e5726e4c80c78115a6e9723c599ed1d73e092bc49d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:070aa8c26c0a74774317a72df8851facc7f0f012a5b406557ac56992d92e1ec8" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-win32.whl", hash = "sha256:6bf14feb84b05ae945277395451998c89c54d0def4070eb5c08de544930b245a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:75672f0bc524ede266287d532d7923dbce94c7514ad07627bac3d0c6d92cc4d9" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f10cf143e4a9bb0f4f5af568a00df94a2d69ef41c2579584454bb0fe5cc642c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78dc31f7fdfe9c9d0eb0e8f42d139db230e826415bbcabd9f0e9faaaee909894" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa475675db22290c3158e1d42326d0f5a65f04f44a0e68c3630a25b53560fb9c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:621db29691044bdeda22e789e482e1b0f3a985d90e3426c9c6d17606416205ea" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a9010e2ed5b3a9e158c5fd966b3ab7e834bb3d3aacc8f66c91dd4b57a3799230" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c39513d8b7477a2e1ed8c43fc21c524e8d5a0f8d4e8b7b074dbdbe7820a08e2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7aef3cf1d5af86e770ab04bfd993dfc4ae8b8c17f66fb77dd4a7d50de7bbb1a3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:557183ddc36babe46b27dd60facbd5adb4492181a5be887587d57cda6e092f21" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:83d3e1f72bd42f6c5c0b7daec530c3f829bd02db42c70b8ddf0c2d90a2459930" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4ce1f21fbe589bc1afd7872dece84fb0e1144f794a288e58a10d2c54a55c43be" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b09f7044ea2b64c9da42fd3d335666518cfd1c6e8a182c95da73d0214b41e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-win32.whl", hash = "sha256:78fddc31cd4d3caa897ad5d31f856b1faadc9474021ad6cb182b9018793e254e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ca8aa88751a775870b764e93bad5135385f563cb8dcee399abf034ea4d3cb47" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:96f044bb325fd9cf1a723015638c219e9143f0dfbc0ca54c565df2b7fc748b44" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4a017a95e5837dc15a8c5661d60e05daa96b90908b1aa6b7acdf443cd25c8ebd" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b1ecbd9819deccc39b7542bf4d2a740d8a620694d39989e58661d3763458f8d4" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7da327dacd7be8f8ec36547373550744a3cc0e536d54665cd83f8bcd961200e8" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0dc56b1f8d06e60db362cc3fdae206681817f86ce4725d34511473487f12a34b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05fb8fb2ab90e21c8d12ea240d744ad514da9baf381ebfa70d91d20d21713175" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cae74872be221df4374d10fec61f93ed1513b9546ea84f2c0bf73ab3e9bd0b03" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32bcc918c0148eb7e3d57385125bac7e5f9e4359d05f07448b09f6f778c2f31c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f9743fc99135d5f78d2454435615f6dec0473ca507c26ce9d92b10b562a280d3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5ba067f4aadae8fda802d91d2124c90c42195ff32d9161d3549e6d05cfe26f96" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:de3bf945454d032f9e390b85c4072e0a0570bf825421c8be0e71209fa65e1abe" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-win32.whl", hash = "sha256:d2277a05f6dcb9fd13db9566aac4fabd68c3ea1ea46ee5567d4eef8efa495a2f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:ab73e8db5e3f564d812c1f5c3a175930a5f9bc96ccb5e3b22a34d7858b401cf7" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aea3caa317752e3a466fa8af45d91ee0ea8c7fdd96e42b0a8dd9b76a7931eba1" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d1b36540d7aaf9b9101b3a6f376c8d8e9f7a9aec93ed05918f2c69d493ffef72" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efbb343ab2ce3540f4ecbe6315d677ed70f37cd9a72b1e58066c918ca83acbaa" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0dd688aab3f7914d3e6e5e3554978e0383312fb8e771d84be008a35b9ee548" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f5fb36b8c6c63fdcbb1d526d94c0d1331610d43f4118cc1beb4efef4f3faacb2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a9a237d13addb93715b6fee74023d5ee3469b53fce527626c0e088aa585805f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5ddd17bd87b2c56ddd60e546a7984a2e64c4e8eab92fb4cf3830a48ad5469d51" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd43992b4473d42f12ff9e68326079f0696d9d4e6000e8f39a0238d482ba6ee2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:f8e3e8056dd674e279741485e2e512d6e9a751c7455809d0114e6ebf8d781085" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c1f708d8ae9c56cf38a903c44297243d2ec83fd82b396b977e0144a3e76217e3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0add982e0e7b9fc14cf4b33789d5f13f66581889b88c2f58099f6ce8f92617bd" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:2b481d846ac894c4e8403c5fd0e87c5d11d6499e404b474602508a224ff531c8" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:28edb433edde181112a908c78907af28f964eabc15f4dd16c9d66c834302677c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dee008f20b542e3cd162ba338a7f9ec0f6d23d395f66fe8aeeec3c9d067ea253" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9bce19aa7c05f91c989f9da7b567f81d21d57a2e6501e2b811aa0f3f79614c1a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0ace09f5bf4d982fe726015f102fb856658b41580597104e301e630ed1d8d86" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d007efe9243ede81ce75990ad7aa172da1e2024144b3eff17ba46a5fff1fff3c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:ad324a5e4858388a4864915b90a42efc8b374376393f14b9940f2454e791912b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10a40cf74cdd97b6f8f905056db73f5d459783de2ca04c6ebd1bf47652818e7e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:92e61c09de95217ae02a9d17f4f66cf073253cdc51bcfdc0f15c62c9a70baa85" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0461344061d6fc3718940f5855d95647831cef6d03a6c7506897f98222784ad4" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e6dfe89074732c9287b3c0f5a6af575c9ede380a788013876cc7b14fe0da0361" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9efed79d51ad1383bba0855f613cca7aa91c943e709af2413ac7f4bb9936ce08" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1eac6cc0e23e448fb3c1446ed85ff796afb616eed5897c978d35dbec030b7c7c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-win32.whl", hash = "sha256:0ab8ee0210047ae86ca023ccfbfe3df82077fd1c9bc021aebbf37d993ef64af0" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:51c8bfa12632c81b94401c101bcedd0c56c3a1f8fa3273ca3472b28cd2f54003" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp312-cp312-win_arm64.whl", hash = "sha256:5eebd451f5def089369ba6d8ff0291303d035e8154f9f26f7633835c5b029ade" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8d9a55760a34ae5ce70434aabb6a6c61c6c44a0ec58ca1cfd9cd86e4745d417d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ff0b197e338b4cf432873e0d6ef025213fdea85311ec4d87d2ea88c28adf2409" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e69f120a20b69e2539d603bbd4d62db38399b10f8bf73a1cf445038a621e8af" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:fde3cde595e947fc8e755b0a21f919a1622483d07c662d00496e040773d22591" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d977447315fa09ea4e8c7ae9b4e22f7659b5128161c1fd55ff786b5349f73503" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ffac8a67e4143cea9a549d4822b93bc0bbaad73fc25aa0ab0ba5ec27d178677" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:94af1ed773ff104ef08ef3d669a0ba9d3a5916c609eb698cffe5d5476d66ff9b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:548199d21d22fb26398dfbbe0ba953a52465c66f3a49f38e6fddce1b127faf53" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c8f1f413b966a9dd3ecf80cd337b0ad7bb3de2474a4ff448ed3ebabfc3f803fc" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:55f13f95b629be5b6ab38918e439bf14169d6f9a8deaae55e0c14e12fb0c74b9" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:8b2dc079dfe29e77a47a19073d2040fa4879aa3656501f1650f8402ddce0313c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-win32.whl", hash = "sha256:da58944be8270f2bfee628a9a2a60c1cf6a12c8bea8e2c9b6edf3e5414ca7793" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:1db4be3037e4ce065a071fa7deee93e78ebc25f448340a02a6c1c0b82c37e383" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:05fd2542892ad770b5dd45003fd080477cf220b611d3ee59b0792097eb0873a9" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b37ee42e09722284a6d9288fe44a191f7276060a3195939bb77c6502058dbb34" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ade11988728b3e4768dadc5696e82c60e9b35fc95335a9b4d1f5d69e753ccec7" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f351ed425380e39bd86df382578aa5b8c5b98e2e265112de7379e7d030258150" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:857d2163e088c868967717ace8e980017fd868a735f3de010412af02bdc30319" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2befc80aa5f2f5b93f28abaaf11feff6677931dd548320e44c52deaa9399744" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:be3694dcfa97c6715dd19ac73d3e1b21a805514a5785663e57fecacd3ff64e5a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2d5f67e86f45638843d025b0828f2e9e55fc45ff9180d2618ccdeaf72a796050" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:64572c85e4ab7d572c9b72cd76b5f90b21181b1459fa6b1aac6f8958c4fcff31" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:8b961912b0e688c1eb4658a46bdb0606b31918d65597fbe7356ca83aa653ffcc" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:722375903e3f079436a7a33da51ce73931536dd041f9feb01536f05d8e010c96" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:a5a96a8f536b65ef1bf910c09e7e71647edde5111f6e1b51f413c6fba5bfe71b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-win32.whl", hash = "sha256:8ffc99c356f1777c506e1b69dc303879153ae2640ba15b8f3d4448bc87139149" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:1e68fb20798f455cda41d20a306a23c901218883f17a4bab1ed6e1331b265fb7" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:2df534f97916cf38ec9b1ddafeb68ae1a4cd4a54775ff26a797026774c0517cf" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c09e581b1c2b8a62b809d4f4bd101ca3de93791e5b0ed1a14085d911be3dee3f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:976888d0d831402086e641018bcc3208e0a38f0835789da91f72894b2cb4161f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:563c37cdb41d08fe1e3f08b201abac0e317ca18e88b91285466ee0a585797520" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b97eb1a3140e279cc76f85b0fb92b7eb3dfbe0471260ee878bc9dc4bf9a0d649" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:06e0623351ab9904cf628245f99c714586f4dd23dc740b88c8bc670d8401a847" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:da12f017b2e404554be14d466cd992459feaa44f252b0f18d909a85266ce1237" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d97f31003a5c86b9e78155a829572c3a26484064fb7ac1d9695fe628bd93d029" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:bd43a6c69876aef4f04eaae3d3b99b0be64755fda274002fa445b92480bf664e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c01755c72fca1dc6b8d5c2ed228b8e7b2ffe184675c22f0f05ebd8fe188b9250" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:625ae561d5fa36400856dcc27464400d047bc2d5e3446be88f437b03fefd72e4" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-win32.whl", hash = "sha256:8d73191883553ee0739741544bf3b00aba2a1224e45d9580b30cbc29e21dc03b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e1cbb037324e759f0afa270229731ff0047772667f3cb38ef5df2cabf0175ede" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/librt/librt-0.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bca1472acbd473eff61059b4409f802c5a1bcb4cd0344d06f939df9c4c125d40" },
 ]

 [[package]]
@@ -1031,15 +1034,15 @@ wheels = [

 [[package]]
 name = "python-discovery"
-version = "1.4.2"
+version = "1.4.3"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
 dependencies = [
    { name = "filelock" },
    { name = "platformdirs" },
 ]
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/python-discovery/python_discovery-1.4.2.tar.gz", hash = "sha256:8f3746c4b4968d22afbb97d36e1a0e5b66e6c0f297290f2e95f05b9b8bf18690" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/python-discovery/python_discovery-1.4.3.tar.gz", hash = "sha256:ad57d7045a862460d4a235986c33f13ed707d3aeb9153fa47eb7dfd0d4673289" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/python-discovery/python_discovery-1.4.2-py3-none-any.whl", hash = "sha256:475803f53b7b2ed6e490e27373f9d8340f7d2eebf9acdaf645d7d714c97bb500" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/python-discovery/python_discovery-1.4.3-py3-none-any.whl", hash = "sha256:b6e1e4a7d9e3f6948c39746ffe8218225162d738ba39d05ab1d2f6c1cac4878c" },
 ]

 [[package]]
@@ -1053,9 +1056,10 @@ wheels = [

 [[package]]
 name = "python-repositories"
-version = "0.3.1"
+version = "2.0.2"
 source = { editable = "." }
 dependencies = [
+    { name = "python-dotenv" },
    { name = "python-utils" },
    { name = "structlog" },
 ]
@@ -1084,6 +1088,7 @@ dev = [
 [package.metadata]
 requires-dist = [
    { name = "minio", marker = "extra == 'minio'", specifier = ">=7.2.16" },
+    { name = "python-dotenv", specifier = ">=1.0.0" },
    { name = "python-utils", specifier = ">=0.1.0", index = "https://gitea.lille-vemmelund.dk/api/packages/brian/pypi/simple/" },
    { name = "redis", marker = "extra == 'redis'", specifier = ">=6.4.0" },
    { name = "structlog", specifier = ">=25.4.0" },
@@ -1200,90 +1205,90 @@ wheels = [

 [[package]]
 name = "regex"
-version = "2026.5.9"
+version = "2026.6.28"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9.tar.gz", hash = "sha256:a8234aa23ec39894bfe4a3f1b85616a7032481964a13ac6fc9f10de4f6fca270" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28.tar.gz", hash = "sha256:3cb4b6c5cb3060cc31efdc1fbb27c25fb9b29044afd87e40601a1c4d9db54342" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57eeeb05db7979413dec5438f2db21d7ecbba787cde7a711df1a6f6df672aa06" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:398c521292f4c7fb807001dcd54694d3a1fcafc179a36ad9cc56f98df85930b6" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f7a7c26137296beba7784de6eba69c6a93a63ccebc385e4962fe67e267a91225" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6441cc660d76107934a09c22167200839a0e89604a6297f78a974e66e931d2c0" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:91328f1c23d47595ca3ef0a7557fa129c5a23404b775c770697d2f35b33e0107" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:93a7860539414dddaefba2b40f8771765ae17949d4c7182b876ce429e11a8309" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd2810d22146b6d838acc5ec15602cb6b47920aa4e33015df3868eedfd20bab8" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:daff2bdbaf1d23e52fdff7c0b7bc2048b68f978df6a4d107ac981f94caef2e66" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4eeb011098fcb77af513dcef521a3dbecbf8849b1e38940759d293b7a93f5026" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ea9c8ecfa1b73c73b626534d6626e5340d429630943672b8480724f44e84b962" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cd2846168eb9ee3c513902bc8225409cb1caab31d04728b145171fa1625d9621" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:39617fb0cde9c0e6306dc70e3bfc096f3da793219879f7ae7aa341a69fbdcf6d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd03c4f0e33280d15cae17159b899245d6b7c53d21def19b263b39655061f5ce" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-win32.whl", hash = "sha256:164eba9b755ea6f244b0d881196fbc1fac09714e9782c9e2732b813142033c8e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-win_amd64.whl", hash = "sha256:86f40a5d6444db30a125c9c9177e6b25dad981cbc37451fd838f145e6edac92e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp312-cp312-win_arm64.whl", hash = "sha256:96f5f58b54a063d7ea9dca08e1cf57bfe10499c4d579ee672da284f57f5f0070" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d626b84406444b165fc0ba981604edea39f0588ff1f92baa23fe50799ea9afdb" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d7bdc0ab8f3dd7e1b4f9ab88634e13374669db86bb3c72e8292f07ae313f539f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a8820737949116ffff55fe18f9fc644530063ba6ebfcb8314239416e78f1347c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0fbdbac82cb3e4450d0ccde7d7a35607f4cb2dd9fba4b8b69bfaf8c9fa6aed" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:57e8915c7986aa33d25e4d3629cef711cd2863f2961b10409f0c04cb8b7d9020" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508f56a89ba9cb26e4168cbc37dbd60a28d82430a9e18ad1d25fe0883c314ca2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6d189041f15691cfa2b6c4290448ec221244d225b3f5fe9e7771b34ffcdf6e2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e82db382b44d0111b22601c509c89f64434816c9e0eef9d1989cda8cc6ff1c04" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2acfb48634f64996b57f90f39afa692ff362162722581921fe92239a59960f3c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d29eebfc9525db68cad3c97eedd7f754fa265aa5cd0cf4f863b2421e1b48fc9f" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:debb893095e944091c16e641a6e33c1b0f4cb61ab945ec5afbf53ce7068834d8" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d659eee77986549c9ea45b861c7567e44d6287c3dc9a4565478853f7b9fe2ff6" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2efa205e6d98b24d1f3ab395c11aa15cdf10935bca283d0285e0499c284fba21" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-win32.whl", hash = "sha256:f3844f134e834076677dd369976e9f5068679fcb8e50102fdf6b7ac96a3ec127" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-win_amd64.whl", hash = "sha256:3527bb4942d2c14552155406cdedd906567456821848aed1cb4933a391bf5eca" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313-win_arm64.whl", hash = "sha256:56a33f191f17d8c417f99945ebdc1e691d3af9605d86ec68c7e54a57e3e17af6" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:01f28d868834624c934b8d2e0aa1c8341337e37831f4a012f18a5afcba4cbaf3" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:48036f6374aaa79eb3b754ec29c61d1c6b1606749d705a13f8854fa2539671f6" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b96350aa424e79d4fd6b567b344dcbe2b2d6bfc48dfe7717587e1fa6d43da6ff" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3af7a4903c5c04a11a196a5aa75cdd7dd3f8508132f9fb3259d9f5908e3b88" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e87577720152d2caae19fe2baaf1f8d5ca12091e9e229f03915c37d1e4b9178" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c8b9b9d294cfea3cd19c718ade7cc93492b2c4991abd9a68d0b3477ae6d8e100" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:728d8bfd28a8845c8b6bc5dc7ce010453d206396786c0765c2740cb65f37791e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7e30b874d341fac767d7df5a0870540541c2c054b80cfaac116e8d367a8a7ff2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fd190e88a895a8901325fad284a3f74ea52b1da8525b76cc811fa9b1edf0ce2b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:8e76e8161ad00694cfce6767d5dea860c6391ac5b83e5c3a39661e696f11fc7e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ddda5340e6c01a293027dd46232fa79eaff1b48058ce7a98f572b6445b088041" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:205109e96b3cf5adf8f4cd62bedde9487feb282b9497a3535451e5a24cd706a0" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbe4579b9f08036aa7d101d1835437a20783574ac66327e6b29b4018a138081" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-win32.whl", hash = "sha256:ed2c9e8068b614c574d8d30e543d617cf5379b0535d46f97ef00e904745a08b5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-win_amd64.whl", hash = "sha256:b46b0f094dc1d3b90356c85a0bd2c9bafc4a6a190b9d6f8ddd5a033b6e088ed4" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp313-cp313t-win_arm64.whl", hash = "sha256:872acc074bd29ffc9913ecdfedf6ea77502312ca44a4aa0d3779089c6069d8de" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:1bd7587a2948b4085195d5a3374eaf4a425dc3e55784c038175355ecf3bbbf8a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:dea2e88e1cce4522496cce630e11e67b98b7076620bc4336c3f674bc21a375f4" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2099f7e7ff7b6aa3192312650a56e91cc091e49d50b04e4f6f8b6e28b3b27f1c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecd353045824e4477562a2ac718c25799cdaaa41f7aa925a806a8a3e6848a5b9" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65c8c8c37377794bd5b2f3ebe51919042bf17aec802e23c833d89782ed0c78af" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b73ab8afcf66c622db143d1c6fda4e58e4d537ee4f125229ad47b1ab80f34c0" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0de5cf193997384ed2ca6f1cd4f78055b255d93d82d5a8cd6ba0d11c10b167e4" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d641a8c9a61618047796d572a39a79b26167b0411d2c3031937b2fe2d081e2cf" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:24b2355ef5cc9aa5b8f07d17704face1c166fdcc2290fa7bd6e6c925655a8346" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a24852d3c29ad9e47593593d8a247c44ccc3d0548ef12c822d6ed0810affe676" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:916714069da19329ef7de197dcbc77bb3104145c7c2c864dbfbe318f46b88b14" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:fa411799ca8da32a8d38d020a88faa5b6f91657d284761352940ecf9f7c3bbdd" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e6da47d679b7010ef27556b6e0f99771b744936db1792a10ceac6547ae1503e" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-win32.whl", hash = "sha256:98bd73080e8756255137e1bd3f3f00295bbc5aa383c0e0f973920e9134d7c4ad" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-win_amd64.whl", hash = "sha256:ff8d372ac2acdc048d1c19916f27ee61bc5722728458ba6ca5052f2c72d51763" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314-win_arm64.whl", hash = "sha256:e1d93bf647916292e8edcec150c07ddf3dc50179ccaf770c04a7f9e452155372" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:83d0ee4a57d1c87cb549e195ec300b8f0ec3a82eba66d835e4e2ed8634fe4499" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d3d7eb5c9a7f6df82ed3cfac9beb93882a5cbcb5b8b157b56cb2b3b276574ac1" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:075160bf16658e16d35233300b8453aac25de4cbea808d22348b6979668e924d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45375819235558a4ff1c4971dc32881f022613abdb180128f5cb4768c1765a1c" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ead4b163ac30a29574510cd4b3e2e985ac5290c05fc7095557d6a5f403fc31b5" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c6e4218fbdfbcd4f6c19efca40930d24a621bf4b48cb76bc6640543bd28ef20" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6351571c8a42b505eb555c0dc47d740d0fb66977dc142919eea6f4325b7c56a0" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:002205cafd2a9e78c6290c7d1df277bf3277b3b7a30e0b4bb0dac2e2e3f7cb2d" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8abd33fef90b2a9efac5557d6033ca82d1195ed3a15fea5af15ba7b463c6a63b" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:31037c82eccb44b7ea2e9e221d7c01429430e989a1f4b91ea5a855f6017b509a" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5604dfd046dc37eca90250fc3be938b076c8059fa772ac0ed6f499b0f0fb0415" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e1b1b4e496afbb24f4a62aba855ee4f88f25578927697b340702e48c9ee6bc2" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:be3372b9df6ddecff6486d37e19095a7b4973137caf5512407a89f4455361f41" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-win32.whl", hash = "sha256:3ddd90103f9e5c471c49c7852ecc1fe27c7e45eb99e977aefe7caa4e779f4f58" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-win_amd64.whl", hash = "sha256:ca518ed29c46eecba6010b15f1b9a479314d2de409536e71b6a13aa04e3b8a77" },
-    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.5.9-cp314-cp314t-win_arm64.whl", hash = "sha256:5e41809d2683fcde7d5a8c87a6567ba1fb1ce0de9f31bff578de00a4b2d76daa" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:81cc5793ad33a10444445e8d29d3c73e752c8fb2e120772d70fcb6d41df40fe1" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e18225243250a1f7d7e5e5d883f3b96465cd79031acf5c6db902b7025f2125d9" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ecd1638b1c2db1f2d01c182a4b0d3e2e88b0e99910320a745c1727ee3638ddab" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4303ebe16b74eeb3fe2715745023266fea92fd44a23f3e7bb2fb48c7a7bbc195" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56b856b70b96c381d837f609eee442a1bd320cd2159f5c294b679552fb1a7eaf" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f74675ab76ab1d005ffba4dee308e53e89efc22be6e9f9fae5b539a3f81bdff2" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90581684565a93f7258af1e5d3f41ef20d7d7c61f2a428183a342bcb65485e38" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:28f9e6c28f9b90f6f784595a33240a57e181e61b6ee3dc259b25c61e356d1aa3" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:378a71d861fc7c8806b04ac5b133d53c0e774f92f5d9663a539872d3fa2b0417" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4cc199874ecd6267a49b111052250825bfe19b5101b23b2ba80f54efa3e0994e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b916a10431494ef4b4d62c6c89cab6426af7873125b8cd6c15811bf5fc58eec8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2e27727fba075f1e4409416d2f537d4c30fc11f012ea507f7bd74d3e19ecb57a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:700fc6a7844bb2c4149292ac79d1df8841a00acd4d45cd32c1ebc7bcc1fd0da8" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-win32.whl", hash = "sha256:03376d60b6a11aecb88a79fa2be06b40faa01c6693bc31ef69435cd4818b9463" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-win_amd64.whl", hash = "sha256:fbd2ded482bf99e6651992bbfcde460272724d4bbc49ef3d6b46d9312867ec84" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp312-cp312-win_arm64.whl", hash = "sha256:37294d3d7ddb64c7e89184b2894e0f8f0a19c514bc59513d71fe692c3a8d5fc6" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b295a83426e0e44e9e60fde99789e181bd26788a1890ae7fe2a24c69bb6246ca" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0c31665c0deb5c111557a1cac8c27bd5629e2f9e7fd5058900a03576c33b601c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6bf295f2c59de77d1ea7de053607ae4dc9ceb3d57bbb6c7ec51ef4acc4ccff94" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:17c077586770f67e05bbffeba07fbee6b2b22244f4d4caf8d94e59d574befe04" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0e6cb5a61486f9062397d2e189573b39d38ecfaed698fd9fb6e2756a8ebb8762" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e86e91a2664f44c3a4e363a7d78fb17c27d5046882e30ea5a877f5e89b28d2ba" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4dfd1331c49233998d84fc5f1f4436cf7a435a7655f6cf0f490229bb5c7254e5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cadea12805a1bce0b091c302b814207be26fb60a9c0e7f9ad2f9e21790a429fe" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5f2c1682b67ad5d2376498f2a5a2a8f782fa2e4a06d0465b5e357799806e8a20" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:64e142eb55e84868087da1375d7c36ff97d55010951849f515322a91d5fef1b4" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:abb4daabe7be63273787a62dfd6164dadf8f7a63fbec3d2730e5e5e7126d858c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ec2b2ad00ab8c16a2798cc8db80c53c4d5b8b3a2441f6cbaef06625f5ca25854" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bfc9677982c914d9085b8e1c3b3ae6e88f139fb56531c2416d6c8f338093c22b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-win32.whl", hash = "sha256:bf54bc693fc4e0530e666ba5ec4bcba14dbe8f66b7cfc15c27317d1a6e40b9a5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-win_amd64.whl", hash = "sha256:e128feaf65bf3d9eb91bec92322a8f7e4835e9c798f3e9ea4b69f4def85620e3" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313-win_arm64.whl", hash = "sha256:695873e0ea8d3815ea9e92e2c68faf039cc450e2c0a62a31afe2049eb11be767" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:189dbf9fc4252d9f1352bf4bd1bef885edb6cc4b7341df202a65f821aaa3891c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9277a4c6503390aa39cb4483b87ec0384faee0850a23b5cea33d008b5d8d83f1" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:17eddca4e8ea9af0b5739314776cdf0172a49731ab61f2e1ea66e066ddd46c97" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4466b8641e00c697aab5a73150150d2b2ea96b131c595691f42031abafd9f4d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9cfcd4b0bdcf768c498415c170d1ed2a25a99bf0b65fa253bbd02f68ceba6475" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:80c7adf1ef647f6b1e8aa2ca280e517174cd08bdf7a2e412cdfb68bd6a0917cb" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a043f5770e82283a22aed4cefef1a4e0f9dd8fd7184cb6ce0ad2e579e2134a9e" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3bd630a8dba06b55254ea5ee862194edab52ec783100d2ef1cd15a9c512fee27" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b77207e3cee13086f1906a6a2a12b41244c577e8ad9370d4b35ae1d548d354f3" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:6de82c268e5d101ee9e3ffd869924aa9a371e3a21e752cf4fa17b6ce50d219f7" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b15859e3908544fb99cf47341dcf0bfd089147d258c4c4d8a29e5b087f8085cb" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:c91487a917edd48a1ea646fdf60d7936d304f0e686fa7ea8326e47efca51d816" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4ac65f3e3a99fd8f3a4a74e7a6610acd1ce9dfe9b8a03d346a4922380d68aeb" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-win32.whl", hash = "sha256:3f6316f258bc7e6c9c2acbe9954947bbd397a81be3742a637a555f1855d6618d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-win_amd64.whl", hash = "sha256:1484bdd6fba28422df9b5ebb04055b2e1b680e8e4f08490bb21ff0f3cc50d0ab" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp313-cp313t-win_arm64.whl", hash = "sha256:3f15020f0b69cafe57baa067ff65b29acef68ff6b1670a53bef1ca11d708e02d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:f7c032b0c8a73739ff8ff1aaf30c281fa19c17bf7f1543256c8507390db7807c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f6710f512c57b84f127a23d0f59560a03b64136eff419ae1be5ab557577fe5e3" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c0013958f427bd82509a186b9ff206d66cb8d60a81fc797a4c717afd18c5b0ba" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f06cdcd6421f8e194ad312ea608020381250df9b8a57661c1b57e9e5273878" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec9689392f7494ff4e3f8e7e8522f9158f11023f337eaaf04a64542fc45bbf26" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:aa084684e6d2078bf6139e374d1fc2af5ddc1ac7122759a2db716d68169f6fd0" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:40455e6840dc4e96a6fe50f4cedc957de2752c954d91e789812be55d49be199a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:530b5c223b9ca5dd8370ac502e080aee0e4ded32be987c6564b425fb5523d581" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e0ed273ecd1a89be84466c1749bfe58609cc2a32b5d5e05006c4625ba96411b" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0ab0d5344311fc8e8667078942056c3b9c9b4a4b1cc99f2eb8a5af54554f4acc" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:eacb79625323d9f7e7925366b917f492b8356fad58f5dc4fa12ff8c21d8f4ca9" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:20f4d87702702aa1d572721e146f301660c50eef6fd6cb596e48a22b0ace17db" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e693940a3b9e6d6e4dc2a54ecaa74b74934f77af1ef95f518a74261ef7cc1bc" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-win32.whl", hash = "sha256:234a51e20ebc18ab83b2c0600cf28f2e884560a0e00f743878f0b7d8e7c4cf03" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-win_amd64.whl", hash = "sha256:7b15c437bc4604f03ceb3f8d37eae2f8930e320e1bc556b259848c639d9eec1a" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314-win_arm64.whl", hash = "sha256:c6e6f790d01380a74ad564f216c533b86504afb61bf66f2b2e11e7f1a3e287a7" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3527a72adcbe9e3600f1553b497d397c1a371d227580d41d96c3c5964109b65c" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:a644f6408692812f5ead82519eed680e08d5d546fddbd9f7d9514e3c73899aa5" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8e2fae6bb883648346f84db270dc9aafc29d8e895f62b88a75ccc83b09519820" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:debe623e09cee97ef9404575e936c610aac9bb08358c5099aaef14644a6871f2" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cc579c91fb4605773483a8d940b136bcc5b854fff44fa14a1572a038f46563f1" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e7c42be203d84ecf7d487ff23f8a61ef0eb0534fa0fc317a2fce8c065d20618f" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8184b4e2fdaf9cdfe77e38f15a4d9dc149168c9c29eb0ea17c5481d3bb80546" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:697f103104f5872d64078d8eeac59979960be8ee76115a2d3f31096312e2a400" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:714d2b1aa29beef0ddfcdc72ad0771c05326551a8bb0680b0ddf74bfaad87387" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0f09f62e450cc2f113018cc8412aeea3a120a04e1ca7e801a0d441583f9a3b06" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:731ea12d5aeb2577eaef2393d6428b995f76eb35f68a89e03e15a97719d1de19" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:51e952c8783eabd4706d0f63922f219bcfc1bef9b8cb35941c0d1a0396578858" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:43248fe4c0ab8fbb223588a0795b11268940072c97bba30ea8f9b49d8cdfde34" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-win32.whl", hash = "sha256:fc1eddc25ad23c0f1344ab280d961ac595ead48292d7c779497975942373f493" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-win_amd64.whl", hash = "sha256:ede8d8e53b6dde0a50f7eca902f0af76d87ab02a55aba7542da68ae3e5dfe83d" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/regex/regex-2026.6.28-cp314-cp314t-win_arm64.whl", hash = "sha256:4da6f6a72f8700b97a1a765e837fb7d5750bfd9f13acea7bae498f573e3a70a8" },
 ]

 [[package]]
@@ -1539,11 +1544,11 @@ wheels = [

 [[package]]
 name = "typing-extensions"
-version = "4.15.0"
+version = "4.16.0"
 source = { registry = "https://proxpi.lille-vemmelund.dk/index/" }
-sdist = { url = "https://proxpi.lille-vemmelund.dk/index/typing-extensions/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" }
+sdist = { url = "https://proxpi.lille-vemmelund.dk/index/typing-extensions/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5" }
 wheels = [
-    { url = "https://proxpi.lille-vemmelund.dk/index/typing-extensions/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" },
+    { url = "https://proxpi.lille-vemmelund.dk/index/typing-extensions/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8" },
 ]

 [[package]]