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

svc_infra/dx/__init__.py

@@ -0,0 +1,58 @@
+"""Developer experience utilities for CI, changelog, and code quality checks.
+
+This module provides utilities to improve developer experience:
+
+- **CI Workflow**: Generate GitHub Actions CI workflow files
+- **Changelog**: Generate release sections from conventional commits
+- **Checks**: OpenAPI schema validation and migration verification
+
+Example:
+    from svc_infra.dx import write_ci_workflow, write_openapi_lint_config
+
+    # Generate CI workflow for a project
+    write_ci_workflow(target_dir="./myproject", python_version="3.12")
+
+    # Generate OpenAPI lint config
+    write_openapi_lint_config(target_dir="./myproject")
+
+    # Validate OpenAPI schema
+    from svc_infra.dx import check_openapi_problem_schema
+
+    check_openapi_problem_schema(path="openapi.json")
+
+    # Generate changelog section
+    from svc_infra.dx import Commit, generate_release_section
+
+    commits = [
+        Commit(sha="abc123", subject="feat: add new feature"),
+        Commit(sha="def456", subject="fix: resolve bug"),
+    ]
+    changelog = generate_release_section(version="1.0.0", commits=commits)
+    print(changelog)
+
+See Also:
+    - CLI commands: svc-infra dx openapi, svc-infra dx changelog
+"""
+
+from __future__ import annotations
+
+# CI workflow generation
+from .add import write_ci_workflow, write_openapi_lint_config
+
+# Changelog generation
+from .changelog import Commit, generate_release_section
+
+# Code quality checks
+from .checks import check_migrations_up_to_date, check_openapi_problem_schema
+
+__all__ = [
+    # CI workflow
+    "write_ci_workflow",
+    "write_openapi_lint_config",
+    # Changelog
+    "Commit",
+    "generate_release_section",
+    # Checks
+    "check_openapi_problem_schema",
+    "check_migrations_up_to_date",
+]

svc_infra/dx/add.py

@@ -43,9 +43,7 @@ jobs:
     return p
 
 
-def write_openapi_lint_config(
-    *, target_dir: str | Path, name: str = ".redocly.yaml"
-) -> Path:
+def write_openapi_lint_config(*, target_dir: str | Path, name: str = ".redocly.yaml") -> Path:
     """Write a minimal OpenAPI lint config placeholder (Redocly)."""
     p = Path(target_dir) / name
     content = """

svc_infra/dx/changelog.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from dataclasses import dataclass
 from datetime import date as _date
-from typing import Sequence
 
 
 @dataclass(frozen=True)
@@ -60,7 +60,7 @@ def generate_release_section(
         buckets.setdefault(typ, []).append(_format_item(c))
 
     lines: list[str] = [f"## v{version} - {release_date}", ""]
-    for key, title in _SECTION_ORDER + [("other", "Other")]:
+    for key, title in [*_SECTION_ORDER, ("other", "Other")]:
         items = buckets.get(key) or []
         if not items:
             continue

svc_infra/dx/checks.py

@@ -8,7 +8,7 @@ def _load_json(path: str | Path) -> dict[Any, Any]:
     import json
 
     p = Path(path)
-    return cast(dict[Any, Any], json.loads(p.read_text()))
+    return cast("dict[Any, Any]", json.loads(p.read_text()))
 
 
 def check_openapi_problem_schema(

svc_infra/health/__init__.py

@@ -37,9 +37,10 @@ from __future__ import annotations
 
 import asyncio
 import time
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from enum import StrEnum
-from typing import Any, Awaitable, Callable, Optional
+from typing import Any
 
 import httpx
 
@@ -60,8 +61,8 @@ class HealthCheckResult:
     name: str
     status: HealthStatus
     latency_ms: float
-    message: Optional[str] = None
-    details: Optional[dict[str, Any]] = None
+    message: str | None = None
+    details: dict[str, Any] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
@@ -193,7 +194,7 @@ class HealthRegistry:
             # Update latency from our timing
             result.latency_ms = (time.perf_counter() - start) * 1000
             return result
-        except asyncio.TimeoutError:
+        except TimeoutError:
             return HealthCheckResult(
                 name=name,
                 status=HealthStatus.UNHEALTHY,
@@ -208,7 +209,7 @@ class HealthRegistry:
                 message=str(e),
             )
 
-    async def check_all(self) -> "AggregatedHealthResult":
+    async def check_all(self) -> AggregatedHealthResult:
         """
         Run all registered health checks concurrently.
 
@@ -261,7 +262,7 @@ class HealthRegistry:
         *,
         timeout: float = 60.0,
         interval: float = 2.0,
-        check_names: Optional[list[str]] = None,
+        check_names: list[str] | None = None,
     ) -> bool:
         """
         Wait until all (or specified) critical checks pass.
@@ -321,7 +322,7 @@ class AggregatedHealthResult:
 
     status: HealthStatus
     checks: list[HealthCheckResult] = field(default_factory=list)
-    message: Optional[str] = None
+    message: str | None = None
 
     def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
@@ -339,7 +340,7 @@ class AggregatedHealthResult:
 # =============================================================================
 
 
-def check_database(url: Optional[str]) -> HealthCheckFn:
+def check_database(url: str | None) -> HealthCheckFn:
     """
     Create a health check for a PostgreSQL database.
 
@@ -391,7 +392,7 @@ def check_database(url: Optional[str]) -> HealthCheckFn:
                 status=HealthStatus.HEALTHY,
                 latency_ms=(time.perf_counter() - start) * 1000,
             )
-        except asyncio.TimeoutError:
+        except TimeoutError:
             return HealthCheckResult(
                 name="database",
                 status=HealthStatus.UNHEALTHY,
@@ -417,7 +418,7 @@ def check_database(url: Optional[str]) -> HealthCheckFn:
     return _check
 
 
-def check_redis(url: Optional[str]) -> HealthCheckFn:
+def check_redis(url: str | None) -> HealthCheckFn:
     """
     Create a health check for Redis.
 
@@ -465,7 +466,7 @@ def check_redis(url: Optional[str]) -> HealthCheckFn:
                     )
             finally:
                 await client.aclose()
-        except asyncio.TimeoutError:
+        except TimeoutError:
             return HealthCheckResult(
                 name="redis",
                 status=HealthStatus.UNHEALTHY,
@@ -496,7 +497,7 @@ def check_url(
     method: str = "GET",
     expected_status: int = 200,
     timeout: float = 5.0,
-    headers: Optional[dict[str, str]] = None,
+    headers: dict[str, str] | None = None,
 ) -> HealthCheckFn:
     """
     Create a health check for an HTTP endpoint.
@@ -622,7 +623,7 @@ def check_tcp(
                 status=HealthStatus.HEALTHY,
                 latency_ms=(time.perf_counter() - start) * 1000,
             )
-        except asyncio.TimeoutError:
+        except TimeoutError:
             return HealthCheckResult(
                 name=name,
                 status=HealthStatus.UNHEALTHY,
@@ -795,9 +796,7 @@ def add_startup_probe(
         else:
             # Log which checks failed
             result = await registry.check_all()
-            failed = [
-                c.name for c in result.checks if c.status == HealthStatus.UNHEALTHY
-            ]
+            failed = [c.name for c in result.checks if c.status == HealthStatus.UNHEALTHY]
             error_msg = f"Dependencies not ready after {timeout}s: {failed}"
             logger.error(error_msg)
             raise RuntimeError(error_msg)

svc_infra/http/client.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 from contextvars import ContextVar
-from typing import Any, Dict, Optional
+from typing import Any
 
 import httpx
 
@@ -22,7 +22,7 @@ def get_request_id() -> str | None:
     return _request_id_ctx.get()
 
 
-def _merge_request_id_header(headers: Dict[str, str] | None) -> Dict[str, str]:
+def _merge_request_id_header(headers: dict[str, str] | None) -> dict[str, str]:
     """Merge X-Request-Id header into headers dict if request ID is set."""
     result = dict(headers) if headers else {}
     request_id = get_request_id()
@@ -59,9 +59,9 @@ def make_timeout(seconds: float | None = None) -> httpx.Timeout:
 
 def new_httpx_client(
     *,
-    timeout_seconds: Optional[float] = None,
-    headers: Optional[Dict[str, str]] = None,
-    base_url: Optional[str] = None,
+    timeout_seconds: float | None = None,
+    headers: dict[str, str] | None = None,
+    base_url: str | None = None,
     propagate_request_id: bool = True,
     **kwargs: Any,
 ) -> httpx.Client:
@@ -71,9 +71,7 @@ def new_httpx_client(
     If propagate_request_id=True (default), X-Request-Id header is added from context.
     """
     timeout = make_timeout(timeout_seconds)
-    merged_headers = (
-        _merge_request_id_header(headers) if propagate_request_id else headers
-    )
+    merged_headers = _merge_request_id_header(headers) if propagate_request_id else headers
     # httpx doesn't accept base_url=None; only pass if non-None
     client_kwargs = {"timeout": timeout, "headers": merged_headers, **kwargs}
     if base_url is not None:
@@ -83,9 +81,9 @@ def new_httpx_client(
 
 def new_async_httpx_client(
     *,
-    timeout_seconds: Optional[float] = None,
-    headers: Optional[Dict[str, str]] = None,
-    base_url: Optional[str] = None,
+    timeout_seconds: float | None = None,
+    headers: dict[str, str] | None = None,
+    base_url: str | None = None,
     propagate_request_id: bool = True,
     **kwargs: Any,
 ) -> httpx.AsyncClient:
@@ -95,9 +93,7 @@ def new_async_httpx_client(
     If propagate_request_id=True (default), X-Request-Id header is added from context.
     """
     timeout = make_timeout(timeout_seconds)
-    merged_headers = (
-        _merge_request_id_header(headers) if propagate_request_id else headers
-    )
+    merged_headers = _merge_request_id_header(headers) if propagate_request_id else headers
     # httpx doesn't accept base_url=None; only pass if non-None
     client_kwargs = {"timeout": timeout, "headers": merged_headers, **kwargs}
     if base_url is not None:

svc_infra/jobs/__init__.py

@@ -0,0 +1,79 @@
+"""Background jobs module providing queue abstraction and worker utilities.
+
+This module provides a flexible background job system with multiple backends:
+
+- **InMemoryJobQueue**: Simple in-memory queue for tests and local development
+- **RedisJobQueue**: Production-ready Redis-backed queue with visibility timeout
+- **InMemoryScheduler**: Interval-based scheduler for periodic tasks
+
+Example:
+    from svc_infra.jobs import easy_jobs, Job
+
+    # Initialize queue and scheduler (auto-detects Redis or uses memory)
+    queue, scheduler = easy_jobs()
+
+    # Enqueue a job
+    job = queue.enqueue("send_email", {"to": "user@example.com"})
+    print(f"Enqueued job: {job.id}")
+
+    # Process jobs with a worker
+    from svc_infra.jobs import process_one
+
+    async def handler(job: Job):
+        if job.name == "send_email":
+            await send_email(job.payload["to"])
+
+    await process_one(queue, handler)
+
+Environment Variables:
+    JOBS_DRIVER: Backend driver ("memory" or "redis"), defaults to "memory"
+    REDIS_URL: Redis connection URL for redis driver
+    JOB_DEFAULT_TIMEOUT_SECONDS: Per-job execution timeout
+    JOBS_SCHEDULE_JSON: JSON array of scheduled task definitions
+
+See Also:
+    - docs/jobs.md for detailed documentation
+    - svc_infra.jobs.builtins for webhook delivery and outbox processing
+"""
+
+from __future__ import annotations
+
+# Easy setup function
+from .easy import easy_jobs
+
+# Loader for schedule configuration
+from .loader import schedule_from_env
+
+# Core queue abstractions
+from .queue import InMemoryJobQueue, Job, JobQueue
+
+# Redis-backed queue for production
+from .redis_queue import RedisJobQueue
+
+# Runner for long-lived workers
+from .runner import WorkerRunner
+
+# Scheduler for periodic tasks
+from .scheduler import InMemoryScheduler, ScheduledTask
+
+# Worker utilities
+from .worker import process_one
+
+__all__ = [
+    # Core types
+    "Job",
+    "JobQueue",
+    # Queue implementations
+    "InMemoryJobQueue",
+    "RedisJobQueue",
+    # Scheduler
+    "InMemoryScheduler",
+    "ScheduledTask",
+    # Easy setup
+    "easy_jobs",
+    # Worker utilities
+    "process_one",
+    "WorkerRunner",
+    # Configuration loader
+    "schedule_from_env",
+]

svc_infra/jobs/builtins/outbox_processor.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, Optional
+from collections.abc import Iterable
 
 from svc_infra.db.outbox import OutboxStore
 from svc_infra.jobs.queue import JobQueue
@@ -10,7 +10,7 @@ def make_outbox_tick(
     outbox: OutboxStore,
     queue: JobQueue,
     *,
-    topics: Optional[Iterable[str]] = None,
+    topics: Iterable[str] | None = None,
     job_name_prefix: str = "outbox",
 ):
     """Return an async task function to move one outbox message into the job queue.
@@ -30,9 +30,7 @@ def make_outbox_tick(
         if msg.id in dispatched:
             return
         job_name = f"{job_name_prefix}.{msg.topic}"
-        queue.enqueue(
-            job_name, {"outbox_id": msg.id, "topic": msg.topic, "payload": msg.payload}
-        )
+        queue.enqueue(job_name, {"outbox_id": msg.id, "topic": msg.topic, "payload": msg.payload})
         # mark as dispatched (bump attempts) so it won't be re-enqueued by fetch_next
         outbox.mark_failed(msg.id)
         dispatched.add(msg.id)

svc_infra/jobs/builtins/webhook_delivery.py

@@ -39,9 +39,7 @@ def make_webhook_handler(
             outbox.mark_processed(int(outbox_id))
             return
         event = payload.get("event") if isinstance(payload, dict) else None
-        subscription = (
-            payload.get("subscription") if isinstance(payload, dict) else None
-        )
+        subscription = payload.get("subscription") if isinstance(payload, dict) else None
         if event is not None and subscription is not None:
             delivery_payload = event
             url = subscription.get("url") or get_webhook_url_for_topic(topic)

svc_infra/jobs/loader.py

@@ -5,7 +5,8 @@ import importlib
 import json
 import logging
 import os
-from typing import Awaitable, Callable, cast
+from collections.abc import Awaitable, Callable
+from typing import cast
 
 from .scheduler import InMemoryScheduler
 
@@ -17,7 +18,7 @@ def _resolve_target(path: str) -> Callable[[], Awaitable[None]]:
     mod = importlib.import_module(mod_name)
     fn = getattr(mod, func_name)
     if asyncio.iscoroutinefunction(fn):
-        return cast(Callable[[], Awaitable[None]], fn)
+        return cast("Callable[[], Awaitable[None]]", fn)
 
     # wrap sync into async
     async def _wrapped():
@@ -26,9 +27,7 @@ def _resolve_target(path: str) -> Callable[[], Awaitable[None]]:
     return _wrapped
 
 
-def schedule_from_env(
-    scheduler: InMemoryScheduler, env_var: str = "JOBS_SCHEDULE_JSON"
-) -> None:
+def schedule_from_env(scheduler: InMemoryScheduler, env_var: str = "JOBS_SCHEDULE_JSON") -> None:
     data = os.getenv(env_var)
     if not data:
         return

svc_infra/jobs/queue.py

@@ -4,8 +4,8 @@ import logging
 import os
 import warnings
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, Optional, Protocol
+from datetime import UTC, datetime, timedelta
+from typing import Any, Protocol
 
 logger = logging.getLogger(__name__)
 
@@ -33,21 +33,19 @@ def _check_inmemory_production_warning(class_name: str) -> None:
 class Job:
     id: str
     name: str
-    payload: Dict[str, Any]
-    available_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    payload: dict[str, Any]
+    available_at: datetime = field(default_factory=lambda: datetime.now(UTC))
     attempts: int = 0
     max_attempts: int = 5
     backoff_seconds: int = 60  # base backoff for retry
-    last_error: Optional[str] = None
+    last_error: str | None = None
 
 
 class JobQueue(Protocol):
-    def enqueue(
-        self, name: str, payload: Dict[str, Any], *, delay_seconds: int = 0
-    ) -> Job:
+    def enqueue(self, name: str, payload: dict[str, Any], *, delay_seconds: int = 0) -> Job:
         pass
 
-    def reserve_next(self) -> Optional[Job]:
+    def reserve_next(self) -> Job | None:
         pass
 
     def ack(self, job_id: str) -> None:
@@ -72,24 +70,16 @@ class InMemoryJobQueue:
         self._seq += 1
         return str(self._seq)
 
-    def enqueue(
-        self, name: str, payload: Dict[str, Any], *, delay_seconds: int = 0
-    ) -> Job:
-        when = datetime.now(timezone.utc) + timedelta(seconds=delay_seconds)
-        job = Job(
-            id=self._next_id(), name=name, payload=dict(payload), available_at=when
-        )
+    def enqueue(self, name: str, payload: dict[str, Any], *, delay_seconds: int = 0) -> Job:
+        when = datetime.now(UTC) + timedelta(seconds=delay_seconds)
+        job = Job(id=self._next_id(), name=name, payload=dict(payload), available_at=when)
         self._jobs.append(job)
         return job
 
-    def reserve_next(self) -> Optional[Job]:
-        now = datetime.now(timezone.utc)
+    def reserve_next(self) -> Job | None:
+        now = datetime.now(UTC)
         for job in self._jobs:
-            if (
-                job.available_at <= now
-                and job.attempts >= 0
-                and job.attempts < job.max_attempts
-            ):
+            if job.available_at <= now and job.attempts >= 0 and job.attempts < job.max_attempts:
                 job.attempts += 1
                 return job
         return None
@@ -98,7 +88,7 @@ class InMemoryJobQueue:
         self._jobs = [j for j in self._jobs if j.id != job_id]
 
     def fail(self, job_id: str, *, error: str | None = None) -> None:
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         for job in self._jobs:
             if job.id == job_id:
                 job.last_error = error

svc_infra/jobs/redis_queue.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import json
 import logging
 from dataclasses import asdict
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional, cast
+from datetime import UTC, datetime
+from typing import Any, cast
 
 from redis import Redis
 
@@ -41,9 +41,7 @@ class RedisJobQueue(JobQueue):
       - {p}:dlq (LIST)          dead-letter job ids
     """
 
-    def __init__(
-        self, client: Redis, *, prefix: str = "jobs", visibility_timeout: int = 60
-    ):
+    def __init__(self, client: Redis, *, prefix: str = "jobs", visibility_timeout: int = 60):
         self._r = client
         self._p = prefix
         self._vt = visibility_timeout
@@ -63,8 +61,8 @@ class RedisJobQueue(JobQueue):
         return f"{self._p}:job:{job_id}"
 
     # Core ops
-    def enqueue(self, name: str, payload: Dict, *, delay_seconds: int = 0) -> Job:
-        now = datetime.now(timezone.utc)
+    def enqueue(self, name: str, payload: dict, *, delay_seconds: int = 0) -> Job:
+        now = datetime.now(UTC)
         job_id = str(self._r.incr(self._k("seq")))
         job = Job(id=job_id, name=name, payload=dict(payload))
         # Persist job
@@ -85,8 +83,8 @@ class RedisJobQueue(JobQueue):
         return job
 
     def _move_due_delayed_to_ready(self) -> None:
-        now_ts = int(datetime.now(timezone.utc).timestamp())
-        ids = cast(list[Any], self._r.zrangebyscore(self._k("delayed"), "-inf", now_ts))
+        now_ts = int(datetime.now(UTC).timestamp())
+        ids = cast("list[Any]", self._r.zrangebyscore(self._k("delayed"), "-inf", now_ts))
         if not ids:
             return
         pipe = self._r.pipeline()
@@ -97,10 +95,8 @@ class RedisJobQueue(JobQueue):
         pipe.execute()
 
     def _requeue_timed_out_processing(self) -> None:
-        now_ts = int(datetime.now(timezone.utc).timestamp())
-        ids = cast(
-            list[Any], self._r.zrangebyscore(self._k("processing_vt"), "-inf", now_ts)
-        )
+        now_ts = int(datetime.now(UTC).timestamp())
+        ids = cast("list[Any]", self._r.zrangebyscore(self._k("processing_vt"), "-inf", now_ts))
         if not ids:
             return
         pipe = self._r.pipeline()
@@ -113,14 +109,14 @@ class RedisJobQueue(JobQueue):
             pipe.hdel(self._job_key(jid_s), "visible_at")
         pipe.execute()
 
-    def reserve_next(self) -> Optional[Job]:
+    def reserve_next(self) -> Job | None:
         # opportunistically move due delayed jobs
         self._move_due_delayed_to_ready()
         # move timed-out processing jobs back to ready before reserving
         self._requeue_timed_out_processing()
 
         # Calculate visibility timeout BEFORE reserve to prevent race condition
-        visible_at = int(datetime.now(timezone.utc).timestamp()) + int(self._vt)
+        visible_at = int(datetime.now(UTC).timestamp()) + int(self._vt)
 
         # Try atomic reserve using Lua script if available
         # This prevents race condition where two workers could reserve the same job
@@ -139,26 +135,20 @@ class RedisJobQueue(JobQueue):
                 logger.warning("Lua script failed, using non-atomic reserve: %s", e)
                 jid = self._r.rpoplpush(self._k("ready"), self._k("processing"))
                 if jid:
-                    job_id_tmp = (
-                        jid.decode()
-                        if isinstance(jid, (bytes, bytearray))
-                        else str(jid)
-                    )
+                    job_id_tmp = jid.decode() if isinstance(jid, (bytes, bytearray)) else str(jid)
                     self._r.zadd(self._k("processing_vt"), {job_id_tmp: visible_at})
         else:
             # Non-atomic fallback (for fakeredis in tests, or older Redis versions)
             jid = self._r.rpoplpush(self._k("ready"), self._k("processing"))
             if jid:
-                job_id_tmp = (
-                    jid.decode() if isinstance(jid, (bytes, bytearray)) else str(jid)
-                )
+                job_id_tmp = jid.decode() if isinstance(jid, (bytes, bytearray)) else str(jid)
                 self._r.zadd(self._k("processing_vt"), {job_id_tmp: visible_at})
 
         if not jid:
             return None
         job_id = jid.decode() if isinstance(jid, (bytes, bytearray)) else str(jid)
         key = self._job_key(job_id)
-        data = cast(dict[Any, Any], self._r.hgetall(key))
+        data = cast("dict[Any, Any]", self._r.hgetall(key))
         if not data:
             # corrupted entry; ack and skip
             self._r.lrem(self._k("processing"), 1, job_id)
@@ -166,7 +156,7 @@ class RedisJobQueue(JobQueue):
             return None
 
         # Decode fields
-        def _get(field: str, default: Optional[str] = None) -> Optional[str]:
+        def _get(field: str, default: str | None = None) -> str | None:
             val = (
                 data.get(field.encode())
                 if isinstance(next(iter(data.keys())), bytes)
@@ -187,9 +177,7 @@ class RedisJobQueue(JobQueue):
             payload = {}
         available_at_str = _get("available_at")
         available_at = (
-            datetime.fromisoformat(available_at_str)
-            if available_at_str
-            else datetime.now(timezone.utc)
+            datetime.fromisoformat(available_at_str) if available_at_str else datetime.now(UTC)
         )
         # If exceeded max_attempts → DLQ and skip
         if attempts > max_attempts:
@@ -216,13 +204,13 @@ class RedisJobQueue(JobQueue):
 
     def fail(self, job_id: str, *, error: str | None = None) -> None:
         key = self._job_key(job_id)
-        data = cast(dict[Any, Any], self._r.hgetall(key))
+        data = cast("dict[Any, Any]", self._r.hgetall(key))
         if not data:
             # nothing to do
             self._r.lrem(self._k("processing"), 1, job_id)
             return
 
-        def _get(field: str, default: Optional[str] = None) -> Optional[str]:
+        def _get(field: str, default: str | None = None) -> str | None:
             val = (
                 data.get(field.encode())
                 if isinstance(next(iter(data.keys())), bytes)
@@ -235,7 +223,7 @@ class RedisJobQueue(JobQueue):
         attempts = int(_get("attempts", "0") or "0")
         max_attempts = int(_get("max_attempts", "5") or "5")
         backoff_seconds = int(_get("backoff_seconds", "60") or "60")
-        now_ts = int(datetime.now(timezone.utc).timestamp())
+        now_ts = int(datetime.now(UTC).timestamp())
         # DLQ if at or beyond max_attempts
         if attempts >= max_attempts:
             self._r.lrem(self._k("processing"), 1, job_id)
@@ -246,9 +234,7 @@ class RedisJobQueue(JobQueue):
         available_at_ts = now_ts + delay
         mapping: dict[str, str] = {
             "last_error": error or "",
-            "available_at": datetime.fromtimestamp(
-                available_at_ts, tz=timezone.utc
-            ).isoformat(),
+            "available_at": datetime.fromtimestamp(available_at_ts, tz=UTC).isoformat(),
         }
         self._r.hset(key, mapping=mapping)
         self._r.lrem(self._k("processing"), 1, job_id)