nexus-queue 0.1.1__py3-none-any.whl

nexus_queue/__init__.py

@@ -0,0 +1,86 @@
+"""nexus-queue — portable taskiq + Redis Streams worker runtime.
+
+Public API is intentionally small and stable: the config, the ports, the
+envelope, and the error taxonomy. The runtime pieces (broker, middleware,
+publisher, kicker) are added on top of these and re-exported as they land.
+"""
+
+from __future__ import annotations
+
+from nexus_queue.app import WorkerApp, create_worker
+from nexus_queue.broker import create_broker
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.delayed import DelayedRetryPoller
+from nexus_queue.envelope import (
+    Envelope,
+    missing_required_labels,
+    require_supported_version,
+)
+from nexus_queue.exceptions import (
+    NexusPermanentError,
+    NexusQueueError,
+    NexusRetryableError,
+)
+from nexus_queue.handlers import HandlerSpec, register
+from nexus_queue.kicker import create_kicker
+from nexus_queue.lifecycle import (
+    IdempotencyStore,
+    configure_logging,
+    register_lifecycle,
+)
+from nexus_queue.naming import (
+    NQ_VERSION,
+    SINGLE_TENANT,
+    consumer_group,
+    delayed_set,
+    dlq_stream,
+    status_stream,
+    work_stream,
+)
+from nexus_queue.pipeline import PipelineRouter
+from nexus_queue.ports import (
+    BlobStorePort,
+    IndexPort,
+    JobStatePort,
+    JobStatus,
+    StatusEvent,
+    StatusEventPort,
+)
+from nexus_queue.publisher import Publisher
+from nexus_queue.tracing import configure_tracing
+
+__all__ = [
+    "NQ_VERSION",
+    "SINGLE_TENANT",
+    "BlobStorePort",
+    "DelayedRetryPoller",
+    "Envelope",
+    "HandlerSpec",
+    "IdempotencyStore",
+    "IndexPort",
+    "JobStatePort",
+    "JobStatus",
+    "NexusPermanentError",
+    "NexusQueueError",
+    "NexusRetryableError",
+    "PipelineRouter",
+    "Publisher",
+    "RuntimeConfig",
+    "StatusEvent",
+    "StatusEventPort",
+    "WorkerApp",
+    "configure_logging",
+    "configure_tracing",
+    "consumer_group",
+    "create_broker",
+    "create_kicker",
+    "create_worker",
+    "delayed_set",
+    "dlq_stream",
+    "missing_required_labels",
+    "register",
+    "register_lifecycle",
+    "require_supported_version",
+    "status_stream",
+    "work_stream",
+]

nexus_queue/app.py

@@ -0,0 +1,47 @@
+"""Top-level factory. Consumers call ``create_worker(config, adapters, handlers)``
+and expose the returned ``broker`` to the taskiq CLI and ``app`` to uvicorn.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass
+
+from fastapi import FastAPI
+from taskiq import AsyncBroker
+
+from nexus_queue.broker import create_broker
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.handlers import HandlerSpec, register
+from nexus_queue.kicker import create_kicker
+from nexus_queue.lifecycle import configure_logging, register_lifecycle
+from nexus_queue.tracing import configure_tracing
+
+
+@dataclass(slots=True, frozen=True)
+class WorkerApp:
+    """Bundle returned by :func:`create_worker`: ``app, broker = create_worker(...)``."""
+
+    app: FastAPI
+    broker: AsyncBroker
+
+    def __iter__(self) -> Iterator[FastAPI | AsyncBroker]:
+        yield self.app
+        yield self.broker
+
+
+def create_worker(
+    config: RuntimeConfig,
+    adapters: object,
+    handlers: Sequence[HandlerSpec],
+) -> WorkerApp:
+    """Build the broker (namespaced + middleware), register lifecycle + handlers,
+    and wrap a FastAPI kicker."""
+    configure_logging(config)
+    configure_tracing(config)
+    broker = create_broker(config)
+    register_lifecycle(broker, config, adapters)
+    for spec in handlers:
+        register(broker, spec, config)
+    app = create_kicker(broker, config)
+    return WorkerApp(app=app, broker=broker)

nexus_queue/broker.py

@@ -0,0 +1,29 @@
+"""Broker factory — the one place that builds a namespaced, middleware-wrapped broker.
+
+Consumers never instantiate ``RedisStreamBroker`` directly: that is how ZP and
+nixon ended up on the default global ``"taskiq"`` stream (which collides across
+projects). Here the stream and consumer group are always
+``nq:{project}:{queue}`` / ``…:cg``.
+"""
+
+from __future__ import annotations
+
+from taskiq import AsyncBroker
+from taskiq_redis import RedisStreamBroker
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.middleware.metrics import MetricsMiddleware
+from nexus_queue.middleware.retry_dlq import RetryDlqMiddleware
+
+
+def create_broker(config: RuntimeConfig) -> AsyncBroker:
+    """Build the standard broker: namespaced streams + the Nexus-Queue middleware stack."""
+    broker: AsyncBroker = RedisStreamBroker(
+        url=config.redis_url,
+        queue_name=config.work_stream,
+        consumer_group_name=config.consumer_group,
+    )
+    return broker.with_middlewares(
+        MetricsMiddleware(config),
+        RetryDlqMiddleware(config),
+    )

nexus_queue/config.py

@@ -0,0 +1,98 @@
+"""Runtime configuration consumed by the worker runtime.
+
+A single pydantic model filled in by the consumer. No env loading inside the
+library (mirrors `agno-agent-builder` / `payload-documents-worker-builder`) so a
+multi-tenant deploy can build several `RuntimeConfig` instances from one env.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, SecretStr, ValidationInfo, field_validator
+
+from nexus_queue import naming
+
+
+class RuntimeConfig(BaseModel):
+    """Everything the runtime needs that is not a port adapter or a handler."""
+
+    app_name: str = Field(
+        description="FastAPI title and structlog identity; shows up in logs and /health.",
+    )
+
+    # ── Identity / namespacing ─────────────────────────────────────────────
+    project: str = Field(
+        description="Stable short project slug used to namespace streams, e.g. 'zp', 'nixon'.",
+    )
+    queue: str = Field(
+        description="Logical queue/pipeline name, e.g. 'documents', 'jobs'.",
+    )
+
+    # ── Broker ─────────────────────────────────────────────────────────────
+    redis_url: str = Field(
+        description="Redis URL for the taskiq-redis stream broker (e.g. redis://redis:6379).",
+    )
+
+    # ── HTTP kicker ────────────────────────────────────────────────────────
+    internal_secret: SecretStr = Field(
+        default=SecretStr(""),
+        description="Shared secret required by the kicker (X-Nexus-Secret). Empty disables the kicker auth gate.",
+    )
+    public_paths: tuple[str, ...] = Field(
+        default=("/health", "/ready", "/metrics", "/docs", "/openapi.json"),
+        description="Kicker paths served without the secret.",
+    )
+
+    # ── Retry / DLQ / idempotency ──────────────────────────────────────────
+    max_retries: int = Field(
+        default=3,
+        ge=0,
+        description="Retry attempts before a message is dead-lettered.",
+    )
+    retry_base_delay_s: float = Field(
+        default=2.0,
+        gt=0,
+        description="Base delay for the exponential backoff applied between retries.",
+    )
+    retry_poll_interval_s: float = Field(
+        default=1.0,
+        gt=0,
+        description="How often the delayed-retry poller drains due retries back onto the work stream.",
+    )
+    idempotency_ttl_s: int = Field(
+        default=86_400,
+        ge=0,
+        description="TTL of the dedup key; 0 disables the idempotency middleware.",
+    )
+    dlq_maxlen: int = Field(
+        default=100_000,
+        ge=0,
+        description="Approx MAXLEN for the dead-letter stream; 0 = unbounded.",
+    )
+
+    # ── Logging ────────────────────────────────────────────────────────────
+    log_level: str = Field(default="INFO")
+
+    @field_validator("project", "queue")
+    @classmethod
+    def _validate_slug(cls, value: str, info: ValidationInfo) -> str:
+        return naming.validate_slug(value, kind=info.field_name or "slug")
+
+    @property
+    def work_stream(self) -> str:
+        return naming.work_stream(self.project, self.queue)
+
+    @property
+    def consumer_group(self) -> str:
+        return naming.consumer_group(self.project, self.queue)
+
+    @property
+    def dlq_stream(self) -> str:
+        return naming.dlq_stream(self.project, self.queue)
+
+    @property
+    def delayed_set(self) -> str:
+        return naming.delayed_set(self.project, self.queue)
+
+    @property
+    def status_stream(self) -> str:
+        return naming.status_stream(self.project)

nexus_queue/delayed.py

@@ -0,0 +1,91 @@
+"""Delayed-retry queue: hold a failed message until its backoff elapses, then
+re-enqueue it.
+
+Redis Streams deliver immediately, so a backed-off retry can't ride the work
+stream. :class:`~nexus_queue.middleware.retry_dlq.RetryDlqMiddleware` parks the
+message in a sorted set scored by its due time; the :class:`DelayedRetryPoller`
+(started by the worker lifecycle) drains due messages back onto the broker. The
+atomic ``ZREM`` makes the move safe across worker replicas — only the one that
+removes a member re-enqueues it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import time
+from typing import Any
+
+import redis.asyncio as aioredis
+import structlog
+from taskiq import AsyncBroker
+from taskiq.kicker import AsyncKicker
+from taskiq.message import TaskiqMessage
+
+from nexus_queue.config import RuntimeConfig
+
+logger = structlog.get_logger("nexus_queue.delayed")
+
+
+def pack_retry(message: TaskiqMessage, labels: dict[str, Any]) -> str:
+    """Serialize a message (with its updated labels) for the delayed-retry set."""
+    return json.dumps(
+        {
+            "task_name": message.task_name,
+            "task_id": message.task_id,
+            "labels": labels,
+            "args": message.args,
+            "kwargs": message.kwargs,
+        }
+    )
+
+
+class DelayedRetryPoller:
+    """Moves due retries from the delayed sorted set back onto the broker."""
+
+    def __init__(self, broker: AsyncBroker, config: RuntimeConfig) -> None:
+        self._broker = broker
+        self._config = config
+        self._redis: aioredis.Redis | None = None
+        self._task: asyncio.Task[None] | None = None
+
+    async def startup(self) -> None:
+        self._redis = aioredis.from_url(self._config.redis_url)
+        self._task = asyncio.create_task(self._run())
+
+    async def shutdown(self) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._task
+        if self._redis is not None:
+            await self._redis.aclose()
+
+    async def _run(self) -> None:
+        while True:
+            try:
+                await self._drain_due()
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("delayed-poll-failed")
+            await asyncio.sleep(self._config.retry_poll_interval_s)
+
+    async def _drain_due(self) -> None:
+        if self._redis is None:
+            return
+        due = await self._redis.zrangebyscore(self._config.delayed_set, "-inf", time.time())
+        for record in due:
+            # Atomic claim: only the replica that removes the member re-enqueues it.
+            if await self._redis.zrem(self._config.delayed_set, record) == 1:
+                await self._reenqueue(json.loads(record))
+
+    async def _reenqueue(self, data: dict[str, Any]) -> None:
+        kicker: AsyncKicker[Any, Any] = AsyncKicker(
+            task_name=data["task_name"],
+            broker=self._broker,
+            labels=data["labels"],
+        ).with_task_id(data["task_id"])
+        await kicker.kiq(*data["args"], **data["kwargs"])
+        logger.info("retry-reenqueued", task=data["task_name"])

nexus_queue/envelope.py

@@ -0,0 +1,56 @@
+"""The Nexus-Queue envelope: standard labels stamped on every message.
+
+Producers build an :class:`Envelope` and turn it into the ``labels`` dict that
+rides on the taskiq message; consumers validate the version on receipt.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+
+from nexus_queue import naming
+from nexus_queue.exceptions import NexusPermanentError
+
+
+@dataclass(slots=True)
+class Envelope:
+    """Routing/metadata for a single enqueue. Carried in message labels, not args."""
+
+    task: str
+    tenant: str = naming.SINGLE_TENANT
+    idempotency_key: str | None = None
+    trace: str | None = None
+    priority: str = "default"
+
+    def to_labels(self) -> dict[str, str]:
+        """Render the standard labels. ``nq_enqueued_at`` is stamped now (UTC)."""
+        labels: dict[str, str] = {
+            naming.LABEL_VERSION: naming.NQ_VERSION,
+            naming.LABEL_TASK: self.task,
+            naming.LABEL_TENANT: self.tenant,
+            naming.LABEL_ENQUEUED_AT: datetime.now(UTC).isoformat(),
+            naming.LABEL_PRIORITY: self.priority,
+        }
+        if self.idempotency_key:
+            labels[naming.LABEL_IDEM] = self.idempotency_key
+        if self.trace:
+            labels[naming.LABEL_TRACE] = self.trace
+        return labels
+
+
+def require_supported_version(labels: Mapping[str, Any]) -> None:
+    """Raise :class:`NexusPermanent` (→ DLQ) if the message is a version we
+    don't speak. Keeps a future ``nq_v=2`` from being silently mishandled."""
+    version = str(labels.get(naming.LABEL_VERSION, ""))
+    if version != naming.NQ_VERSION:
+        raise NexusPermanentError(
+            f"Unsupported nq_v={version!r}; this worker speaks {naming.NQ_VERSION!r}"
+        )
+
+
+def missing_required_labels(labels: Mapping[str, Any]) -> tuple[str, ...]:
+    """Return the required labels absent from ``labels`` (empty tuple if valid)."""
+    return tuple(key for key in naming.REQUIRED_LABELS if not labels.get(key))

nexus_queue/exceptions.py

@@ -0,0 +1,15 @@
+"""Error taxonomy that drives the runtime's retry vs dead-letter decision."""
+
+from __future__ import annotations
+
+
+class NexusQueueError(Exception):
+    """Base class for every error raised by nexus-queue."""
+
+
+class NexusRetryableError(NexusQueueError):
+    """Transient failure — retry until attempts are exhausted, then dead-letter."""
+
+
+class NexusPermanentError(NexusQueueError):
+    """Non-retryable failure — route straight to the DLQ, skip remaining retries."""

nexus_queue/handlers.py

@@ -0,0 +1,80 @@
+"""Handler registration with the cross-cutting concerns that need an ``around``
+scope (which taskiq middleware hooks can't give): idempotency, tracing, latency.
+
+A handler is ``async def h(payload, deps) -> None`` — it depends only on its
+typed payload and the project's :class:`NexusAdapters`. ``register`` wraps it
+so the same handler runs unchanged in any project.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any
+
+import structlog
+from opentelemetry import trace
+from opentelemetry.propagate import extract
+from pydantic import BaseModel
+from taskiq import AsyncBroker, Context, TaskiqDepends
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.envelope import require_supported_version
+from nexus_queue.lifecycle import IdempotencyStore
+from nexus_queue.middleware.metrics import CONSUME_SECONDS
+from nexus_queue.naming import LABEL_IDEM, LABEL_TENANT, LABEL_TRACE, SINGLE_TENANT
+
+logger = structlog.get_logger("nexus_queue.handlers")
+_tracer = trace.get_tracer("nexus_queue")
+
+# deps is the project's adapter container; the handler types it to a Protocol
+# of the ports it actually uses.
+HandlerFn = Callable[[Any, Any], Awaitable[None]]
+
+
+@dataclass(slots=True)
+class HandlerSpec:
+    """Binds a wire task name to a handler and its payload model."""
+
+    task_name: str
+    handler: HandlerFn
+    payload_model: type[BaseModel]
+    idempotent: bool = True
+
+
+def register(broker: AsyncBroker, spec: HandlerSpec, config: RuntimeConfig) -> None:
+    """Register ``spec.handler`` under its wire task name, wrapped with version
+    check, idempotency dedup, an OTel consume span, and a latency histogram."""
+
+    async def _run(context: Context = TaskiqDepends(), **kwargs: Any) -> None:
+        labels = context.message.labels
+        require_supported_version(labels)
+        state = context.state
+
+        raw_idem = labels.get(LABEL_IDEM) if spec.idempotent else None
+        idem = str(raw_idem) if raw_idem else None
+        store: IdempotencyStore | None = state.nexus_idempotency if idem else None
+        if store is not None and idem and await store.already_processed(idem):
+            logger.info("duplicate-skipped", task=spec.task_name, idem=idem)
+            return
+
+        adapters = state.nexus_adapters
+        payload = spec.payload_model(**kwargs)
+
+        traceparent = labels.get(LABEL_TRACE)
+        parent = extract({"traceparent": str(traceparent)}) if traceparent else None
+        with _tracer.start_as_current_span(
+            f"nexus_queue.consume {spec.task_name}",
+            context=parent,
+        ) as span:
+            span.set_attribute("nq.task", spec.task_name)
+            span.set_attribute("nq.tenant", str(labels.get(LABEL_TENANT, SINGLE_TENANT)))
+            with CONSUME_SECONDS.labels(config.project, config.queue, spec.task_name).time():
+                await spec.handler(payload, adapters)
+
+        # Record dedup only after success: a failed attempt must stay retryable.
+        if store is not None and idem:
+            await store.mark_processed(idem)
+
+    _run.__name__ = "nexus_run_" + spec.task_name.replace(".", "_").replace(":", "_")
+    broker.task(task_name=spec.task_name)(_run)

nexus_queue/kicker.py

@@ -0,0 +1,98 @@
+"""Generic HTTP kicker for producers that can't speak Redis directly
+(e.g. a TypeScript/Payload caller). One standard contract for every project:
+``POST /enqueue/{task}`` gated by ``X-Nexus-Secret``, plus ``/health``/``/ready``.
+"""
+
+from __future__ import annotations
+
+import hmac
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+import structlog
+from fastapi import FastAPI, Request, Response, status
+from fastapi.responses import JSONResponse
+from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
+from pydantic import BaseModel, Field
+from taskiq import AsyncBroker
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.naming import SINGLE_TENANT
+from nexus_queue.publisher import Publisher
+
+logger = structlog.get_logger("nexus_queue.kicker")
+
+
+class EnqueueRequest(BaseModel):
+    payload: dict[str, Any] = Field(default_factory=dict)
+    tenant: str = SINGLE_TENANT
+    idempotency_key: str | None = None
+    priority: str = "default"
+    trace: str | None = None
+
+
+def create_kicker(broker: AsyncBroker, config: RuntimeConfig) -> FastAPI:
+    """Build the FastAPI kicker the consumer hands to uvicorn."""
+
+    @asynccontextmanager
+    async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+        # Fail-open is allowed (some deploys front the kicker with a mesh), but it
+        # must never be silent: an empty secret leaves /enqueue unauthenticated.
+        if not config.internal_secret.get_secret_value():
+            logger.warning(
+                "kicker-auth-disabled",
+                detail="internal_secret is empty; /enqueue is unauthenticated",
+            )
+        # The kicker connects the broker; the worker process owns its own lifecycle.
+        if not broker.is_worker_process:
+            await broker.startup()
+        yield
+        if not broker.is_worker_process:
+            await broker.shutdown()
+
+    app = FastAPI(title=config.app_name, lifespan=lifespan)
+    publisher = Publisher(broker, config)
+
+    @app.middleware("http")
+    async def _auth(request: Request, call_next: Any) -> Any:  # pyright: ignore[reportUnusedFunction]
+        if request.url.path in config.public_paths:
+            return await call_next(request)
+        secret = config.internal_secret.get_secret_value()
+        if secret:
+            provided = request.headers.get("x-nexus-secret", "")
+            if not hmac.compare_digest(provided, secret):
+                return JSONResponse(
+                    {"error": "Forbidden"},
+                    status_code=status.HTTP_403_FORBIDDEN,
+                )
+        return await call_next(request)
+
+    @app.get("/health")
+    async def health() -> dict[str, str]:  # pyright: ignore[reportUnusedFunction]
+        return {"status": "ok"}
+
+    @app.get("/ready")
+    async def ready() -> dict[str, str]:  # pyright: ignore[reportUnusedFunction]
+        return {"status": "ok"}
+
+    @app.get("/metrics")
+    async def metrics() -> Response:  # pyright: ignore[reportUnusedFunction]
+        return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)
+
+    @app.post("/enqueue/{task}", status_code=status.HTTP_202_ACCEPTED)
+    async def enqueue(  # pyright: ignore[reportUnusedFunction]
+        task: str,
+        body: EnqueueRequest,
+    ) -> dict[str, str]:
+        task_id = await publisher.enqueue_raw(
+            task,
+            body.payload,
+            tenant=body.tenant,
+            idempotency_key=body.idempotency_key,
+            priority=body.priority,
+            trace=body.trace,
+        )
+        return {"status": "queued", "task": task, "task_id": task_id}
+
+    return app

nexus_queue/lifecycle.py

@@ -0,0 +1,104 @@
+"""Worker lifecycle: logging, dependency injection, and the idempotency store.
+
+``register_lifecycle`` wires the project's adapters and a Redis-backed
+idempotency store into the worker ``state`` on startup, where the handler
+wrapper (see :mod:`nexus_queue.handlers`) reads them.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import redis.asyncio as aioredis
+import structlog
+from taskiq import AsyncBroker, TaskiqEvents, TaskiqState
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.delayed import DelayedRetryPoller
+from nexus_queue.naming import idempotency_redis_key
+
+
+class IdempotencyStore:
+    """Redis mark-done dedup keyed by the message's ``nq_idem`` label.
+
+    The key is recorded only *after* a handler succeeds, so a failed attempt
+    leaves no marker and stays eligible for retry/DLQ. Claiming the key up
+    front would make a re-enqueued retry skip itself as a phantom duplicate."""
+
+    def __init__(self, config: RuntimeConfig) -> None:
+        self._config = config
+        self._redis: aioredis.Redis | None = None
+
+    async def startup(self) -> None:
+        self._redis = aioredis.from_url(self._config.redis_url)
+
+    async def shutdown(self) -> None:
+        if self._redis is not None:
+            await self._redis.aclose()
+
+    async def already_processed(self, idem: str) -> bool:
+        """True if a message with this key already completed within the TTL."""
+        if self._config.idempotency_ttl_s <= 0 or self._redis is None:
+            return False
+        return bool(await self._redis.exists(idempotency_redis_key(idem)))
+
+    async def mark_processed(self, idem: str) -> None:
+        """Record completion so later duplicates are skipped within the TTL."""
+        if self._config.idempotency_ttl_s <= 0 or self._redis is None:
+            return
+        await self._redis.set(
+            idempotency_redis_key(idem),
+            "1",
+            ex=self._config.idempotency_ttl_s,
+        )
+
+
+def configure_logging(config: RuntimeConfig) -> None:
+    """Idempotent structlog setup so taskiq + FastAPI share one JSON sink."""
+    level = getattr(logging, config.log_level.upper(), logging.INFO)
+    logging.basicConfig(level=level, format="%(message)s")
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.processors.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(level),
+        cache_logger_on_first_use=True,
+    )
+
+
+def register_lifecycle(
+    broker: AsyncBroker,
+    config: RuntimeConfig,
+    adapters: object,
+) -> None:
+    """Register startup/shutdown hooks that expose config, adapters and the
+    idempotency store on the worker ``state``.
+
+    ``adapters`` is whatever container the project chooses — the runtime only
+    stashes it on ``state`` for the handler wrapper to hand back as ``deps``.
+    The package contributes the *ports* (see :mod:`nexus_queue.ports`); the
+    *container* is the project's, so a handler can depend on exactly the ports
+    it needs."""
+
+    @broker.on_event(TaskiqEvents.WORKER_STARTUP)
+    async def _startup(state: TaskiqState) -> None:  # pyright: ignore[reportUnusedFunction]
+        state.nexus_config = config
+        state.nexus_adapters = adapters
+        store = IdempotencyStore(config)
+        await store.startup()
+        state.nexus_idempotency = store
+        poller = DelayedRetryPoller(broker, config)
+        await poller.startup()
+        state.nexus_delayed = poller
+
+    @broker.on_event(TaskiqEvents.WORKER_SHUTDOWN)
+    async def _shutdown(state: TaskiqState) -> None:  # pyright: ignore[reportUnusedFunction]
+        store: IdempotencyStore = state.nexus_idempotency
+        await store.shutdown()
+        poller: DelayedRetryPoller = state.nexus_delayed
+        await poller.shutdown()

nexus_queue/middleware/__init__.py

@@ -0,0 +1,8 @@
+"""Broker-level middleware for the Nexus-Queue runtime."""
+
+from __future__ import annotations
+
+from nexus_queue.middleware.metrics import MetricsMiddleware
+from nexus_queue.middleware.retry_dlq import RetryDlqMiddleware
+
+__all__ = ["MetricsMiddleware", "RetryDlqMiddleware"]

nexus_queue/middleware/metrics.py

@@ -0,0 +1,59 @@
+"""Prometheus counters for queue throughput.
+
+Latency is measured in the handler wrapper (it needs an ``around`` scope that
+middleware hooks can't give); here we keep the stateless counters.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from prometheus_client import Counter, Histogram
+from taskiq.abc.middleware import TaskiqMiddleware
+from taskiq.message import TaskiqMessage
+from taskiq.result import TaskiqResult
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.naming import LABEL_TASK
+
+_LABELNAMES = ("project", "queue", "task")
+
+RECEIVED = Counter(
+    "nexus_queue_received_total",
+    "Messages pulled from the stream for execution.",
+    _LABELNAMES,
+)
+COMPLETED = Counter(
+    "nexus_queue_completed_total",
+    "Messages whose handler returned successfully.",
+    _LABELNAMES,
+)
+FAILED = Counter(
+    "nexus_queue_failed_total",
+    "Messages whose handler raised (before retry/DLQ resolution).",
+    _LABELNAMES,
+)
+CONSUME_SECONDS = Histogram(
+    "nexus_queue_consume_seconds",
+    "Handler execution wall-time (measured in the handler wrapper).",
+    _LABELNAMES,
+)
+
+
+class MetricsMiddleware(TaskiqMiddleware):
+    """Increment throughput counters around execution."""
+
+    def __init__(self, config: RuntimeConfig) -> None:
+        super().__init__()
+        self._config = config
+
+    def _task(self, message: TaskiqMessage) -> str:
+        return str(message.labels.get(LABEL_TASK, message.task_name))
+
+    def pre_execute(self, message: TaskiqMessage) -> TaskiqMessage:
+        RECEIVED.labels(self._config.project, self._config.queue, self._task(message)).inc()
+        return message
+
+    def post_execute(self, message: TaskiqMessage, result: TaskiqResult[Any]) -> None:
+        counter = FAILED if result.is_err else COMPLETED
+        counter.labels(self._config.project, self._config.queue, self._task(message)).inc()

nexus_queue/middleware/retry_dlq.py

@@ -0,0 +1,125 @@
+"""Retry + dead-letter middleware.
+
+Unifies retry and DLQ in one place so the two decisions stay consistent:
+
+* transient error and attempts remain → park the message in the delayed-retry
+  sorted set scored by its due time (``now + exponential backoff``). Redis
+  Streams deliver immediately, so the backoff can't ride the work stream; the
+  :class:`~nexus_queue.delayed.DelayedRetryPoller` moves the message back onto
+  the broker once its delay elapses.
+* attempts exhausted, or a :class:`NexusPermanentError` → ``XADD`` to the
+  ``nq:{project}:{queue}:dlq`` stream with failure metadata, instead of the
+  silent ack-and-drop that both reference projects do today.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import time
+from datetime import UTC, datetime
+from typing import Any
+
+import redis.asyncio as aioredis
+import structlog
+from taskiq.abc.middleware import TaskiqMiddleware
+from taskiq.exceptions import NoResultError
+from taskiq.message import TaskiqMessage
+from taskiq.result import TaskiqResult
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.delayed import pack_retry
+from nexus_queue.exceptions import NexusPermanentError
+
+logger = structlog.get_logger("nexus_queue.retry_dlq")
+
+# SystemRandom keeps ruff's bandit check (S311) happy without a noqa: jitter is
+# not security-sensitive, but a CSPRNG is a fine source for it.
+_jitter = random.SystemRandom()
+
+_MAX_BACKOFF_S = 60.0
+
+
+class RetryDlqMiddleware(TaskiqMiddleware):
+    """Re-enqueue transient failures with backoff; dead-letter the rest."""
+
+    def __init__(self, config: RuntimeConfig) -> None:
+        super().__init__()
+        self._config = config
+        self._redis: aioredis.Redis | None = None
+
+    async def startup(self) -> None:
+        self._redis = aioredis.from_url(self._config.redis_url)
+
+    async def shutdown(self) -> None:
+        if self._redis is not None:
+            await self._redis.aclose()
+
+    def _backoff_delay(self, attempt: int) -> float:
+        base = self._config.retry_base_delay_s * (2.0 ** max(attempt - 1, 0))
+        return min(base, _MAX_BACKOFF_S) + _jitter.random()
+
+    async def on_error(
+        self,
+        message: TaskiqMessage,
+        result: TaskiqResult[Any],
+        exception: BaseException,
+    ) -> None:
+        if isinstance(exception, NoResultError):
+            return
+
+        permanent = isinstance(exception, NexusPermanentError)
+        attempt = int(message.labels.get("_retries", 0)) + 1
+        max_retries = int(message.labels.get("max_retries", self._config.max_retries))
+
+        if not permanent and attempt < max_retries:
+            delay = self._backoff_delay(attempt)
+            labels = {**message.labels, "_retries": attempt}
+            record = pack_retry(message, labels)
+            if self._redis is not None:
+                await self._redis.zadd(self._config.delayed_set, {record: time.time() + delay})
+            result.error = NoResultError()
+            logger.info(
+                "retry-scheduled",
+                task=message.task_name,
+                attempt=attempt,
+                max_retries=max_retries,
+                delay_s=round(delay, 2),
+            )
+            return
+
+        await self._dead_letter(message, exception, attempts=attempt, permanent=permanent)
+
+    async def _dead_letter(
+        self,
+        message: TaskiqMessage,
+        exception: BaseException,
+        *,
+        attempts: int,
+        permanent: bool,
+    ) -> None:
+        record: dict[str, Any] = {
+            "task_id": message.task_id,
+            "task_name": message.task_name,
+            "labels": message.labels,
+            "args": message.args,
+            "kwargs": message.kwargs,
+            "error": repr(exception),
+            "permanent": permanent,
+            "attempts": attempts,
+            "failed_at": datetime.now(UTC).isoformat(),
+        }
+        if self._redis is not None:
+            await self._redis.xadd(
+                self._config.dlq_stream,
+                {"data": json.dumps(record, default=str)},
+                maxlen=self._config.dlq_maxlen or None,
+                approximate=True,
+            )
+        logger.warning(
+            "dead-letter",
+            task=message.task_name,
+            stream=self._config.dlq_stream,
+            permanent=permanent,
+            attempts=attempts,
+        )

nexus_queue/naming.py

@@ -0,0 +1,72 @@
+"""Stream/group naming and envelope label keys for the Nexus-Queue wire contract.
+
+Single source of truth for the strings that travel on the wire. Producers and
+consumers in any language must agree on these; the TypeScript client mirrors
+the same constants.
+"""
+
+from __future__ import annotations
+
+import re
+
+#: Wire-contract version. Bumped only on incompatible envelope changes.
+NQ_VERSION = "1"
+
+# ── Envelope label keys (carried in TaskiqMessage.labels) ──────────────────
+LABEL_VERSION = "nq_v"
+LABEL_TASK = "nq_task"
+LABEL_TENANT = "nq_tenant"
+LABEL_IDEM = "nq_idem"
+LABEL_TRACE = "nq_trace"
+LABEL_ENQUEUED_AT = "nq_enqueued_at"
+LABEL_PRIORITY = "nq_priority"
+
+#: Labels a conformant message MUST carry.
+REQUIRED_LABELS: tuple[str, ...] = (
+    LABEL_VERSION,
+    LABEL_TASK,
+    LABEL_TENANT,
+    LABEL_ENQUEUED_AT,
+)
+
+#: Sentinel tenant for single-tenant deployments.
+SINGLE_TENANT = "_"
+
+_SLUG = re.compile(r"^[a-z0-9][a-z0-9-]*$")
+
+
+def validate_slug(part: str, *, kind: str) -> str:
+    """Reject slugs that would break the ``nq:{project}:{queue}`` scheme."""
+    if not _SLUG.match(part):
+        raise ValueError(f"Invalid {kind} {part!r}: must match [a-z0-9][a-z0-9-]*")
+    return part
+
+
+def work_stream(project: str, queue: str) -> str:
+    """Redis stream key that carries work for a queue."""
+    return f"nq:{project}:{queue}"
+
+
+def consumer_group(project: str, queue: str) -> str:
+    """Consumer group name for a queue's workers."""
+    return f"nq:{project}:{queue}:cg"
+
+
+def dlq_stream(project: str, queue: str) -> str:
+    """Dead-letter stream key for a queue."""
+    return f"nq:{project}:{queue}:dlq"
+
+
+def delayed_set(project: str, queue: str) -> str:
+    """Sorted-set key holding retries until their backoff elapses."""
+    return f"nq:{project}:{queue}:delayed"
+
+
+def status_stream(project: str) -> str:
+    """Per-project status-event stream key."""
+    return f"nq:{project}:status"
+
+
+def idempotency_redis_key(idem: str) -> str:
+    """Redis key used by the idempotency middleware to dedup a message."""
+    return f"nq:idem:{idem}"

nexus_queue/pipeline.py

@@ -0,0 +1,49 @@
+"""Pipeline routing: enqueue the next stage of a multi-step job, propagating
+tenant + trace from the current message so the whole pipeline is one trace.
+
+Single-stage workers (e.g. ZP documents) don't need this; nixon's split
+pipeline does.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+from taskiq import AsyncBroker, TaskiqMessage
+from taskiq.kicker import AsyncKicker
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.envelope import Envelope
+from nexus_queue.naming import LABEL_PRIORITY, LABEL_TENANT, LABEL_TRACE, SINGLE_TENANT
+
+
+class PipelineRouter:
+    """Forwards a job to its next stage, carrying the envelope context over."""
+
+    def __init__(self, broker: AsyncBroker, config: RuntimeConfig) -> None:
+        self._broker = broker
+        self._config = config
+
+    async def forward(
+        self,
+        next_task: str,
+        payload: BaseModel,
+        *,
+        source: TaskiqMessage,
+    ) -> str:
+        """Enqueue ``next_task`` propagating tenant/trace/priority from ``source``."""
+        labels = source.labels
+        envelope = Envelope(
+            task=next_task,
+            tenant=str(labels.get(LABEL_TENANT, SINGLE_TENANT)),
+            trace=str(labels[LABEL_TRACE]) if labels.get(LABEL_TRACE) else None,
+            priority=str(labels.get(LABEL_PRIORITY, "default")),
+        )
+        kicker: AsyncKicker[Any, Any] = AsyncKicker(
+            task_name=next_task,
+            broker=self._broker,
+            labels=envelope.to_labels(),
+        )
+        task_obj = await kicker.kiq(**payload.model_dump())
+        return str(task_obj.task_id)

nexus_queue/ports.py

@@ -0,0 +1,81 @@
+"""Ports — the contract that makes workers movable across projects.
+
+A handler depends only on these Protocols; each project provides the adapters
+(e.g. ZP maps `JobStatePort` to a Payload document's ``parse_*`` fields, nixon
+to its Postgres job state machine). Handlers never import a project's domain.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from enum import StrEnum
+from typing import Any, Protocol, runtime_checkable
+
+from pydantic import BaseModel, Field
+
+from nexus_queue.naming import NQ_VERSION, SINGLE_TENANT
+
+
+class JobStatus(StrEnum):
+    """Minimal common job lifecycle. Projects may track richer states in their
+    own store; this is the subset the ports speak."""
+
+    CREATED = "created"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@runtime_checkable
+class JobStatePort(Protocol):
+    """Transitions the job's state in the project's system-of-record.
+
+    The producer creates the job before enqueueing; the handler drives it from
+    here. Implementations must be idempotent (``complete`` of an already
+    completed job is a no-op)."""
+
+    async def processing(self, job_id: str, *, meta: Mapping[str, Any] | None = None) -> None: ...
+
+    async def complete(self, job_id: str, *, result: Mapping[str, Any]) -> None: ...
+
+    async def fail(self, job_id: str, *, error: str, permanent: bool) -> None: ...
+
+    async def get(self, job_id: str) -> JobStatus: ...
+
+
+@runtime_checkable
+class BlobStorePort(Protocol):
+    """Binary storage behind an opaque reference (MinIO, Payload media, S3…)."""
+
+    async def get(self, ref: str) -> bytes: ...
+
+    async def put(self, ref: str, data: bytes, *, content_type: str) -> str: ...
+
+
+@runtime_checkable
+class IndexPort(Protocol):
+    """Search index upserts/deletes (Typesense in both reference projects)."""
+
+    async def upsert(self, collection: str, docs: Sequence[Mapping[str, Any]]) -> None: ...
+
+    async def delete(self, collection: str, ids: Sequence[str]) -> None: ...
+
+
+class StatusEvent(BaseModel):
+    """Versioned status event published to ``nq:{project}:status``."""
+
+    nq_v: str = Field(default=NQ_VERSION)
+    job_id: str
+    task: str
+    tenant: str = Field(default=SINGLE_TENANT)
+    state: JobStatus
+    ts: str
+    trace: str | None = None
+    error: str | None = None
+
+
+@runtime_checkable
+class StatusEventPort(Protocol):
+    """Emits a status event (push-status; generalizes nixon's domain-event stream)."""
+
+    async def emit(self, event: StatusEvent) -> None: ...

nexus_queue/publisher.py

@@ -0,0 +1,78 @@
+"""Python producer. Stamps the standard envelope labels (and the current OTel
+traceparent for end-to-end tracing) and enqueues onto the namespaced stream.
+
+The TypeScript producer (`@zetesis/nexus-queue`) emits the same shape.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from opentelemetry.propagate import inject
+from pydantic import BaseModel
+from taskiq import AsyncBroker
+from taskiq.kicker import AsyncKicker
+
+from nexus_queue.config import RuntimeConfig
+from nexus_queue.envelope import Envelope
+from nexus_queue.naming import SINGLE_TENANT
+
+
+def _current_traceparent() -> str | None:
+    carrier: dict[str, str] = {}
+    inject(carrier)
+    return carrier.get("traceparent")
+
+
+class Publisher:
+    """Enqueues tasks by name with the Nexus-Queue envelope."""
+
+    def __init__(self, broker: AsyncBroker, config: RuntimeConfig) -> None:
+        self._broker = broker
+        self._config = config
+
+    async def enqueue(
+        self,
+        task: str,
+        payload: BaseModel,
+        *,
+        tenant: str = SINGLE_TENANT,
+        idempotency_key: str | None = None,
+        priority: str = "default",
+        trace: str | None = None,
+    ) -> str:
+        """Enqueue a typed payload; returns the taskiq task id."""
+        return await self.enqueue_raw(
+            task,
+            payload.model_dump(),
+            tenant=tenant,
+            idempotency_key=idempotency_key,
+            priority=priority,
+            trace=trace,
+        )
+
+    async def enqueue_raw(
+        self,
+        task: str,
+        payload: dict[str, Any],
+        *,
+        tenant: str = SINGLE_TENANT,
+        idempotency_key: str | None = None,
+        priority: str = "default",
+        trace: str | None = None,
+    ) -> str:
+        """Enqueue a raw kwargs payload (used by the HTTP kicker)."""
+        envelope = Envelope(
+            task=task,
+            tenant=tenant,
+            idempotency_key=idempotency_key,
+            trace=trace or _current_traceparent(),
+            priority=priority,
+        )
+        kicker: AsyncKicker[Any, Any] = AsyncKicker(
+            task_name=task,
+            broker=self._broker,
+            labels=envelope.to_labels(),
+        )
+        task_obj = await kicker.kiq(**payload)
+        return str(task_obj.task_id)

nexus_queue/tracing.py

@@ -0,0 +1,38 @@
+"""Optional OpenTelemetry tracing setup for the worker.
+
+The runtime instruments spans through the OTel *API* (see :mod:`nexus_queue.handlers`),
+but emitting them needs an SDK + exporter. A deployment opts in by setting the
+standard ``OTEL_EXPORTER_OTLP_ENDPOINT``; with it unset the spans stay no-op, so
+the same image runs untraced where no collector exists.
+"""
+
+from __future__ import annotations
+
+import os
+
+import structlog
+from opentelemetry import trace
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from nexus_queue.config import RuntimeConfig
+
+logger = structlog.get_logger("nexus_queue.tracing")
+
+OTLP_ENDPOINT_ENV = "OTEL_EXPORTER_OTLP_ENDPOINT"
+
+
+def configure_tracing(config: RuntimeConfig) -> None:
+    """Wire an OTLP span exporter when a collector endpoint is configured.
+
+    No-op unless ``OTEL_EXPORTER_OTLP_ENDPOINT`` is set. The exporter reads the
+    endpoint (and any other ``OTEL_*`` options) from the environment itself."""
+    endpoint = os.environ.get(OTLP_ENDPOINT_ENV)
+    if not endpoint:
+        return
+    provider = TracerProvider(resource=Resource.create({"service.name": config.app_name}))
+    provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
+    trace.set_tracer_provider(provider)
+    logger.info("tracing-configured", endpoint=endpoint, service=config.app_name)

nexus_queue-0.1.1.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: nexus-queue
+Version: 0.1.1
+Summary: Nexus-Queue — portable taskiq + Redis Streams worker runtime: namespaced streams, versioned envelope, ports-and-adapters, retry/DLQ/idempotency/tracing/metrics middleware.
+Project-URL: Homepage, https://github.com/Zetesis-Labs/PayloadAgents
+Project-URL: Repository, https://github.com/Zetesis-Labs/PayloadAgents
+Project-URL: Issues, https://github.com/Zetesis-Labs/PayloadAgents/issues
+Author: Zetesis Labs
+License: MIT
+Keywords: dlq,ports-and-adapters,queue,redis,taskiq,worker
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.115
+Requires-Dist: opentelemetry-api>=1.35
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.35
+Requires-Dist: opentelemetry-sdk>=1.35
+Requires-Dist: prometheus-client>=0.20
+Requires-Dist: pydantic>=2.9
+Requires-Dist: redis>=5.0
+Requires-Dist: structlog>=24.1
+Requires-Dist: taskiq-redis>=1.1.1
+Requires-Dist: taskiq>=0.11.18
+Requires-Dist: uvicorn[standard]>=0.34
+Description-Content-Type: text/markdown
+
+# nexus-queue
+
+Portable worker runtime for the **Nexus-Queue** standard: taskiq + Redis Streams,
+domain-agnostic, ports-and-adapters. One project builds queues the same way as
+the next, and a worker's handlers move between projects unchanged.
+
+What this package owns (the parts that are the *same* across projects):
+
+- **Namespaced streams** — `nq:{project}:{queue}` (+ `:cg`, `:dlq`) and
+  `nq:{project}:status`, so multiple projects/queues coexist on one Redis
+  (the default global `"taskiq"` stream is never used).
+- **Versioned envelope** — standard labels (`nq_v`, `nq_task`, `nq_tenant`,
+  `nq_idem`, `nq_trace`, `nq_enqueued_at`, `nq_priority`) on top of taskiq's
+  message, plus typed pydantic payloads.
+- **Ports** — `JobStatePort`, `BlobStorePort`, `IndexPort`, `StatusEventPort`.
+  Handlers depend only on these; each project supplies the adapters
+  (e.g. Payload vs Postgres/MinIO).
+- **Middleware stack** (broker-level): idempotency (dedup on `nq_idem`),
+  DLQ (dead-letter on retry-exhaustion instead of silent drop), retries with
+  exponential backoff + jitter, OTel tracing (`nq_trace` propagation), and
+  Prometheus metrics.
+- **Producer + kicker** — a Python `Publisher` and a generic HTTP kicker for
+  non-Python producers. The TypeScript producer client ships as
+  `@zetesis/nexus-queue`.
+
+Spec: `nexus-queue-spec.md`.
+
+Released via release-please on every conventional commit to `main`
+(scope `nexus-queue`).

nexus_queue-0.1.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+nexus_queue/__init__.py,sha256=vZC0Kh4XgC9PJAQUu_bjDHmp7I94L97jkgJVroF_rNg,2121
+nexus_queue/app.py,sha256=xJ58WaTLGrpor0GiSoxfiagqIvzfUN_CjvWmoSM98lY,1484
+nexus_queue/broker.py,sha256=zqUQFOMnZ3XDs0gegWC75wcL1F02514_0WjXu8QZ1hI,1066
+nexus_queue/config.py,sha256=34GIQsRmbR7xb1Xy2iSumZVHtkLrH0xqwqkTCFX2fGU,3979
+nexus_queue/delayed.py,sha256=FCDc88C1GujhH3yB9eEWAaLlv3JDgvgFBJRpM4iHRXU,3227
+nexus_queue/envelope.py,sha256=7k81IrrPBijoDXp8uE60Fh4J57Fpetwc8t-3TRI6XOI,2069
+nexus_queue/exceptions.py,sha256=ceB2nn6jHft_y32Qmmoq40hAgJ7mto3jWILNf2MogJE,475
+nexus_queue/handlers.py,sha256=VWR3FRkalbEPzHbvg6JqaIjA3vjM2uokq5ONr_gGsgs,3254
+nexus_queue/kicker.py,sha256=hwbCfd-vyxFsDPghaF8dBg5lVqYkwHWQftnDngKGhVQ,3648
+nexus_queue/lifecycle.py,sha256=-H9Z-VTYab1CeLGz0iMuQBBxjyNr5I-1xd6G0gaoTEs,4042
+nexus_queue/naming.py,sha256=uAkfFHT-DZMtPL3uKVt5gSSfZZ0yVxBDXXc-rzWdN3U,2108
+nexus_queue/pipeline.py,sha256=L6ytmQhbCSEIRCe_VUqyMa8v_kfJrJNQxlONHRu0JLw,1647
+nexus_queue/ports.py,sha256=wnRavsKSS4JReHhc5MfOTL-dtOxW08U5mQYn8CISjzA,2545
+nexus_queue/publisher.py,sha256=zDgSVvwI4XIJtsEZrcCufEReOtOUOmHmb8zs_hCt6oM,2283
+nexus_queue/tracing.py,sha256=lNSxUTAOO7VJBkOKP7EX0ns0DBWP-8nXdKqrieiF2A4,1520
+nexus_queue/middleware/__init__.py,sha256=7dAc7nzCLrfOsZQOXYLOhxHSW7HUXbQ7c4zpZ2w8Q8M,276
+nexus_queue/middleware/metrics.py,sha256=Dah5GrUSs2VJWNK5P7sSV1dyh4esEfr510tDASO3i64,1875
+nexus_queue/middleware/retry_dlq.py,sha256=zAzdrMhzJjYyUsdntTtL3Jc6LmcrkzfI-U9Gcj8HPWM,4361
+nexus_queue/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nexus_queue-0.1.1.dist-info/METADATA,sha256=nuIq6JILH-c3mCN93ND1TBfqb4QK62I6KFf6a_syLqA,2821
+nexus_queue-0.1.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+nexus_queue-0.1.1.dist-info/RECORD,,

nexus_queue-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any