django-absurd 0.1.0a1__tar.gz

django_absurd-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lincoln Loop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_absurd-0.1.0a1/MANIFEST.in

@@ -0,0 +1,10 @@
+# setuptools-scm's git file-finder sweeps every tracked file into the sdist.
+# Prune dev/internal files so only django_absurd (plus the standard packaging
+# files: pyproject.toml, README, LICENSE) ships.
+prune docs
+prune examples
+prune tests
+prune .github
+exclude CLAUDE.md compose.yaml renovate.json tox.ini uv.lock
+exclude .dockerignore .editorconfig .envrc .gitignore .python-version
+exclude .pre-commit-config.yaml .prettierrc.toml .yamllint.yml

django_absurd-0.1.0a1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: django-absurd
+Version: 0.1.0a1
+Summary: Django integration for Absurd, the Postgres-native workflow engine.
+Author-email: Marc Gibbons <marc@lincolnloop.com>, Lincoln Loop <info@lincolnloop.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lincolnloop/django-absurd
+Project-URL: Issues, https://github.com/lincolnloop/django-absurd/issues
+Project-URL: Repository, https://github.com/lincolnloop/django-absurd
+Keywords: absurd,background-jobs,django,postgres,queue,tasks,workflow,workflow-engine
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: absurd-sdk<0.5.0,>=0.4.0
+Requires-Dist: Django>=6.0
+Dynamic: license-file
+
+# django-absurd
+
+Django integration for [Absurd](https://earendil-works.github.io/absurd/), the
+Postgres-native workflow engine. Wraps Absurd's SDK so it reuses Django's database
+connection, ships its schema as Django migrations, and exposes its queues and tasks
+through Django settings, management commands, and system checks.
+
+> **Alpha.** APIs and behavior may change between releases.
+
+## Requirements
+
+- Python 3.12+
+- Django 6.0+
+- PostgreSQL with the **psycopg (v3)** Django backend (the Absurd SDK reuses Django's
+  connection and requires psycopg3)
+
+## Installation
+
+```console
+pip install django-absurd
+```
+
+Pre-release tags (e.g. `v0.1.0a1`) upload as PyPI pre-releases, which `pip install`
+skips unless you pass `--pre`:
+
+```console
+pip install --pre django-absurd
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

django_absurd-0.1.0a1/README.md

@@ -0,0 +1,32 @@
+# django-absurd
+
+Django integration for [Absurd](https://earendil-works.github.io/absurd/), the
+Postgres-native workflow engine. Wraps Absurd's SDK so it reuses Django's database
+connection, ships its schema as Django migrations, and exposes its queues and tasks
+through Django settings, management commands, and system checks.
+
+> **Alpha.** APIs and behavior may change between releases.
+
+## Requirements
+
+- Python 3.12+
+- Django 6.0+
+- PostgreSQL with the **psycopg (v3)** Django backend (the Absurd SDK reuses Django's
+  connection and requires psycopg3)
+
+## Installation
+
+```console
+pip install django-absurd
+```
+
+Pre-release tags (e.g. `v0.1.0a1`) upload as PyPI pre-releases, which `pip install`
+skips unless you pass `--pre`:
+
+```console
+pip install --pre django-absurd
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

django_absurd-0.1.0a1/django_absurd/AGENTS.md

@@ -0,0 +1,43 @@
+# django-absurd — agent guide
+
+Guidance for coding agents integrating **django-absurd** into a Django project. This
+file ships inside the installed package (`site-packages/django_absurd/AGENTS.md`) so it
+is discoverable from a project's virtualenv.
+
+django-absurd is a Django integration for
+[Absurd](https://earendil-works.github.io/absurd/), a Postgres-native workflow engine.
+It reuses Django's database connection, ships Absurd's schema as Django migrations, and
+surfaces queues/tasks through Django settings, management commands, and system checks.
+
+## Hard requirements
+
+- **Python 3.12+**, **Django 6.0+**.
+- **PostgreSQL via the psycopg (v3) Django backend.** The Absurd SDK reuses Django's
+  connection and requires psycopg3 — `django.db.backends.postgresql` with psycopg3
+  installed. A psycopg2 setup will not work. The app asserts this; do not work around
+  it.
+- Targets `DATABASES['default']`.
+
+## Setup checklist
+
+1. Install: `pip install django-absurd` (pre-releases: add `--pre`).
+2. Add `django_absurd` to `INSTALLED_APPS`.
+3. Configure Django's `TASKS` setting to use the Absurd backend (see the project README
+   and the upstream Absurd docs for backend path and `OPTIONS`).
+4. Run `python manage.py migrate` — Absurd's schema is applied via shipped SQL
+   migrations (no network access needed at migrate time).
+5. Sync declared queues: `python manage.py absurd_sync_queues`.
+6. Run a worker: `python manage.py absurd_worker`.
+
+## Validation
+
+- Run `python manage.py check django_absurd` — system checks flag misconfiguration
+  (wrong DB backend, queues declared but not synced, missing router, etc.). Treat check
+  failures as blocking; fix configuration rather than silencing them.
+
+## Notes
+
+- Migrations are offline and sourced only from the pinned Absurd schema — never fetch at
+  migrate time.
+- This is alpha software; confirm behavior against the installed version's README rather
+  than assuming API stability.

django_absurd-0.1.0a1/django_absurd/__init__.py

@@ -0,0 +1 @@
+ABSURD_SCHEMA_VERSION = "0.4.0"

django_absurd-0.1.0a1/django_absurd/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class AbsurdConfig(AppConfig):
+    name = "django_absurd"
+    label = "django_absurd"
+
+    def ready(self) -> None:
+        import django_absurd.checks  # noqa: F401, PLC0415

django_absurd-0.1.0a1/django_absurd/backends.py

@@ -0,0 +1,210 @@
+import typing as t
+
+import psycopg.errors
+import psycopg.sql
+from absurd_sdk import CreateQueueOptions
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connections, transaction
+from django.db.utils import ProgrammingError
+from django.tasks import TaskResult, TaskResultStatus
+from django.tasks.backends.base import BaseTaskBackend
+from django.tasks.base import TaskError
+from django.tasks.exceptions import TaskResultDoesNotExist
+from django.utils import timezone
+from django.utils.module_loading import import_string
+
+from django_absurd.connection import build_absurd_client, register_jsonb_loader
+
+if t.TYPE_CHECKING:
+    from django.tasks.base import Task
+
+
+class AbsurdBackendOptions(t.TypedDict, total=False):
+    DATABASE: str
+    DEFAULT_MAX_ATTEMPTS: int
+    QUEUES: dict[str, CreateQueueOptions]
+
+
+class AbsurdBackend(BaseTaskBackend):
+    supports_get_result = True
+    supports_async_task = False
+    supports_defer = False
+    supports_priority = False
+
+    def __init__(self, alias: str, params: dict[str, t.Any]) -> None:
+        self.has_top_level_queues: bool = "QUEUES" in params
+        super().__init__(alias, params)
+        if "QUEUES" in self.options:
+            self.queues = set(self.options["QUEUES"])  # type: ignore[assignment]
+        self.database: str = self.options.get("DATABASE", "default")
+        self.default_max_attempts: int = self.options.get("DEFAULT_MAX_ATTEMPTS", 5)
+
+    def enqueue(
+        self, task: "Task", args: list[t.Any], kwargs: dict[str, t.Any]
+    ) -> TaskResult:
+        self.validate_task(task)
+        client = build_absurd_client(self.database)
+        spawn_params = kwargs.pop("absurd_spawn_params", None)
+        defaults = getattr(task.func, "absurd_default_params", None)
+        merged = build_merged_spawn_options(defaults, spawn_params)
+        max_attempts: int = merged.pop("max_attempts", self.default_max_attempts)
+        try:
+            # Savepoint so a misconfig DB error (below) rolls back only the spawn,
+            # leaving an enclosing transaction.atomic() block usable.
+            with transaction.atomic(using=self.database, savepoint=True):
+                spawn_result = client.spawn(
+                    task.module_path,
+                    {"args": list(args), "kwargs": dict(kwargs)},
+                    queue=task.queue_name,
+                    max_attempts=max_attempts,
+                    **merged,
+                )
+        except (
+            psycopg.errors.UndefinedTable,
+            psycopg.errors.UndefinedFunction,
+            psycopg.errors.InvalidSchemaName,
+        ):
+            msg = (
+                f"Queue '{task.queue_name}' is not provisioned in Absurd. "
+                "Run manage.py absurd_sync_queues (and manage.py migrate if the "
+                "absurd schema is absent)."
+            )
+            raise ImproperlyConfigured(msg) from None
+        return TaskResult(
+            task=task,
+            id=f"{task.queue_name}:{spawn_result['task_id']}",
+            status=TaskResultStatus.READY,
+            enqueued_at=timezone.now(),
+            started_at=None,
+            finished_at=None,
+            last_attempted_at=None,
+            args=list(args),
+            kwargs=dict(kwargs),
+            backend=self.alias,
+            errors=[],
+            worker_ids=[],
+        )
+
+    def get_result(self, result_id: str) -> TaskResult:
+        queue, task_id = decode_result_id(result_id)
+        if queue not in self.queues:
+            raise TaskResultDoesNotExist(result_id)
+        connection = connections[self.database]
+        connection.ensure_connection()
+        sql = psycopg.sql.SQL(
+            "SELECT t.task_name, t.params, t.enqueue_at, t.first_started_at,"
+            " t.state, t.completed_payload, t.cancelled_at,"
+            " lr.started_at AS run_started, lr.completed_at, lr.failed_at,"
+            " lr.failure_reason,"
+            " (SELECT array_agg(r.claimed_by ORDER BY r.attempt)"
+            "  FROM {r} r"
+            "  WHERE r.task_id = t.task_id AND r.claimed_by IS NOT NULL) AS worker_ids"
+            " FROM {t} t"
+            " LEFT JOIN {r} lr ON lr.run_id = t.last_attempt_run"
+            " WHERE t.task_id = %s"
+        ).format(
+            t=psycopg.sql.Identifier("absurd", f"t_{queue}"),
+            r=psycopg.sql.Identifier("absurd", f"r_{queue}"),
+        )
+        rendered = sql.as_string(connection.connection)
+        try:
+            with (
+                transaction.atomic(using=self.database, savepoint=True),
+                connection.cursor() as cursor,
+            ):
+                register_jsonb_loader(cursor)
+                cursor.execute(rendered, [task_id])
+                row = cursor.fetchone()
+        except ProgrammingError:
+            raise TaskResultDoesNotExist(result_id) from None
+        if row is None:
+            raise TaskResultDoesNotExist(result_id)
+        return build_task_result(self, result_id, queue, row)
+
+
+def decode_result_id(result_id: str) -> tuple[str, str]:
+    parts = result_id.rsplit(":", 1)
+    if len(parts) != 2:
+        raise TaskResultDoesNotExist(result_id)
+    return parts[0], parts[1]
+
+
+STATE_TO_STATUS: dict[str, TaskResultStatus] = {
+    "pending": TaskResultStatus.READY,
+    "running": TaskResultStatus.RUNNING,
+    "sleeping": TaskResultStatus.RUNNING,
+    "completed": TaskResultStatus.SUCCESSFUL,
+    "failed": TaskResultStatus.FAILED,
+    "cancelled": TaskResultStatus.FAILED,
+}
+
+
+def map_state_to_status(state: str) -> TaskResultStatus:
+    return STATE_TO_STATUS.get(state, TaskResultStatus.READY)
+
+
+def build_task_result(
+    backend: "AbsurdBackend",
+    result_id: str,
+    queue: str,
+    row: t.Any,
+) -> TaskResult:
+    (
+        task_name,
+        params,
+        enqueue_at,
+        first_started_at,
+        state,
+        completed_payload,
+        cancelled_at,
+        run_started,
+        completed_at,
+        failed_at,
+        failure_reason,
+        worker_ids_array,
+    ) = row
+    try:
+        task_obj = import_string(task_name)
+    except ImportError:
+        msg = f"task '{task_name}' is no longer importable"
+        raise ImproperlyConfigured(msg) from None
+    if task_obj.queue_name != queue:
+        task_obj = task_obj.using(queue_name=queue)
+    status = map_state_to_status(state)
+    errors: list[TaskError] = []
+    if state == "failed" and failure_reason:
+        errors = [
+            TaskError(
+                exception_class_path=failure_reason.get("name", ""),
+                traceback=failure_reason.get("traceback")
+                or failure_reason.get("message", ""),
+            )
+        ]
+    finished_at = completed_at or failed_at or cancelled_at
+    worker_ids: list[str] = worker_ids_array or []
+    result: TaskResult = TaskResult(
+        task=task_obj,
+        id=result_id,
+        status=status,
+        enqueued_at=enqueue_at,
+        started_at=first_started_at,
+        finished_at=finished_at,
+        last_attempted_at=run_started,
+        args=params["args"],
+        kwargs=params["kwargs"],
+        backend=backend.alias,
+        errors=errors,
+        worker_ids=worker_ids,
+    )
+    if state == "completed":
+        object.__setattr__(result, "_return_value", completed_payload)
+    return result
+
+
+def build_merged_spawn_options(defaults: t.Any, per_call: t.Any) -> dict[str, t.Any]:
+    merged: dict[str, t.Any] = {}
+    if defaults is not None:
+        merged.update(defaults.to_kwargs())
+    if per_call is not None:
+        merged.update(per_call.to_kwargs())
+    return merged

django_absurd-0.1.0a1/django_absurd/checks.py

@@ -0,0 +1,217 @@
+import typing as t
+from collections.abc import Sequence
+from datetime import timedelta
+
+from absurd_sdk import CreateQueueOptions, QueueDetachMode, QueueStorageMode
+from django.apps import AppConfig
+from django.conf import settings
+from django.core.checks import CheckMessage, Error, Tags, register
+from django.core.checks import Warning as DjangoWarning
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connections
+from django.db.utils import OperationalError, ProgrammingError
+from django.utils.connection import ConnectionDoesNotExist
+
+from django_absurd.connection import BACKEND_ERROR_MESSAGE, validate_backend
+from django_absurd.models import Queue
+from django_absurd.queues import (
+    get_absurd_backends,
+    get_absurd_database,
+    get_declared_queues,
+)
+from django_absurd.routers import AbsurdRouter
+
+W001_MSG = (
+    "django-absurd: the absurd schema is not migrated;"
+    " declared queues cannot be provisioned."
+)
+W001_HINT = "Run 'manage.py migrate', then 'manage.py absurd_sync_queues'."
+W002_MSG = "django-absurd: declared queues are out of sync with the database."
+W002_HINT = "Run 'manage.py absurd_sync_queues'."
+E005_MSG = (
+    "django-absurd: a non-default DATABASE is configured but AbsurdRouter is not in"
+    " DATABASE_ROUTERS."
+)
+E005_HINT = "Add 'django_absurd.routers.AbsurdRouter' to settings.DATABASE_ROUTERS."
+E001_MSG = BACKEND_ERROR_MESSAGE
+E002_MSG = (
+    "django-absurd: both top-level QUEUES and OPTIONS['QUEUES'] are set"
+    " on the same backend."
+)
+E002_HINT = "Remove either the top-level QUEUES key or OPTIONS['QUEUES'] — not both."
+E003_MSG = "django-absurd: invalid per-queue policy options."
+E003_HINT = (
+    "Remove unknown keys and ensure storage_mode/detach_mode values"
+    " are valid SDK literals."
+)
+E004_MSG = (
+    "django-absurd: multiple Absurd backends are configured with distinct"
+    " DATABASE values."
+)
+E004_HINT = "Use a single DATABASE across all Absurd backends."
+
+DURATION_OPTION_KEYS = frozenset(
+    ("partition_lookahead", "partition_lookback", "cleanup_ttl", "detach_min_age")
+)
+SCALAR_OPTION_KEYS = frozenset(("cleanup_limit", "detach_mode", "storage_mode"))
+
+VALID_QUEUE_OPTION_KEYS = set(CreateQueueOptions.__annotations__)
+VALID_STORAGE_MODES = set(t.get_args(QueueStorageMode))
+VALID_DETACH_MODES = set(t.get_args(QueueDetachMode))
+
+
+@register("absurd")
+def check_absurd_config(
+    *,
+    app_configs: Sequence[AppConfig] | None,
+    **kwargs: t.Any,
+) -> list[CheckMessage]:
+    backends = get_absurd_backends()
+    if not backends:
+        return []
+
+    errors: list[CheckMessage] = []
+    databases: set[str] = set()
+    e005_emitted = False
+
+    for backend in backends.values():
+        db = get_absurd_database(backend)
+        databases.add(db)
+
+        if backend.has_top_level_queues and "QUEUES" in backend.options:
+            errors.append(Error(E002_MSG, hint=E002_HINT, id="absurd.E002"))
+
+        declared = get_declared_queues(backend)
+        for queue_name, policy in declared.items():
+            errors.extend(validate_queue_policy(queue_name, policy))
+
+        if db != "default" and not router_installed() and not e005_emitted:
+            errors.append(Error(E005_MSG, hint=E005_HINT, id="absurd.E005"))
+            e005_emitted = True
+
+        try:
+            validate_backend(db)
+        except (OperationalError, ConnectionDoesNotExist):
+            pass
+        except ImproperlyConfigured:
+            errors.append(Error(E001_MSG, id="absurd.E001"))
+
+    if len(databases) > 1:
+        errors.append(Error(E004_MSG, hint=E004_HINT, id="absurd.E004"))
+
+    return errors
+
+
+@register(Tags.database, "absurd")
+def check_absurd_queue_state(
+    *,
+    app_configs: Sequence[AppConfig] | None,
+    databases: Sequence[str] | None,
+    **kwargs: t.Any,
+) -> list[CheckMessage]:
+    if not databases:
+        return []
+
+    backends = get_absurd_backends()
+    if not backends:
+        return []
+
+    errors: list[CheckMessage] = []
+    for backend in backends.values():
+        db = get_absurd_database(backend)
+        if db not in databases:
+            continue
+        declared = get_declared_queues(backend)
+        if not declared:
+            continue
+        errors.extend(query_queue_state(db, declared))
+
+    return errors
+
+
+def validate_queue_policy(
+    queue_name: str, policy: dict[str, t.Any]
+) -> list[CheckMessage]:
+    errors: list[CheckMessage] = [
+        Error(
+            f"{E003_MSG} Queue '{queue_name}': unknown key '{key}'.",
+            hint=E003_HINT,
+            id="absurd.E003",
+        )
+        for key in policy
+        if key not in VALID_QUEUE_OPTION_KEYS
+    ]
+    if "storage_mode" in policy and policy["storage_mode"] not in VALID_STORAGE_MODES:
+        mode = policy["storage_mode"]
+        errors.append(
+            Error(
+                f"{E003_MSG} Queue '{queue_name}': invalid storage_mode '{mode}'.",
+                hint=E003_HINT,
+                id="absurd.E003",
+            )
+        )
+    if "detach_mode" in policy and policy["detach_mode"] not in VALID_DETACH_MODES:
+        mode = policy["detach_mode"]
+        errors.append(
+            Error(
+                f"{E003_MSG} Queue '{queue_name}': invalid detach_mode '{mode}'.",
+                hint=E003_HINT,
+                id="absurd.E003",
+            )
+        )
+    return errors
+
+
+def router_installed() -> bool:
+    for router in settings.DATABASE_ROUTERS:
+        if router == "django_absurd.routers.AbsurdRouter":
+            return True
+        if isinstance(router, AbsurdRouter):
+            return True
+    return False
+
+
+def query_queue_state(alias: str, declared: dict[str, dict]) -> list[CheckMessage]:
+    try:
+        actual = {
+            q.queue_name: q
+            for q in Queue.objects.using(alias).filter(queue_name__in=declared)
+        }
+    except OperationalError:
+        return []
+    except ProgrammingError:
+        return [DjangoWarning(W001_MSG, hint=W001_HINT, id="absurd.W001")]
+
+    drift = [
+        name
+        for name, opts in declared.items()
+        if name not in actual or has_option_drifted(alias, opts, actual[name])
+    ]
+    if drift:
+        return [
+            DjangoWarning(
+                W002_MSG,
+                hint=f"{W002_HINT} Out of sync: {', '.join(drift)}",
+                id="absurd.W002",
+            )
+        ]
+    return []
+
+
+def has_option_drifted(alias: str, opts: dict, queue: Queue) -> bool:
+    for key, declared_val in opts.items():
+        if key in DURATION_OPTION_KEYS:
+            actual_val = getattr(queue, key)
+            if parse_interval(alias, declared_val) != actual_val:
+                return True
+        elif key in SCALAR_OPTION_KEYS:
+            actual_val = getattr(queue, key)
+            if declared_val != actual_val:
+                return True
+    return False
+
+
+def parse_interval(alias: str, interval_str: str) -> timedelta:
+    with connections[alias].cursor() as cur:
+        cur.execute("SELECT %s::interval", [interval_str])
+        return cur.fetchone()[0]

django_absurd-0.1.0a1/django_absurd/connection.py

@@ -0,0 +1,34 @@
+import json
+
+import psycopg
+import psycopg.abc
+from absurd_sdk import Absurd
+from django.core.exceptions import ImproperlyConfigured
+from django.db import connections
+from psycopg.types.json import set_json_loads
+
+BACKEND_ERROR_MESSAGE = (
+    "django-absurd requires the psycopg (v3) PostgreSQL backend. "
+    "See https://www.psycopg.org/psycopg3/docs/"
+)
+
+
+def validate_backend(using: str) -> None:
+    conn = connections[using]
+    conn.ensure_connection()
+    if not isinstance(conn.connection, psycopg.Connection):
+        raise ImproperlyConfigured(BACKEND_ERROR_MESSAGE)
+
+
+def register_jsonb_loader(context: psycopg.abc.AdaptContext) -> None:
+    # absurd-sdk returns jsonb columns as raw strings unless we register a loader;
+    # psycopg3's built-in loader is jsonb-type-OID only and doesn't cover the
+    # un-typed bytea path the SDK's claim_tasks cursor uses.
+    # Accepts either a Connection (for the SDK path) or a Cursor (for get_result,
+    # where cursor-scope avoids poisoning Django's shared connection adapters).
+    set_json_loads(json.loads, context)
+
+
+def build_absurd_client(using: str) -> Absurd:
+    validate_backend(using)
+    return Absurd(connections[using].connection)

django_absurd-0.1.0a1/django_absurd/management/commands/absurd_sync_queues.py

@@ -0,0 +1,26 @@
+from django.core.management.base import BaseCommand
+
+from django_absurd.queues import SyncResult, get_absurd_backends, sync_queues
+
+
+class Command(BaseCommand):
+    help = "Create and reconcile queues declared on each Absurd task backend."
+
+    def handle(self, *args: object, **options: object) -> None:
+        backends = get_absurd_backends()
+        if not backends:
+            self.stdout.write("No Absurd task backends configured.")
+            return
+        for alias, backend in backends.items():
+            prefix = f"[{alias}] " if len(backends) > 1 else ""
+            self.report_result(prefix, sync_queues(backend))
+
+    def report_result(self, prefix: str, result: SyncResult) -> None:
+        if result.created:
+            self.stdout.write(f"{prefix}Created: {', '.join(result.created)}")
+        if result.reconciled:
+            self.stdout.write(f"{prefix}Reconciled: {', '.join(result.reconciled)}")
+        if not result.created and not result.reconciled:
+            self.stdout.write(f"{prefix}No queues to sync.")
+        for warning in result.storage_warnings:
+            self.stderr.write(self.style.WARNING(f"{prefix}{warning}"))