svc-infra 0.1.706__py3-none-any.whl → 1.1.0__py3-none-any.whl

svc_infra/cli/cmds/jobs/jobs_cmds.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Optional
 
 import typer
 
@@ -14,12 +13,8 @@ app = typer.Typer(help="Background jobs and scheduler commands")
 
 @app.command("run")
 def run(
-    poll_interval: float = typer.Option(
-        0.5, help="Sleep seconds between loops when idle"
-    ),
-    max_loops: Optional[int] = typer.Option(
-        None, help="Max loops before exit (for tests)"
-    ),
+    poll_interval: float = typer.Option(0.5, help="Sleep seconds between loops when idle"),
+    max_loops: int | None = typer.Option(None, help="Max loops before exit (for tests)"),
 ):
     """Run scheduler ticks and process jobs in a simple loop."""
 

svc_infra/cli/cmds/obs/obs_cmds.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import os
 import socket
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 from urllib.parse import urlparse
 
 import typer
@@ -29,9 +30,7 @@ def _run(cmd: list[str], *, env: dict | None = None):
 def _emit_local_stack(root: Path, metrics_url: str):
     write(
         root / "docker-compose.yml",
-        render_template(
-            "svc_infra.obs.providers.grafana.templates", "docker-compose.yml.tmpl", {}
-        ),
+        render_template("svc_infra.obs.providers.grafana.templates", "docker-compose.yml.tmpl", {}),
     )
     p = urlparse(metrics_url)
     prom_yml = render_template(
@@ -116,9 +115,7 @@ def up():
 
     root = Path(".obs")
     root.mkdir(exist_ok=True)
-    metrics_url = os.getenv(
-        "SVC_INFRA_METRICS_URL", "http://host.docker.internal:8000/metrics"
-    )
+    metrics_url = os.getenv("SVC_INFRA_METRICS_URL", "http://host.docker.internal:8000/metrics")
 
     cloud_url = os.getenv("GRAFANA_CLOUD_URL", "").strip()
     cloud_token = os.getenv("GRAFANA_CLOUD_TOKEN", "").strip()

svc_infra/cli/cmds/sdk/sdk_cmds.py

@@ -4,9 +4,7 @@ import subprocess
 
 import typer
 
-app = typer.Typer(
-    no_args_is_help=True, add_completion=False, help="Generate SDKs from OpenAPI."
-)
+app = typer.Typer(no_args_is_help=True, add_completion=False, help="Generate SDKs from OpenAPI.")
 
 
 def _echo(cmd: list[str]):
@@ -30,9 +28,7 @@ def _parse_bool(val: str | bool | None, default: bool = True) -> bool:
 def sdk_ts(
     openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
     outdir: str = typer.Option("sdk-ts", help="Output directory"),
-    dry_run: str = typer.Option(
-        "true", help="Print commands instead of running (true/false)"
-    ),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
 ):
     """Generate a TypeScript SDK (openapi-typescript-codegen as default)."""
     cmd = [
@@ -55,9 +51,7 @@ def sdk_py(
     openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
     outdir: str = typer.Option("sdk-py", help="Output directory"),
     package_name: str = typer.Option("client_sdk", help="Python package name"),
-    dry_run: str = typer.Option(
-        "true", help="Print commands instead of running (true/false)"
-    ),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
 ):
     """Generate a Python SDK via openapi-generator-cli with "python" generator."""
     cmd = [
@@ -84,12 +78,8 @@ def sdk_py(
 @app.command("postman")
 def sdk_postman(
     openapi: str = typer.Argument(..., help="Path to OpenAPI JSON"),
-    out: str = typer.Option(
-        "postman_collection.json", help="Output Postman collection"
-    ),
-    dry_run: str = typer.Option(
-        "true", help="Print commands instead of running (true/false)"
-    ),
+    out: str = typer.Option("postman_collection.json", help="Output Postman collection"),
+    dry_run: str = typer.Option("true", help="Print commands instead of running (true/false)"),
 ):
     """Convert OpenAPI to a Postman collection via openapi-to-postmanv2."""
     cmd = [

svc_infra/cli/foundation/runner.py

@@ -3,21 +3,20 @@ from __future__ import annotations
 import asyncio
 import shutil
 from pathlib import Path
-from typing import List, Optional
 
 
 def _has_poetry(root: Path) -> bool:
     return (root / "pyproject.toml").exists() and bool(shutil.which("poetry"))
 
 
-def candidate_cmds(root: Path, prog: str, argv: List[str]) -> List[List[str]]:
+def candidate_cmds(root: Path, prog: str, argv: list[str]) -> list[list[str]]:
     """
     Return argv lists to try in order:
       1) poetry run <prog> ...
       2) <prog> ...
       3) python -m <module> ...
     """
-    cmds: List[List[str]] = []
+    cmds: list[list[str]] = []
     if _has_poetry(root):
         cmds.append(["poetry", "run", prog, *argv])
 
@@ -25,20 +24,18 @@ def candidate_cmds(root: Path, prog: str, argv: List[str]) -> List[List[str]]:
         cmds.append([prog, *argv])
 
     py = shutil.which("python3") or shutil.which("python") or "python"
-    module = (
-        prog.replace("-", "_") + ".cli_shim"
-    )  # e.g., svc-infra -> svc_infra.cli_shim
+    module = prog.replace("-", "_") + ".cli_shim"  # e.g., svc-infra -> svc_infra.cli_shim
     cmds.append([py, "-m", module, *argv])
 
     return cmds
 
 
-async def run_from_root(root: Path, prog: str, argv: List[str]) -> str:
+async def run_from_root(root: Path, prog: str, argv: list[str]) -> str:
     """
     cd to project root and run the first working candidate command.
     Returns captured stdout+stderr text; raises on total failure.
     """
-    last_exc: Optional[BaseException] = None
+    last_exc: BaseException | None = None
     for cmd in candidate_cmds(root, prog, argv):
         try:
             proc = await asyncio.create_subprocess_exec(
@@ -56,6 +53,4 @@ async def run_from_root(root: Path, prog: str, argv: List[str]) -> str:
         except Exception as e:
             last_exc = e
             continue
-    raise RuntimeError(
-        f"All runners failed in {root} for: {prog} {' '.join(argv)}"
-    ) from last_exc
+    raise RuntimeError(f"All runners failed in {root} for: {prog} {' '.join(argv)}") from last_exc

svc_infra/cli/foundation/typer_bootstrap.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
 
 import typer
 
@@ -12,7 +11,7 @@ from svc_infra.app.root import resolve_project_root
 def pre_cli(app: typer.Typer) -> None:
     @app.callback()
     def _bootstrap(
-        env_file: Optional[Path] = typer.Option(
+        env_file: Path | None = typer.Option(
             None,
             "--env-file",
             dir_okay=False,

svc_infra/data/__init__.py

@@ -0,0 +1,83 @@
+"""Data lifecycle module for backup verification, retention, and GDPR erasure.
+
+This module provides data lifecycle management primitives:
+
+- **add_data_lifecycle**: FastAPI integration for auto-migration and fixtures
+- **Backup**: Backup health verification utilities
+- **Retention**: Data retention policies and purge execution
+- **Erasure**: GDPR-compliant data erasure workflows
+- **Fixtures**: Fixture loading with run-once semantics
+
+Example:
+    from fastapi import FastAPI
+    from svc_infra.data import add_data_lifecycle, make_on_load_fixtures
+
+    app = FastAPI()
+
+    # Enable auto-migration and fixture loading
+    add_data_lifecycle(
+        app,
+        auto_migrate=True,
+        on_load_fixtures=make_on_load_fixtures(load_seed_data),
+    )
+
+    # Define retention policies
+    from svc_infra.data import RetentionPolicy, run_retention_purge
+
+    policies = [
+        RetentionPolicy(name="old_logs", model=AuditLog, older_than_days=90),
+        RetentionPolicy(name="expired_tokens", model=RefreshToken, older_than_days=30),
+    ]
+
+    # Run in a scheduled job
+    affected = await run_retention_purge(session, policies)
+
+    # GDPR erasure
+    from svc_infra.data import ErasurePlan, ErasureStep, run_erasure
+
+    plan = ErasurePlan(steps=[
+        ErasureStep(name="anonymize_user", run=anonymize_user_data),
+        ErasureStep(name="delete_logs", run=delete_user_logs),
+    ])
+    await run_erasure(session, principal_id="user_123", plan=plan)
+
+See Also:
+    - docs/data-lifecycle.md for detailed documentation
+"""
+
+from __future__ import annotations
+
+# FastAPI integration
+from .add import add_data_lifecycle
+
+# Backup verification
+from .backup import BackupHealthReport, make_backup_verification_job, verify_backups
+
+# GDPR erasure
+from .erasure import ErasurePlan, ErasureStep, run_erasure
+
+# Fixture loading
+from .fixtures import make_on_load_fixtures, run_fixtures
+
+# Retention policies
+from .retention import RetentionPolicy, purge_policy, run_retention_purge
+
+__all__ = [
+    # FastAPI integration
+    "add_data_lifecycle",
+    # Backup
+    "BackupHealthReport",
+    "verify_backups",
+    "make_backup_verification_job",
+    # Retention
+    "RetentionPolicy",
+    "purge_policy",
+    "run_retention_purge",
+    # Erasure
+    "ErasureStep",
+    "ErasurePlan",
+    "run_erasure",
+    # Fixtures
+    "run_fixtures",
+    "make_on_load_fixtures",
+]

svc_infra/data/add.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import Callable, Iterable, Optional
+from collections.abc import Callable, Iterable
 
 from fastapi import FastAPI
 
@@ -13,11 +13,11 @@ def add_data_lifecycle(
     *,
     auto_migrate: bool = True,
     database_url: str | None = None,
-    discover_packages: Optional[list[str]] = None,
+    discover_packages: list[str] | None = None,
     with_payments: bool | None = None,
-    on_load_fixtures: Optional[Callable[[], None]] = None,
-    retention_jobs: Optional[Iterable[Callable[[], None]]] = None,
-    erasure_job: Optional[Callable[[str], None]] = None,
+    on_load_fixtures: Callable[[], None] | None = None,
+    retention_jobs: Iterable[Callable[[], None]] | None = None,
+    erasure_job: Callable[[str], None] | None = None,
 ) -> None:
     """
     Wire data lifecycle conveniences:

svc_infra/data/backup.py

@@ -1,20 +1,20 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from datetime import datetime, timezone
-from typing import Callable, Optional
+from datetime import UTC, datetime
 
 
 @dataclass(frozen=True)
 class BackupHealthReport:
     ok: bool
-    last_success: Optional[datetime]
-    retention_days: Optional[int]
+    last_success: datetime | None
+    retention_days: int | None
     message: str = ""
 
 
 def verify_backups(
-    *, last_success: Optional[datetime] = None, retention_days: Optional[int] = None
+    *, last_success: datetime | None = None, retention_days: int | None = None
 ) -> BackupHealthReport:
     """Return a basic backup health report.
 
@@ -27,12 +27,10 @@ def verify_backups(
             retention_days=retention_days,
             message="no_backup_seen",
         )
-    now = datetime.now(timezone.utc)
+    now = datetime.now(UTC)
     age_days = (now - last_success).total_seconds() / 86400.0
     ok = retention_days is None or age_days <= max(1, retention_days)
-    return BackupHealthReport(
-        ok=ok, last_success=last_success, retention_days=retention_days
-    )
+    return BackupHealthReport(ok=ok, last_success=last_success, retention_days=retention_days)
 
 
 __all__ = ["BackupHealthReport", "verify_backups"]
@@ -41,7 +39,7 @@ __all__ = ["BackupHealthReport", "verify_backups"]
 def make_backup_verification_job(
     checker: Callable[[], BackupHealthReport],
     *,
-    on_report: Optional[Callable[[BackupHealthReport], None]] = None,
+    on_report: Callable[[BackupHealthReport], None] | None = None,
 ):
     """Return a callable suitable for scheduling in a job runner.
 

svc_infra/data/erasure.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Iterable, Optional, Protocol
+from typing import Any, Protocol
 
 
 class SqlSession(Protocol):  # minimal protocol for tests/integration
@@ -25,7 +26,7 @@ async def run_erasure(
     principal_id: str,
     plan: ErasurePlan,
     *,
-    on_audit: Optional[Callable[[str, dict[str, Any]], None]] = None,
+    on_audit: Callable[[str, dict[str, Any]], None] | None = None,
 ) -> int:
     """Run an erasure plan and optionally emit an audit event.
 

svc_infra/data/fixtures.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import inspect
+from collections.abc import Awaitable, Callable, Iterable
 from pathlib import Path
-from typing import Awaitable, Callable, Iterable, Optional
 
 
 async def run_fixtures(
     loaders: Iterable[Callable[[], None | Awaitable[None]]],
     *,
-    run_once_file: Optional[str] = None,
+    run_once_file: str | None = None,
 ) -> None:
     """Run a sequence of fixture loaders (sync or async).
 
@@ -29,7 +29,7 @@ async def run_fixtures(
 
 
 def make_on_load_fixtures(
-    *loaders: Callable[[], None | Awaitable[None]], run_once_file: Optional[str] = None
+    *loaders: Callable[[], None | Awaitable[None]], run_once_file: str | None = None
 ) -> Callable[[], Awaitable[None]]:
     """Return an async callable suitable for add_data_lifecycle(on_load_fixtures=...)."""
 

svc_infra/data/retention.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from typing import Any, Iterable, Optional, Protocol, Sequence
+from datetime import UTC, datetime, timedelta
+from typing import Any, Protocol
 
 
 class SqlSession(Protocol):  # minimal protocol for tests/integration
@@ -15,8 +16,8 @@ class RetentionPolicy:
     name: str
     model: Any  # SQLAlchemy model or test double exposing columns
     older_than_days: int
-    soft_delete_field: Optional[str] = "deleted_at"
-    extra_where: Optional[Sequence[Any]] = None
+    soft_delete_field: str | None = "deleted_at"
+    extra_where: Sequence[Any] | None = None
     hard_delete: bool = False
 
 
@@ -26,7 +27,7 @@ async def purge_policy(session: SqlSession, policy: RetentionPolicy) -> int:
     If hard_delete is False and soft_delete_field exists on model, set timestamp; else DELETE.
     Returns number of affected rows (best-effort; test doubles may return an int directly).
     """
-    cutoff = datetime.now(timezone.utc) - timedelta(days=policy.older_than_days)
+    cutoff = datetime.now(UTC) - timedelta(days=policy.older_than_days)
     m = policy.model
     where = list(policy.extra_where or [])
     created_col = getattr(m, "created_at", None)
@@ -34,11 +35,7 @@ async def purge_policy(session: SqlSession, policy: RetentionPolicy) -> int:
         where.append(created_col <= cutoff)
 
     # Soft-delete path when available and requested
-    if (
-        not policy.hard_delete
-        and policy.soft_delete_field
-        and hasattr(m, policy.soft_delete_field)
-    ):
+    if not policy.hard_delete and policy.soft_delete_field and hasattr(m, policy.soft_delete_field):
         stmt = m.update().where(*where).values({policy.soft_delete_field: cutoff})
         res = await session.execute(stmt)
         return getattr(res, "rowcount", 0)
@@ -49,9 +46,7 @@ async def purge_policy(session: SqlSession, policy: RetentionPolicy) -> int:
     return getattr(res, "rowcount", 0)
 
 
-async def run_retention_purge(
-    session: SqlSession, policies: Iterable[RetentionPolicy]
-) -> int:
+async def run_retention_purge(session: SqlSession, policies: Iterable[RetentionPolicy]) -> int:
     total = 0
     for p in policies:
         total += await purge_policy(session, p)

svc_infra/db/crud_schema.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Optional, Sequence, cast
+from typing import Any, cast
 
 from pydantic import BaseModel, ConfigDict, create_model
 
@@ -35,10 +36,10 @@ def _opt(t: type[Any]) -> tuple[Any, Any]:
 def make_crud_schemas_from_specs(
     *,
     specs: Sequence[FieldSpec],
-    read_name: Optional[str],
-    create_name: Optional[str],
-    update_name: Optional[str],
-    json_encoders: Optional[dict[type[Any], Any]] = None,
+    read_name: str | None,
+    create_name: str | None,
+    update_name: str | None,
+    json_encoders: dict[type[Any], Any] | None = None,
 ) -> tuple[type[BaseModel], type[BaseModel], type[BaseModel]]:
     ann_read: dict[str, tuple[Any, Any]] = {}
     ann_create: dict[str, tuple[Any, Any]] = {}
@@ -60,9 +61,9 @@ def make_crud_schemas_from_specs(
         if not s.exclude_from_update:
             ann_update[s.name] = _opt(s.typ)
 
-    Read = create_model(read_name or "Read", **cast(dict[str, Any], ann_read))
-    Create = create_model(create_name or "Create", **cast(dict[str, Any], ann_create))
-    Update = create_model(update_name or "Update", **cast(dict[str, Any], ann_update))
+    Read = create_model(read_name or "Read", **cast("dict[str, Any]", ann_read))
+    Create = create_model(create_name or "Create", **cast("dict[str, Any]", ann_create))
+    Update = create_model(update_name or "Update", **cast("dict[str, Any]", ann_update))
 
     cfg = ConfigDict(from_attributes=True)
     if json_encoders:

svc_infra/db/nosql/__init__.py

@@ -4,7 +4,6 @@ from svc_infra.db.nosql.resource import NoSqlResource
 
 from .repository import NoSqlRepository
 
-
 __all__ = [
     "NoSqlResource",
     "NoSqlRepository",

svc_infra/db/nosql/constants.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 # Environment variable names to look up for Mongo URL
 DEFAULT_MONGO_ENV_VARS: Sequence[str] = (

svc_infra/db/nosql/core.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
-from typing import Any, Iterable, Sequence, cast
+from typing import Any, cast
 
 try:
     from motor.motor_asyncio import AsyncIOMotorDatabase
@@ -47,7 +48,7 @@ async def _apply_indexes(
     if not indexes:
         return []
     result = await db[collection].create_indexes(list(indexes))
-    return cast(list[str], result)
+    return cast("list[str]", result)
 
 
 # collection + doc used to "lock" the chosen DB name for this app
@@ -61,9 +62,7 @@ async def assert_db_locked(
     registry = db.client.get_database(_REG_DB)
     await registry[_REG_COLL].create_index("service_id", unique=True)
 
-    doc = await registry[_REG_COLL].find_one(
-        {"service_id": service_id}, projection={"db_name": 1}
-    )
+    doc = await registry[_REG_COLL].find_one({"service_id": service_id}, projection={"db_name": 1})
     if doc is None:
         await registry[_REG_COLL].insert_one(
             {"service_id": service_id, "db_name": expected_db_name}
@@ -106,13 +105,9 @@ async def prepare_mongo(
 
     expected_db = get_mongo_dbname_from_env(required=True)
     if db.name != expected_db:
-        raise RuntimeError(
-            f"Connected to Mongo DB '{db.name}', but env says '{expected_db}'."
-        )
+        raise RuntimeError(f"Connected to Mongo DB '{db.name}', but env says '{expected_db}'.")
 
-    await assert_db_locked(
-        db, expected_db, service_id=service_id, allow_rebind=allow_rebind
-    )
+    await assert_db_locked(db, expected_db, service_id=service_id, allow_rebind=allow_rebind)
 
     # collections
     colls = [r.resolved_collection() for r in resources]
@@ -128,9 +123,7 @@ async def prepare_mongo(
             names = await _apply_indexes(db, collection=coll, indexes=idx_models)
             created_idx[coll] = names
 
-    return PrepareResult(
-        ok=True, created_collections=created_colls, created_indexes=created_idx
-    )
+    return PrepareResult(ok=True, created_collections=created_colls, created_indexes=created_idx)
 
 
 def setup_and_prepare(

svc_infra/db/nosql/indexes.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
+from collections.abc import Iterable
+from typing import Any
 
 from pymongo import ASCENDING, DESCENDING, IndexModel
 from pymongo.collation import Collation
@@ -17,12 +18,12 @@ from pymongo.collation import Collation
 #   "sparse": True/False,
 #   "background": True/False   # ignored by MongoDB 6+, harmless to pass
 # }
-Alias = Dict[str, Any]
-KeySpec = Union[str, Tuple[str, int]]
+Alias = dict[str, Any]
+KeySpec = str | tuple[str, int]
 
 
-def _normalize_keys(keys: Iterable[KeySpec]) -> List[Tuple[str, int]]:
-    out: List[Tuple[str, int]] = []
+def _normalize_keys(keys: Iterable[KeySpec]) -> list[tuple[str, int]]:
+    out: list[tuple[str, int]] = []
     for k in keys:
         if isinstance(k, tuple):
             field, dir_val = k
@@ -36,20 +37,20 @@ def _normalize_keys(keys: Iterable[KeySpec]) -> List[Tuple[str, int]]:
     return out
 
 
-def _normalize_collation(c: Optional[Dict[str, Any]]) -> Optional[Collation]:
+def _normalize_collation(c: dict[str, Any] | None) -> Collation | None:
     if not c:
         return None
     # common short form e.g. {"locale":"en","strength":2}
     return Collation(**c)
 
 
-def normalize_index(idx: Union[IndexModel, Alias]) -> IndexModel:
+def normalize_index(idx: IndexModel | Alias) -> IndexModel:
     if isinstance(idx, IndexModel):
         return idx
     keys = _normalize_keys(idx.get("keys", []))
     if not keys:
         raise ValueError("Index alias requires 'keys'.")
-    kwargs: Dict[str, Any] = {}
+    kwargs: dict[str, Any] = {}
     for k in (
         "name",
         "unique",
@@ -67,8 +68,8 @@ def normalize_index(idx: Union[IndexModel, Alias]) -> IndexModel:
 
 
 def normalize_indexes(
-    indexes: Optional[Iterable[Union[IndexModel, Alias]]],
-) -> List[IndexModel]:
+    indexes: Iterable[IndexModel | Alias] | None,
+) -> list[IndexModel]:
     if not indexes:
         return []
     return [normalize_index(i) for i in indexes]

svc_infra/db/nosql/management.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional, Type, Union, get_args, get_origin
+from typing import Any, Optional, Union, get_args, get_origin
 
 from bson import ObjectId
 from pydantic import BaseModel
@@ -24,7 +24,7 @@ def _unwrap_union(annotation: Any) -> set[type]:
     """
     origin = get_origin(annotation)
     if origin is Union:
-        return {t for t in get_args(annotation) if t is not type(None)}  # noqa: E721
+        return {t for t in get_args(annotation) if t is not type(None)}
     return {annotation} if annotation is not None else set()
 
 
@@ -37,7 +37,7 @@ def _is_objectid_like(annotation: Any) -> bool:
 
 
 def make_document_crud_schemas(
-    document_model: Type[BaseModel],
+    document_model: type[BaseModel],
     *,
     create_exclude: tuple[str, ...] = ("_id",),
     read_name: str | None = None,

svc_infra/db/nosql/mongo/client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 try:
     from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
@@ -13,8 +13,8 @@ except ImportError:  # pragma: no cover
 
 from .settings import MongoSettings
 
-_client: Optional[AsyncIOMotorClient] = None
-_db: Optional[AsyncIOMotorDatabase] = None
+_client: AsyncIOMotorClient | None = None
+_db: AsyncIOMotorDatabase | None = None
 
 
 def _require_motor() -> None:

svc_infra/db/nosql/mongo/settings.py

@@ -6,12 +6,8 @@ from pydantic import AnyUrl, BaseModel, Field
 
 
 class MongoSettings(BaseModel):
-    url: AnyUrl = Field(
-        default_factory=lambda: os.getenv("MONGO_URL", "mongodb://localhost:27017")
-    )  # type: ignore[assignment]
+    url: AnyUrl = Field(default_factory=lambda: os.getenv("MONGO_URL", "mongodb://localhost:27017"))  # type: ignore[assignment]
     db_name: str = Field(default_factory=lambda: os.getenv("MONGO_DB", ""))
-    appname: str = Field(
-        default_factory=lambda: os.getenv("MONGO_APPNAME", "svc-infra")
-    )
+    appname: str = Field(default_factory=lambda: os.getenv("MONGO_APPNAME", "svc-infra"))
     min_pool_size: int = int(os.getenv("MONGO_MIN_POOL", "0"))
     max_pool_size: int = int(os.getenv("MONGO_MAX_POOL", "100"))