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

svc_infra/billing/models.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Optional
 
 from sqlalchemy import JSON, DateTime, Index, Numeric, String, UniqueConstraint, text
 from sqlalchemy.orm import Mapped, mapped_column
@@ -15,9 +14,7 @@ class UsageEvent(ModelBase):
     __tablename__ = "billing_usage_events"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    tenant_id: Mapped[str] = mapped_column(
-        String(TENANT_ID_LEN), index=True, nullable=False
-    )
+    tenant_id: Mapped[str] = mapped_column(String(TENANT_ID_LEN), index=True, nullable=False)
     metric: Mapped[str] = mapped_column(String(64), index=True, nullable=False)
     amount: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)
     at_ts: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
@@ -30,9 +27,7 @@ class UsageEvent(ModelBase):
     )
 
     __table_args__ = (
-        UniqueConstraint(
-            "tenant_id", "metric", "idempotency_key", name="uq_usage_idem"
-        ),
+        UniqueConstraint("tenant_id", "metric", "idempotency_key", name="uq_usage_idem"),
         Index("ix_usage_tenant_metric_ts", "tenant_id", "metric", "at_ts"),
     )
 
@@ -41,16 +36,10 @@ class UsageAggregate(ModelBase):
     __tablename__ = "billing_usage_aggregates"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    tenant_id: Mapped[str] = mapped_column(
-        String(TENANT_ID_LEN), index=True, nullable=False
-    )
+    tenant_id: Mapped[str] = mapped_column(String(TENANT_ID_LEN), index=True, nullable=False)
     metric: Mapped[str] = mapped_column(String(64), index=True, nullable=False)
-    period_start: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False
-    )
-    granularity: Mapped[str] = mapped_column(
-        String(8), nullable=False
-    )  # hour|day|month
+    period_start: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    granularity: Mapped[str] = mapped_column(String(8), nullable=False)  # hour|day|month
     total: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)
     updated_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
@@ -59,9 +48,7 @@ class UsageAggregate(ModelBase):
     )
 
     __table_args__ = (
-        UniqueConstraint(
-            "tenant_id", "metric", "period_start", "granularity", name="uq_usage_agg"
-        ),
+        UniqueConstraint("tenant_id", "metric", "period_start", "granularity", name="uq_usage_agg"),
     )
 
 
@@ -69,11 +56,9 @@ class Plan(ModelBase):
     __tablename__ = "billing_plans"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    key: Mapped[str] = mapped_column(
-        String(64), unique=True, index=True, nullable=False
-    )
+    key: Mapped[str] = mapped_column(String(64), unique=True, index=True, nullable=False)
     name: Mapped[str] = mapped_column(String(128), nullable=False)
-    description: Mapped[Optional[str]] = mapped_column(String(255))
+    description: Mapped[str | None] = mapped_column(String(255))
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         server_default=text("CURRENT_TIMESTAMP"),
@@ -100,14 +85,10 @@ class Subscription(ModelBase):
     __tablename__ = "billing_subscriptions"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    tenant_id: Mapped[str] = mapped_column(
-        String(TENANT_ID_LEN), index=True, nullable=False
-    )
+    tenant_id: Mapped[str] = mapped_column(String(TENANT_ID_LEN), index=True, nullable=False)
     plan_id: Mapped[str] = mapped_column(String(64), index=True, nullable=False)
-    effective_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False
-    )
-    ended_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    effective_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    ended_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         server_default=text("CURRENT_TIMESTAMP"),
@@ -119,17 +100,11 @@ class Price(ModelBase):
     __tablename__ = "billing_prices"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    key: Mapped[str] = mapped_column(
-        String(64), unique=True, index=True, nullable=False
-    )
+    key: Mapped[str] = mapped_column(String(64), unique=True, index=True, nullable=False)
     currency: Mapped[str] = mapped_column(String(8), nullable=False)
-    unit_amount: Mapped[int] = mapped_column(
-        Numeric(18, 0), nullable=False
-    )  # minor units
-    metric: Mapped[Optional[str]] = mapped_column(
-        String(64)
-    )  # null for fixed recurring
-    recurring_interval: Mapped[Optional[str]] = mapped_column(String(8))  # month|year
+    unit_amount: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)  # minor units
+    metric: Mapped[str | None] = mapped_column(String(64))  # null for fixed recurring
+    recurring_interval: Mapped[str | None] = mapped_column(String(8))  # month|year
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         server_default=text("CURRENT_TIMESTAMP"),
@@ -141,19 +116,13 @@ class Invoice(ModelBase):
     __tablename__ = "billing_invoices"
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
-    tenant_id: Mapped[str] = mapped_column(
-        String(TENANT_ID_LEN), index=True, nullable=False
-    )
-    period_start: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False
-    )
-    period_end: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False
-    )
+    tenant_id: Mapped[str] = mapped_column(String(TENANT_ID_LEN), index=True, nullable=False)
+    period_start: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    period_end: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
     status: Mapped[str] = mapped_column(String(16), index=True, nullable=False)
     total_amount: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)
     currency: Mapped[str] = mapped_column(String(8), nullable=False)
-    provider_invoice_id: Mapped[Optional[str]] = mapped_column(String(128), index=True)
+    provider_invoice_id: Mapped[str | None] = mapped_column(String(128), index=True)
     created_at: Mapped[datetime] = mapped_column(
         DateTime(timezone=True),
         server_default=text("CURRENT_TIMESTAMP"),
@@ -166,8 +135,8 @@ class InvoiceLine(ModelBase):
 
     id: Mapped[str] = mapped_column(String(64), primary_key=True)
     invoice_id: Mapped[str] = mapped_column(String(64), index=True, nullable=False)
-    price_id: Mapped[Optional[str]] = mapped_column(String(64), index=True)
-    metric: Mapped[Optional[str]] = mapped_column(String(64))
+    price_id: Mapped[str | None] = mapped_column(String(64), index=True)
+    metric: Mapped[str | None] = mapped_column(String(64))
     quantity: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)
     amount: Mapped[int] = mapped_column(Numeric(18, 0), nullable=False)
     created_at: Mapped[datetime] = mapped_column(

svc_infra/billing/quotas.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
-from typing import Annotated, Optional
+from datetime import UTC, datetime
+from typing import Annotated
 
 from fastapi import Depends, HTTPException, status
 from sqlalchemy import select
@@ -13,10 +13,8 @@ from svc_infra.api.fastapi.tenancy.context import TenantId
 from .models import PlanEntitlement, Subscription, UsageAggregate
 
 
-async def _current_subscription(
-    session: AsyncSession, tenant_id: str
-) -> Optional[Subscription]:
-    now = datetime.now(tz=timezone.utc)
+async def _current_subscription(session: AsyncSession, tenant_id: str) -> Subscription | None:
+    now = datetime.now(tz=UTC)
     row = (
         (
             await session.execute(
@@ -59,7 +57,7 @@ def require_quota(metric: str, *, window: str = "day", soft: bool = True):
             # no entitlement → unlimited
             return
         # compute current window start
-        now = datetime.now(tz=timezone.utc)
+        now = datetime.now(tz=UTC)
         if window == "day":
             period_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
             granularity = "day"

svc_infra/billing/schemas.py

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Annotated, Optional
+from typing import Annotated
 
 from pydantic import BaseModel, Field
 
 
 class UsageIn(BaseModel):
     metric: str = Field(..., min_length=1, max_length=64)
-    amount: Annotated[
-        int, Field(ge=0, description="Non-negative amount for the metric")
-    ]
-    at: Optional[datetime] = Field(
+    amount: Annotated[int, Field(ge=0, description="Non-negative amount for the metric")]
+    at: datetime | None = Field(
         default=None,
         description="Event timestamp (UTC). Defaults to server time if omitted.",
     )
@@ -33,4 +31,4 @@ class UsageAggregateRow(BaseModel):
 
 class UsageAggregatesOut(BaseModel):
     items: list[UsageAggregateRow] = Field(default_factory=list)
-    next_cursor: Optional[str] = None
+    next_cursor: str | None = None

svc_infra/cache/__init__.py

@@ -11,16 +11,23 @@ from .add import add_cache
 from .backend import get_cache
 
 # Core decorators - main public API
-from .decorators import cached  # alias for cache_read
-from .decorators import mutates  # alias for cache_write
-from .decorators import cache_read, cache_write, init_cache, init_cache_async
+from .decorators import (
+    cache_read,
+    cache_write,
+    cached,  # alias for cache_read
+    init_cache,
+    init_cache_async,
+    mutates,  # alias for cache_write
+)
 
 # Recaching functionality for advanced use cases
 from .recache import RecachePlan, recache
 
 # Resource management for entity-based caching
-from .resources import entity  # legacy alias
-from .resources import resource
+from .resources import (
+    entity,  # legacy alias
+    resource,
+)
 
 __all__ = [
     # Primary decorators developers use

svc_infra/cache/add.py

@@ -14,7 +14,8 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Any, Callable, Optional
+from collections.abc import Callable
+from typing import Any
 
 from svc_infra.cache.backend import DEFAULT_READINESS_TIMEOUT
 from svc_infra.cache.backend import get_cache as _get_cache
@@ -35,7 +36,7 @@ def _instance() -> Any:
 
 
 def _derive_settings(
-    url: Optional[str], prefix: Optional[str], version: Optional[str]
+    url: str | None, prefix: str | None, version: str | None
 ) -> tuple[str, str, str]:
     """Derive cache settings from parameters or environment variables.
 
@@ -111,9 +112,7 @@ def add_cache(
             try:
                 setattr(app.state, state_key, _instance())
             except Exception:
-                logger.debug(
-                    "Unable to expose cache instance on app.state", exc_info=True
-                )
+                logger.debug("Unable to expose cache instance on app.state", exc_info=True)
 
     async def _shutdown():
         try:
@@ -146,16 +145,14 @@ def add_cache(
     # Mark wired and expose state immediately if desired
     if hasattr(app, "state"):
         try:
-            setattr(app.state, "_svc_cache_wired", True)
+            app.state._svc_cache_wired = True
             if expose_state and not hasattr(app.state, state_key):
                 setattr(app.state, state_key, _instance())
         except Exception:
             pass
 
     if register_ok:
-        logger.info(
-            "Cache wired: url=%s namespace=%s", eff_url, f"{eff_prefix}:{eff_version}"
-        )
+        logger.info("Cache wired: url=%s namespace=%s", eff_url, f"{eff_prefix}:{eff_version}")
     else:
         # If we cannot register handlers, at least initialize now
         try:

svc_infra/cache/backend.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 from cashews import cache as _cache
 
@@ -42,10 +41,10 @@ def _full_prefix() -> str:
 
 
 def setup_cache(
-    url: Optional[str] = None,
+    url: str | None = None,
     *,
-    prefix: Optional[str] = None,
-    version: Optional[str] = None,
+    prefix: str | None = None,
+    version: str | None = None,
 ):
     """
     Configure Cashews and set a global key prefix for namespacing.
@@ -118,7 +117,9 @@ async def wait_ready(timeout: float = DEFAULT_READINESS_TIMEOUT) -> None:
         retrieved_value = await _cache.get(probe_key)
 
         if retrieved_value != PROBE_VALUE:
-            error_msg = f"Cache readiness probe failed. Expected '{PROBE_VALUE}', got '{retrieved_value}'"
+            error_msg = (
+                f"Cache readiness probe failed. Expected '{PROBE_VALUE}', got '{retrieved_value}'"
+            )
             logger.error(error_msg)
             raise RuntimeError(error_msg)
 

svc_infra/cache/decorators.py

@@ -9,7 +9,8 @@ from __future__ import annotations
 
 import inspect
 import logging
-from typing import Any, Awaitable, Callable, Iterable, Optional, Union
+from collections.abc import Awaitable, Callable, Iterable
+from typing import Any
 
 from cashews import cache as _cache
 
@@ -64,11 +65,11 @@ async def init_cache_async(
 
 def cache_read(
     *,
-    key: Union[str, tuple[str, ...]],
-    ttl: Optional[int] = None,
-    tags: Optional[Union[Iterable[str], Callable[..., Iterable[str]]]] = None,
-    early_ttl: Optional[int] = None,
-    refresh: Optional[bool] = None,
+    key: str | tuple[str, ...],
+    ttl: int | None = None,
+    tags: Iterable[str] | Callable[..., Iterable[str]] | None = None,
+    early_ttl: int | None = None,
+    refresh: bool | None = None,
 ):
     """
     Cache decorator for read operations with version-resilient key handling.
@@ -126,9 +127,7 @@ def cache_read(
         # Attempt 1: With prefix parameter (preferred)
         if namespace:
             try:
-                wrapped = _cache.cache(
-                    ttl_val, template, prefix=namespace, **cache_kwargs
-                )(func)
+                wrapped = _cache.cache(ttl_val, template, prefix=namespace, **cache_kwargs)(func)
             except TypeError as e:
                 error_msgs.append(f"prefix parameter: {e}")
 
@@ -140,28 +139,22 @@ def cache_read(
                     if namespace and not template.startswith(f"{namespace}:")
                     else template
                 )
-                wrapped = _cache.cache(ttl_val, key_with_namespace, **cache_kwargs)(
-                    func
-                )
+                wrapped = _cache.cache(ttl_val, key_with_namespace, **cache_kwargs)(func)
             except TypeError as e:
                 error_msgs.append(f"embedded namespace: {e}")
 
         # Attempt 3: Minimal fallback
         if wrapped is None:
             try:
-                key_with_namespace = (
-                    f"{namespace}:{template}" if namespace else template
-                )
+                key_with_namespace = f"{namespace}:{template}" if namespace else template
                 wrapped = _cache.cache(ttl_val, key_with_namespace)(func)
             except Exception as e:
                 error_msgs.append(f"minimal fallback: {e}")
                 logger.error(f"All cache decorator attempts failed: {error_msgs}")
-                raise RuntimeError(
-                    f"Failed to apply cache decorator: {error_msgs[-1]}"
-                ) from e
+                raise RuntimeError(f"Failed to apply cache decorator: {error_msgs[-1]}") from e
 
         # Attach key variants renderer for cache writers
-        setattr(wrapped, "__svc_key_variants__", build_key_variants_renderer(template))
+        wrapped.__svc_key_variants__ = build_key_variants_renderer(template)  # type: ignore[attr-defined]
 
         # If tags were provided as a callable, populate cashews tag sets manually.
         # This is best-effort and only affects invalidation-by-tag behavior.
@@ -191,19 +184,15 @@ def cache_read(
                         except Exception:
                             pass
                     if tag_val:
-                        await _cache.set_add(
-                            tag_key_prefix + tag_val, full_key, expire=ttl_val
-                        )
+                        await _cache.set_add(tag_key_prefix + tag_val, full_key, expire=ttl_val)
             except Exception:
                 # Don't let best-effort tag mapping break cache reads.
                 pass
 
             return result
 
-        setattr(
-            _wrapped_with_dynamic_tags,
-            "__svc_key_variants__",
-            getattr(wrapped, "__svc_key_variants__", None),
+        _wrapped_with_dynamic_tags.__svc_key_variants__ = getattr(  # type: ignore[attr-defined]
+            wrapped, "__svc_key_variants__", None
         )
         return _wrapped_with_dynamic_tags
 
@@ -219,8 +208,8 @@ cached = cache_read
 
 def cache_write(
     *,
-    tags: Union[Iterable[str], Callable[..., Iterable[str]]],
-    recache: Optional[Iterable[RecacheSpec]] = None,
+    tags: Iterable[str] | Callable[..., Iterable[str]],
+    recache: Iterable[RecacheSpec] | None = None,
     recache_max_concurrency: int = 5,
 ):
     """

svc_infra/cache/keys.py

@@ -6,7 +6,7 @@ with version-resilient handling and namespace support.
 """
 
 import logging
-from typing import Callable, Union
+from collections.abc import Callable
 
 from svc_infra.cache.backend import alias as _alias
 
@@ -15,7 +15,7 @@ from .utils import validate_cache_key
 logger = logging.getLogger(__name__)
 
 
-def build_key_template(key: Union[str, tuple[str, ...]]) -> str:
+def build_key_template(key: str | tuple[str, ...]) -> str:
     """Convert key to template string."""
     if isinstance(key, tuple):
         parts = [part for part in key if part]

svc_infra/cache/recache.py

@@ -7,9 +7,10 @@ including recache plans and execution strategies.
 
 import asyncio
 import logging
+from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import dataclass
 from inspect import Parameter, signature
-from typing import Any, Awaitable, Callable, Iterable, Optional, Union
+from typing import Any
 
 from cashews import cache as _cache
 
@@ -34,19 +35,19 @@ class RecachePlan:
     """
 
     getter: Callable[..., Awaitable[Any]]
-    include: Optional[Iterable[str]] = None
-    rename: Optional[dict[str, str]] = None
-    extra: Optional[dict[str, Any]] = None
-    key: Optional[Union[str, tuple[str, ...]]] = None
+    include: Iterable[str] | None = None
+    rename: dict[str, str] | None = None
+    extra: dict[str, Any] | None = None
+    key: str | tuple[str, ...] | None = None
 
 
 def recache(
     getter: Callable[..., Awaitable[Any]],
     *,
-    include: Optional[Iterable[str]] = None,
-    rename: Optional[dict[str, str]] = None,
-    extra: Optional[dict[str, Any]] = None,
-    key: Optional[Union[str, tuple[str, ...]]] = None,
+    include: Iterable[str] | None = None,
+    rename: dict[str, str] | None = None,
+    extra: dict[str, Any] | None = None,
+    key: str | tuple[str, ...] | None = None,
 ) -> RecachePlan:
     """
     Create a recache plan for cache warming after invalidation.
@@ -61,21 +62,17 @@ def recache(
     Returns:
         RecachePlan instance
     """
-    return RecachePlan(
-        getter=getter, include=include, rename=rename, extra=extra, key=key
-    )
+    return RecachePlan(getter=getter, include=include, rename=rename, extra=extra, key=key)
 
 
-RecacheSpec = Union[
-    Callable[..., Awaitable[Any]],
-    RecachePlan,
-    tuple[Callable[..., Awaitable[Any]], Any],  # Legacy format
-]
+RecacheSpec = (
+    Callable[..., Awaitable[Any]]
+    | RecachePlan
+    | tuple[Callable[..., Awaitable[Any]], Any]  # Legacy format
+)
 
 
-def generate_key_variants(
-    template: Union[str, tuple[str, ...]], params: dict[str, Any]
-) -> list[str]:
+def generate_key_variants(template: str | tuple[str, ...], params: dict[str, Any]) -> list[str]:
     """
     Generate all possible cache key variants for deletion.
 
@@ -184,24 +181,18 @@ def build_getter_kwargs(
                     continue
                 try:
                     if callable(source):
-                        legacy_call_kwargs[getter_param] = source(
-                            *mut_args, **mut_kwargs
-                        )
+                        legacy_call_kwargs[getter_param] = source(*mut_args, **mut_kwargs)
                     elif isinstance(source, str) and source in mut_kwargs:
                         legacy_call_kwargs[getter_param] = mut_kwargs[source]
                 except Exception as e:
-                    logger.warning(
-                        f"Recache parameter mapping failed for {getter_param}: {e}"
-                    )
+                    logger.warning(f"Recache parameter mapping failed for {getter_param}: {e}")
 
         # Add direct parameter matches
         for param_name in getter_params.keys():
             if param_name not in legacy_call_kwargs and param_name in mut_kwargs:
                 legacy_call_kwargs[param_name] = mut_kwargs[param_name]
 
-        legacy_call_kwargs = {
-            k: v for k, v in legacy_call_kwargs.items() if k in getter_params
-        }
+        legacy_call_kwargs = {k: v for k, v in legacy_call_kwargs.items() if k in getter_params}
         return getter, legacy_call_kwargs
 
     # Handle simple getter function
@@ -232,9 +223,7 @@ async def execute_recache(
                         try:
                             await _cache.delete(key_variant)
                         except Exception as e:
-                            logger.debug(
-                                f"Failed to delete cache key {key_variant}: {e}"
-                            )
+                            logger.debug(f"Failed to delete cache key {key_variant}: {e}")
 
                 # Execute the getter to warm the cache
                 await getter(**call_kwargs)
@@ -243,6 +232,4 @@ async def execute_recache(
                 logger.error(f"Recache operation failed: {e}")
 
     # Execute all recache operations concurrently
-    await asyncio.gather(
-        *[_run_single_recache(spec) for spec in specs], return_exceptions=True
-    )
+    await asyncio.gather(*[_run_single_recache(spec) for spec in specs], return_exceptions=True)

svc_infra/cache/resources.py

@@ -8,7 +8,7 @@ with standardized key patterns and tag management.
 import asyncio
 import inspect
 import logging
-from typing import Callable, Optional, Tuple
+from collections.abc import Callable
 
 from cashews import cache as _cache
 
@@ -41,8 +41,8 @@ class Resource:
         *,
         suffix: str,
         ttl: int,
-        key_template: Optional[str] = None,
-        tags_template: Optional[Tuple[str, ...]] = None,
+        key_template: str | None = None,
+        tags_template: tuple[str, ...] | None = None,
         lock: bool = True,
     ):
         """
@@ -63,9 +63,7 @@ class Resource:
 
         def _decorator(func: Callable):
             try:
-                return _cache(ttl=ttl, key=key_template, tags=tags_template, lock=lock)(
-                    func
-                )
+                return _cache(ttl=ttl, key=key_template, tags=tags_template, lock=lock)(func)
             except TypeError:
                 # Fallback for older cashews versions
                 return _cache(ttl=ttl, key=key_template, tags=tags_template)(func)
@@ -75,7 +73,7 @@ class Resource:
     def cache_write(
         self,
         *,
-        recache: Optional[list[tuple[Callable, Callable]]] = None,
+        recache: list[tuple[Callable, Callable]] | None = None,
         recache_max_concurrency: int = 5,
     ):
         """
@@ -99,9 +97,7 @@ class Resource:
             """Delete all cache keys for a specific entity."""
             namespace = _alias() or ""
             namespace_prefix = (
-                f"{namespace}:"
-                if namespace and not namespace.endswith(":")
-                else namespace
+                f"{namespace}:" if namespace and not namespace.endswith(":") else namespace
             )
 
             # Generate candidate keys to delete
@@ -137,9 +133,7 @@ class Resource:
                     # Namespaced wildcard
                     if namespace_prefix:
                         await _maybe_await(
-                            delete_match(
-                                f"{namespace_prefix}{entity_name}:*:{entity_id}*"
-                            )
+                            delete_match(f"{namespace_prefix}{entity_name}:*:{entity_id}*")
                         )
                     # Non-namespaced wildcard
                     await _maybe_await(delete_match(f"{entity_name}:*:{entity_id}*"))
@@ -178,9 +172,7 @@ class Resource:
                         # Tag invalidation
                         invalidate_func = getattr(_cache, "invalidate", None)
                         if callable(invalidate_func):
-                            await _maybe_await(
-                                invalidate_func(f"{self.name}:{entity_id}")
-                            )
+                            await _maybe_await(invalidate_func(f"{self.name}:{entity_id}"))
 
                         # Precise key deletion
                         await _delete_entity_keys(self.name, str(entity_id))

svc_infra/cache/ttl.py

@@ -6,7 +6,6 @@ via environment variables with sensible defaults.
 """
 
 import os
-from typing import Optional
 
 
 def _get_env_int(key: str, default: int) -> int:
@@ -36,7 +35,7 @@ TTL_SHORT: int = _get_env_int("CACHE_TTL_SHORT", 30)  # 30 seconds
 TTL_LONG: int = _get_env_int("CACHE_TTL_LONG", 3600)  # 1 hour
 
 
-def get_ttl(duration_type: str) -> Optional[int]:
+def get_ttl(duration_type: str) -> int | None:
     """
     Get TTL value by duration type name.
 
@@ -60,7 +59,7 @@ def get_ttl(duration_type: str) -> Optional[int]:
     return ttl_map.get(duration_type.lower())
 
 
-def validate_ttl(ttl: Optional[int]) -> int:
+def validate_ttl(ttl: int | None) -> int:
     """
     Validate and normalize a TTL value.