taskiq-django 0.0.1__tar.gz

taskiq_django-0.0.1/PKG-INFO

@@ -0,0 +1,352 @@
+Metadata-Version: 2.3
+Name: taskiq-django
+Version: 0.0.1
+Summary: Add your description here
+Requires-Dist: django>=6.0.5
+Requires-Dist: taskiq>=0.12.4
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# taskiq-django
+
+Django integration for [Taskiq](https://taskiq-python.github.io/).
+
+`taskiq-django` lets you run a Taskiq broker alongside a Django project and persist scheduled tasks in your Django database.
+It ships with:
+
+- `DjangoScheduleSource` — a `taskiq.ScheduleSource` backed by the Django ORM.
+- A Django admin for adding, editing and deleting schedules through the web UI.
+
+The package itself is broker-agnostic — pair it with any Taskiq broker (`AsyncpgBroker`, `RedisBroker`, `KafkaBroker`, etc.).
+The `examples/` folder uses [taskiq-postgres](https://github.com/danfimov/taskiq-postgres/) on top of PostgreSQL.
+
+## Installation
+
+```bash
+pip install taskiq-django
+```
+
+Add the app to `INSTALLED_APPS` so its model and admin are registered:
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "taskiq_django",
+]
+```
+
+Then apply the migration that creates the `taskiq_schedules` table:
+
+```bash
+python manage.py migrate taskiq_django
+```
+
+## Using Taskiq with Django
+
+Taskiq broker and scheduler are async, while Django historically is sync. The cleanest way to host both in a single process
+is to serve Django over ASGI and let an ASGI server (`granian` or `uvicorn` for example) drive the broker lifecycle through
+Starlette's `lifespan` hook.
+
+The recipe below mirrors the one used in [`examples/example_app`](examples/example_app/) of this repository.
+
+### Default Django application
+
+A standard Django ASGI entry point looks like this:
+
+```python
+# asgi.py
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+application = get_asgi_application()
+```
+
+This is enough to serve Django through any ASGI server, but it has no place to plug a Taskiq broker into — Django's ASGI app
+does not expose `lifespan` events.
+
+### Serving Django via Starlette
+
+Wrap the Django ASGI app in a [Starlette](https://www.starlette.io/) application and mount it at `/`. Starlette supports
+`lifespan`, makes static files easy, and lets us add ASGI middleware around Django:
+
+```python
+# asgi.py
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+django_asgi = get_asgi_application()
+
+from starlette.applications import Starlette
+from starlette.routing import Mount
+
+application = Starlette(
+    routes=(
+        Mount("/", django_asgi),
+    ),
+)
+```
+
+> Set `DJANGO_SETTINGS_MODULE` and call `get_asgi_application()` **before** importing anything that touches Django models
+> (including `taskiq_django`). Otherwise `django.apps.AppRegistryNotReady` will fire at import time.
+
+### Serving static files with Starlette
+
+Collect Django's static files into a folder and serve it via `StaticFiles`. In your Django settings:
+
+```python
+# settings.py
+STATIC_URL = "static/"
+STATIC_ROOT = "static/"
+```
+
+Then add a `Mount` in front of Django:
+
+```python
+# asgi.py
+from starlette.staticfiles import StaticFiles
+
+application = Starlette(
+    routes=(
+        Mount("/static", StaticFiles(directory="static"), name="static"),
+        Mount("/", django_asgi),
+    ),
+)
+```
+
+Run `python manage.py collectstatic` once so admin CSS/JS appears under `static/`.
+
+### Broker and scheduler lifespan
+
+Construct the broker and scheduler at module level, and use a Starlette `lifespan` to start and stop them with the process:
+
+```python
+# asgi.py
+from contextlib import asynccontextmanager
+from taskiq import TaskiqScheduler, async_shared_broker
+from taskiq_pg.asyncpg import AsyncpgBroker
+
+from taskiq_django import DjangoScheduleSource
+
+DSN = "postgres://taskiq_django:look_in_vault@localhost:5432/taskiq_django"
+broker = AsyncpgBroker(dsn=DSN)
+async_shared_broker.default_broker(broker)
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+
+
+@asynccontextmanager
+async def broker_lifespan(app):
+    await broker.startup()
+    for source in scheduler.sources:
+        await source.startup()
+    try:
+        yield
+    finally:
+        for source in scheduler.sources:
+            await source.shutdown()
+        await broker.shutdown()
+
+
+application = Starlette(
+    routes=(...),
+    lifespan=broker_lifespan,
+)
+```
+
+### Injecting broker and scheduler into requests
+
+If you want Django views (including the schedules admin) to reach the broker or the scheduler, add a small ASGI middleware
+that puts them on the request scope. The Django `request.scope` dict is the same `scope` Starlette passed down, so values
+land directly on `request.scope["broker"]` / `request.scope["scheduler"]`:
+
+```python
+# asgi.py
+from starlette.middleware import Middleware
+
+
+class InjectBrokerMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] in ("http", "websocket"):
+            scope["broker"] = broker
+            scope["scheduler"] = scheduler
+        await self.app(scope, receive, send)
+
+
+application = Starlette(
+    routes=(...),
+    lifespan=broker_lifespan,
+    middleware=[Middleware(InjectBrokerMiddleware)],
+)
+```
+
+### Full example
+
+```python
+# asgi.py
+import os
+from contextlib import asynccontextmanager
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+django_asgi = get_asgi_application()
+
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.routing import Mount
+from starlette.staticfiles import StaticFiles
+from taskiq import TaskiqScheduler, async_shared_broker
+from taskiq_pg.asyncpg import AsyncpgBroker
+
+from taskiq_django import DjangoScheduleSource
+
+DSN = "postgres://taskiq_django:look_in_vault@localhost:5432/taskiq_django"
+broker = AsyncpgBroker(dsn=DSN)
+async_shared_broker.default_broker(broker)
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+
+
+@asynccontextmanager
+async def broker_lifespan(app):
+    await broker.startup()
+    for source in scheduler.sources:
+        await source.startup()
+    try:
+        yield
+    finally:
+        for source in scheduler.sources:
+            await source.shutdown()
+        await broker.shutdown()
+
+
+class InjectBrokerMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] in ("http", "websocket"):
+            scope["broker"] = broker
+            scope["scheduler"] = scheduler
+        await self.app(scope, receive, send)
+
+
+application = Starlette(
+    routes=(
+        Mount("/static", StaticFiles(directory="static"), name="static"),
+        Mount("/", django_asgi),
+    ),
+    lifespan=broker_lifespan,
+    middleware=[Middleware(InjectBrokerMiddleware)],
+)
+```
+
+Run the web process with any ASGI server, e.g. Granian:
+
+```bash
+granian example_app.asgi:application --interface asgi --reload
+```
+
+## Defining tasks
+
+Use `async_shared_broker.task` so tasks are not bound to a concrete broker at import time — the broker is attached at runtime
+via `async_shared_broker.default_broker(broker)`:
+
+```python
+# example_app/tasks.py
+from taskiq import async_shared_broker
+
+
+@async_shared_broker.task("solve_all_problems")
+async def best_task_ever(message: str) -> None:
+    print(f'Got "{message}"')
+```
+
+To make sure tasks are discovered and registered with the broker, use Taskiq's filesystem discovery flag (`--fs-discover`)
+when starting the worker, or import the tasks module from `asgi.py`.
+
+## Persistent schedules with `DjangoScheduleSource`
+
+`DjangoScheduleSource` stores `ScheduledTask` records in the Django database via the `taskiq_schedules` table. Plug it into
+your scheduler:
+
+```python
+from taskiq import TaskiqScheduler
+from taskiq_django import DjangoScheduleSource
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+```
+
+Schedules can now be managed through the Django admin: `/admin/taskiq_django/taskiqtaskschedule/` exposes list / add /
+change / delete views. Each action routes through the source's `add_schedule` / `delete_schedule` methods, so any side
+effects you add by subclassing `DjangoScheduleSource` will fire from the admin too.
+
+A schedule row carries the full `ScheduledTask` payload — `task_name`, `args`, `kwargs`, `labels`, plus the schedule
+definition (`cron` + optional `cron_offset`, or `time` for one-shots, or `interval` in seconds). Exactly one of `cron` /
+`time` / `interval` must be set.
+
+> `DjangoScheduleSource.startup()` does **not** truncate or seed the table — the admin is treated as the source of truth.
+> If you want to sync schedules declared on `@task(schedule=[...])` labels into the database, do it explicitly from a
+> one-off script or a management command.
+
+## Running the worker and the scheduler
+
+Both the worker and the scheduler import the broker and the scheduler objects from `asgi.py`:
+
+```bash
+# worker
+taskiq worker example_app.asgi:broker --fs-discover
+
+# scheduler
+taskiq scheduler example_app.asgi:scheduler --fs-discover
+```
+
+Because `asgi.py` calls `get_asgi_application()` at import time, Django is fully configured by the time the worker or
+scheduler process touches any ORM code — no extra bootstrapping needed.
+
+If you'd rather keep `asgi.py` web-only, move the broker/scheduler/`DJANGO_SETTINGS_MODULE` setup into a dedicated
+`broker.py` module and call `django.setup()` at the top of it; then point Taskiq at `example_app.broker:broker` instead.
+
+## Accessing the Django ORM from a Taskiq task
+
+Inside a worker process, Django ORM is fully available — both sync and async APIs:
+
+```python
+from django.contrib.auth.models import User
+from taskiq import async_shared_broker
+
+
+@async_shared_broker.task("list_users")
+async def list_users() -> None:
+    async for user in User.objects.all():
+        print(user.username)
+```
+
+When the worker imports `example_app.asgi:broker`, the module-level `get_asgi_application()` call has already run
+`django.setup()`, so model imports work immediately.
+
+## Local development
+
+The example project under `examples/` ships with a `Makefile`:
+
+```bash
+make run_infra       # docker compose up -d postgres
+make run             # granian + Starlette + Django
+make run_worker      # taskiq worker
+make run_scheduler   # taskiq scheduler
+```

taskiq_django-0.0.1/README.md

@@ -0,0 +1,343 @@
+# taskiq-django
+
+Django integration for [Taskiq](https://taskiq-python.github.io/).
+
+`taskiq-django` lets you run a Taskiq broker alongside a Django project and persist scheduled tasks in your Django database.
+It ships with:
+
+- `DjangoScheduleSource` — a `taskiq.ScheduleSource` backed by the Django ORM.
+- A Django admin for adding, editing and deleting schedules through the web UI.
+
+The package itself is broker-agnostic — pair it with any Taskiq broker (`AsyncpgBroker`, `RedisBroker`, `KafkaBroker`, etc.).
+The `examples/` folder uses [taskiq-postgres](https://github.com/danfimov/taskiq-postgres/) on top of PostgreSQL.
+
+## Installation
+
+```bash
+pip install taskiq-django
+```
+
+Add the app to `INSTALLED_APPS` so its model and admin are registered:
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    "taskiq_django",
+]
+```
+
+Then apply the migration that creates the `taskiq_schedules` table:
+
+```bash
+python manage.py migrate taskiq_django
+```
+
+## Using Taskiq with Django
+
+Taskiq broker and scheduler are async, while Django historically is sync. The cleanest way to host both in a single process
+is to serve Django over ASGI and let an ASGI server (`granian` or `uvicorn` for example) drive the broker lifecycle through
+Starlette's `lifespan` hook.
+
+The recipe below mirrors the one used in [`examples/example_app`](examples/example_app/) of this repository.
+
+### Default Django application
+
+A standard Django ASGI entry point looks like this:
+
+```python
+# asgi.py
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+application = get_asgi_application()
+```
+
+This is enough to serve Django through any ASGI server, but it has no place to plug a Taskiq broker into — Django's ASGI app
+does not expose `lifespan` events.
+
+### Serving Django via Starlette
+
+Wrap the Django ASGI app in a [Starlette](https://www.starlette.io/) application and mount it at `/`. Starlette supports
+`lifespan`, makes static files easy, and lets us add ASGI middleware around Django:
+
+```python
+# asgi.py
+import os
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+django_asgi = get_asgi_application()
+
+from starlette.applications import Starlette
+from starlette.routing import Mount
+
+application = Starlette(
+    routes=(
+        Mount("/", django_asgi),
+    ),
+)
+```
+
+> Set `DJANGO_SETTINGS_MODULE` and call `get_asgi_application()` **before** importing anything that touches Django models
+> (including `taskiq_django`). Otherwise `django.apps.AppRegistryNotReady` will fire at import time.
+
+### Serving static files with Starlette
+
+Collect Django's static files into a folder and serve it via `StaticFiles`. In your Django settings:
+
+```python
+# settings.py
+STATIC_URL = "static/"
+STATIC_ROOT = "static/"
+```
+
+Then add a `Mount` in front of Django:
+
+```python
+# asgi.py
+from starlette.staticfiles import StaticFiles
+
+application = Starlette(
+    routes=(
+        Mount("/static", StaticFiles(directory="static"), name="static"),
+        Mount("/", django_asgi),
+    ),
+)
+```
+
+Run `python manage.py collectstatic` once so admin CSS/JS appears under `static/`.
+
+### Broker and scheduler lifespan
+
+Construct the broker and scheduler at module level, and use a Starlette `lifespan` to start and stop them with the process:
+
+```python
+# asgi.py
+from contextlib import asynccontextmanager
+from taskiq import TaskiqScheduler, async_shared_broker
+from taskiq_pg.asyncpg import AsyncpgBroker
+
+from taskiq_django import DjangoScheduleSource
+
+DSN = "postgres://taskiq_django:look_in_vault@localhost:5432/taskiq_django"
+broker = AsyncpgBroker(dsn=DSN)
+async_shared_broker.default_broker(broker)
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+
+
+@asynccontextmanager
+async def broker_lifespan(app):
+    await broker.startup()
+    for source in scheduler.sources:
+        await source.startup()
+    try:
+        yield
+    finally:
+        for source in scheduler.sources:
+            await source.shutdown()
+        await broker.shutdown()
+
+
+application = Starlette(
+    routes=(...),
+    lifespan=broker_lifespan,
+)
+```
+
+### Injecting broker and scheduler into requests
+
+If you want Django views (including the schedules admin) to reach the broker or the scheduler, add a small ASGI middleware
+that puts them on the request scope. The Django `request.scope` dict is the same `scope` Starlette passed down, so values
+land directly on `request.scope["broker"]` / `request.scope["scheduler"]`:
+
+```python
+# asgi.py
+from starlette.middleware import Middleware
+
+
+class InjectBrokerMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] in ("http", "websocket"):
+            scope["broker"] = broker
+            scope["scheduler"] = scheduler
+        await self.app(scope, receive, send)
+
+
+application = Starlette(
+    routes=(...),
+    lifespan=broker_lifespan,
+    middleware=[Middleware(InjectBrokerMiddleware)],
+)
+```
+
+### Full example
+
+```python
+# asgi.py
+import os
+from contextlib import asynccontextmanager
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_app.settings")
+django_asgi = get_asgi_application()
+
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.routing import Mount
+from starlette.staticfiles import StaticFiles
+from taskiq import TaskiqScheduler, async_shared_broker
+from taskiq_pg.asyncpg import AsyncpgBroker
+
+from taskiq_django import DjangoScheduleSource
+
+DSN = "postgres://taskiq_django:look_in_vault@localhost:5432/taskiq_django"
+broker = AsyncpgBroker(dsn=DSN)
+async_shared_broker.default_broker(broker)
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+
+
+@asynccontextmanager
+async def broker_lifespan(app):
+    await broker.startup()
+    for source in scheduler.sources:
+        await source.startup()
+    try:
+        yield
+    finally:
+        for source in scheduler.sources:
+            await source.shutdown()
+        await broker.shutdown()
+
+
+class InjectBrokerMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] in ("http", "websocket"):
+            scope["broker"] = broker
+            scope["scheduler"] = scheduler
+        await self.app(scope, receive, send)
+
+
+application = Starlette(
+    routes=(
+        Mount("/static", StaticFiles(directory="static"), name="static"),
+        Mount("/", django_asgi),
+    ),
+    lifespan=broker_lifespan,
+    middleware=[Middleware(InjectBrokerMiddleware)],
+)
+```
+
+Run the web process with any ASGI server, e.g. Granian:
+
+```bash
+granian example_app.asgi:application --interface asgi --reload
+```
+
+## Defining tasks
+
+Use `async_shared_broker.task` so tasks are not bound to a concrete broker at import time — the broker is attached at runtime
+via `async_shared_broker.default_broker(broker)`:
+
+```python
+# example_app/tasks.py
+from taskiq import async_shared_broker
+
+
+@async_shared_broker.task("solve_all_problems")
+async def best_task_ever(message: str) -> None:
+    print(f'Got "{message}"')
+```
+
+To make sure tasks are discovered and registered with the broker, use Taskiq's filesystem discovery flag (`--fs-discover`)
+when starting the worker, or import the tasks module from `asgi.py`.
+
+## Persistent schedules with `DjangoScheduleSource`
+
+`DjangoScheduleSource` stores `ScheduledTask` records in the Django database via the `taskiq_schedules` table. Plug it into
+your scheduler:
+
+```python
+from taskiq import TaskiqScheduler
+from taskiq_django import DjangoScheduleSource
+
+scheduler = TaskiqScheduler(
+    broker=broker,
+    sources=[DjangoScheduleSource()],
+)
+```
+
+Schedules can now be managed through the Django admin: `/admin/taskiq_django/taskiqtaskschedule/` exposes list / add /
+change / delete views. Each action routes through the source's `add_schedule` / `delete_schedule` methods, so any side
+effects you add by subclassing `DjangoScheduleSource` will fire from the admin too.
+
+A schedule row carries the full `ScheduledTask` payload — `task_name`, `args`, `kwargs`, `labels`, plus the schedule
+definition (`cron` + optional `cron_offset`, or `time` for one-shots, or `interval` in seconds). Exactly one of `cron` /
+`time` / `interval` must be set.
+
+> `DjangoScheduleSource.startup()` does **not** truncate or seed the table — the admin is treated as the source of truth.
+> If you want to sync schedules declared on `@task(schedule=[...])` labels into the database, do it explicitly from a
+> one-off script or a management command.
+
+## Running the worker and the scheduler
+
+Both the worker and the scheduler import the broker and the scheduler objects from `asgi.py`:
+
+```bash
+# worker
+taskiq worker example_app.asgi:broker --fs-discover
+
+# scheduler
+taskiq scheduler example_app.asgi:scheduler --fs-discover
+```
+
+Because `asgi.py` calls `get_asgi_application()` at import time, Django is fully configured by the time the worker or
+scheduler process touches any ORM code — no extra bootstrapping needed.
+
+If you'd rather keep `asgi.py` web-only, move the broker/scheduler/`DJANGO_SETTINGS_MODULE` setup into a dedicated
+`broker.py` module and call `django.setup()` at the top of it; then point Taskiq at `example_app.broker:broker` instead.
+
+## Accessing the Django ORM from a Taskiq task
+
+Inside a worker process, Django ORM is fully available — both sync and async APIs:
+
+```python
+from django.contrib.auth.models import User
+from taskiq import async_shared_broker
+
+
+@async_shared_broker.task("list_users")
+async def list_users() -> None:
+    async for user in User.objects.all():
+        print(user.username)
+```
+
+When the worker imports `example_app.asgi:broker`, the module-level `get_asgi_application()` call has already run
+`django.setup()`, so model imports work immediately.
+
+## Local development
+
+The example project under `examples/` ships with a `Makefile`:
+
+```bash
+make run_infra       # docker compose up -d postgres
+make run             # granian + Starlette + Django
+make run_worker      # taskiq worker
+make run_scheduler   # taskiq scheduler
+```

taskiq_django-0.0.1/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "taskiq-django"
+version = "0.0.1"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "django>=6.0.5",
+    "taskiq>=0.12.4",
+]
+
+[dependency-groups]
+dev = [
+    "prek>=0.4.4",
+    {include-group = "test"},
+    {include-group = "lint"},
+    {include-group = "types"},
+    {include-group = "examples"},
+]
+lint = [
+    "ruff>=0.15.14",
+    "zizmor>=1.25.2",
+]
+types = [
+    "django-stubs>=6.0.5",
+    "ty>=0.0.39",
+]
+examples = [
+    "granian[reload]>=2.7.5",
+    "starlette>=1.2.1",
+    "taskiq-postgres[asyncpg]>=0.8.0",
+]
+test = [
+    "pytest>=9.1.0",
+    "pytest-asyncio>=1.4.0",
+    "pytest-django>=4.12.0",
+    "dirty-equals>=0.11",
+    "pytest-deadfixtures>=3.1.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.11,<0.12"]
+build-backend = "uv_build"
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    "I",
+    "E",
+    "W",
+    "S",
+    "F",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"examples/example_app/asgi.py" = ["E402"]
+"tests/**" = ["S101"]

taskiq_django-0.0.1/src/taskiq_django/__init__.py

@@ -0,0 +1,9 @@
+__all__ = ["DjangoScheduleSource"]
+
+
+def __getattr__(name: str):
+    if name == "DjangoScheduleSource":
+        from taskiq_django.schedule_source import DjangoScheduleSource
+
+        return DjangoScheduleSource
+    raise AttributeError(f"module 'taskiq_django' has no attribute {name!r}")

taskiq_django-0.0.1/src/taskiq_django/admin.py

@@ -0,0 +1,175 @@
+from asgiref.sync import async_to_sync
+from django.contrib import admin, messages
+from django.contrib.admin import helpers
+from django.http import HttpResponseRedirect
+from django.template.response import TemplateResponse
+from django.urls import URLPattern, path, reverse
+
+from taskiq_django.forms import TaskiqTaskScheduleForm
+from taskiq_django.models import TaskiqTaskSchedule
+from taskiq_django.schedule_source import DjangoScheduleSource
+
+FIELDSETS = [
+    (None, {"fields": ["schedule_id", "task_name"]}),
+    ("Schedule", {"fields": ["cron", "cron_offset", "time", "interval"]}),
+    ("Payload", {"fields": ["args", "kwargs", "labels"], "classes": ["collapse"]}),
+]
+
+
+def _get_source(request) -> DjangoScheduleSource:
+    scheduler = request.scope["scheduler"]
+    for source in scheduler.sources:
+        if isinstance(source, DjangoScheduleSource):
+            return source
+    raise RuntimeError("DjangoScheduleSource is not registered in the scheduler.")
+
+
+@admin.register(TaskiqTaskSchedule)
+class TaskiqTaskScheduleAdmin(admin.ModelAdmin):
+    def get_urls(self) -> list[URLPattern]:
+        urls = super().get_urls()
+        wrap = self.admin_site.admin_view
+        custom_urls = [
+            path(
+                "",
+                wrap(self.external_list_view),
+                name="taskiq_django_taskiqtaskschedule_changelist",
+            ),
+            path(
+                "add/",
+                wrap(self.external_add_view),
+                name="taskiq_django_taskiqtaskschedule_add",
+            ),
+            path(
+                "<path:object_id>/change/",
+                wrap(self.external_change_view),
+                name="taskiq_django_taskiqtaskschedule_change",
+            ),
+            path(
+                "<path:object_id>/delete/",
+                wrap(self.external_delete_view),
+                name="taskiq_django_taskiqtaskschedule_delete",
+            ),
+        ]
+        return custom_urls + urls
+
+    def external_list_view(self, request):
+        source = _get_source(request)
+        tasks = async_to_sync(source.get_schedules)()
+        rows = [
+            {
+                "id": task.schedule_id,
+                "task_name": task.task_name,
+                "schedule": task.cron or task.time or (task.interval and f"every {task.interval}s"),
+                "created_at": None,
+                "updated_at": None,
+            }
+            for task in tasks
+        ]
+        context = {
+            **self.admin_site.each_context(request),
+            "title": self.model._meta.verbose_name_plural,
+            "opts": self.model._meta,
+            "rows": rows,
+        }
+        return TemplateResponse(request, "taskiq_django/list_view.html", context)
+
+    def external_add_view(self, request):
+        source = _get_source(request)
+        task_names = list(request.scope["broker"].get_all_tasks().keys())
+        if request.method == "POST":
+            form = TaskiqTaskScheduleForm(request.POST, task_names=task_names)
+            if form.is_valid():
+                async_to_sync(source.add_schedule)(form.to_scheduled_task())
+                messages.success(request, "Schedule created.")
+                return HttpResponseRedirect(
+                    reverse("admin:taskiq_django_taskiqtaskschedule_changelist")
+                )
+        else:
+            form = TaskiqTaskScheduleForm(task_names=task_names)
+        return self._render_form(request, form, title="Add taskiq schedule", object_id=None)
+
+    def external_change_view(self, request, object_id):
+        source = _get_source(request)
+        task_names = list(request.scope["broker"].get_all_tasks().keys())
+        if request.method == "POST":
+            form = TaskiqTaskScheduleForm(request.POST, task_names=task_names)
+            if form.is_valid():
+                async_to_sync(source.add_schedule)(form.to_scheduled_task())
+                messages.success(request, "Schedule updated.")
+                return HttpResponseRedirect(
+                    reverse("admin:taskiq_django_taskiqtaskschedule_changelist")
+                )
+        else:
+            task = self._find_schedule(source, object_id)
+            if task is None:
+                messages.error(request, f"Schedule {object_id} not found.")
+                return HttpResponseRedirect(
+                    reverse("admin:taskiq_django_taskiqtaskschedule_changelist")
+                )
+            form = TaskiqTaskScheduleForm.from_scheduled_task(task, task_names=task_names)
+        return self._render_form(
+            request, form, title="Change taskiq schedule", object_id=object_id
+        )
+
+    def external_delete_view(self, request, object_id):
+        if request.method == "POST":
+            source = _get_source(request)
+            async_to_sync(source.delete_schedule)(object_id)
+            messages.success(request, "Schedule deleted.")
+            return HttpResponseRedirect(
+                reverse("admin:taskiq_django_taskiqtaskschedule_changelist")
+            )
+        context = {
+            **self.admin_site.each_context(request),
+            "title": "Delete taskiq schedule",
+            "opts": self.model._meta,
+            "object_id": object_id,
+        }
+        return TemplateResponse(request, "taskiq_django/delete_confirmation.html", context)
+
+    def _render_form(self, request, form, *, title, object_id):
+        adminform = helpers.AdminForm(
+            form,
+            fieldsets=FIELDSETS,
+            prepopulated_fields={},
+            readonly_fields=[],
+            model_admin=self,
+        )
+        context = {
+            **self.admin_site.each_context(request),
+            "title": title,
+            "opts": self.model._meta,
+            "object_id": object_id,
+            "original": {"pk": object_id} if object_id else None,
+            "adminform": adminform,
+            "errors": helpers.AdminErrorList(form, []),
+            "media": self.media + adminform.media,
+            "is_popup": False,
+            "save_as": False,
+            "save_on_top": False,
+            "show_save": True,
+            "show_save_as_new": False,
+            "show_save_and_add_another": False,
+            "show_save_and_continue": False,
+            "show_close": False,
+            "show_delete_link": object_id is not None,
+            "can_change": True,
+            "add": object_id is None,
+            "change": object_id is not None,
+            "has_view_permission": True,
+            "has_add_permission": True,
+            "has_change_permission": True,
+            "has_delete_permission": True,
+            "has_file_field": False,
+            "has_editable_inline_admin_formsets": False,
+            "inline_admin_formsets": [],
+        }
+        return TemplateResponse(request, "taskiq_django/change_form.html", context)
+
+    @staticmethod
+    def _find_schedule(source: DjangoScheduleSource, schedule_id: str):
+        for task in async_to_sync(source.get_schedules)():
+            if task.schedule_id == schedule_id:
+                return task
+        return None

taskiq_django-0.0.1/src/taskiq_django/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class TaskiqApplicationConfig(AppConfig):
+    name = "taskiq_django"
+    verbose_name = "Taskiq django extension"

taskiq_django-0.0.1/src/taskiq_django/forms.py

@@ -0,0 +1,110 @@
+import uuid
+
+from django import forms
+from django.contrib.admin import widgets as admin_widgets
+from taskiq.scheduler.scheduled_task import ScheduledTask
+
+
+class NonEmptyJSONField(forms.JSONField):
+    """JSONField that treats {} and [] as valid (non-empty) values."""
+
+    empty_values = [None, ""]
+
+
+class TaskiqTaskScheduleForm(forms.Form):
+    schedule_id = forms.CharField(max_length=64, required=False, widget=forms.HiddenInput)
+    task_name = forms.CharField(
+        max_length=255,
+        widget=forms.TextInput(attrs={"class": "vTextField"}),
+    )
+
+    def __init__(self, *args, task_names: list[str] | None = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if task_names is not None:
+            choices = [(name, name) for name in task_names]
+            current = self.initial.get("task_name") or (
+                self.data.get("task_name") if self.is_bound else None
+            )
+            if current and current not in task_names:
+                choices.insert(0, (current, f"{current} (not registered)"))
+            self.fields["task_name"] = forms.ChoiceField(
+                choices=choices,
+                widget=forms.Select,
+            )
+    cron = forms.CharField(
+        max_length=255,
+        required=False,
+        widget=forms.TextInput(attrs={"class": "vTextField"}),
+        help_text="Standard cron expression (e.g. '0 * * * *').",
+    )
+    cron_offset = forms.CharField(
+        max_length=64,
+        required=False,
+        widget=forms.TextInput(attrs={"class": "vTextField"}),
+        help_text="Timezone or offset for cron evaluation.",
+    )
+    time = forms.SplitDateTimeField(
+        required=False,
+        widget=admin_widgets.AdminSplitDateTime,
+        help_text="One-shot run at this datetime (UTC).",
+    )
+    interval = forms.IntegerField(
+        min_value=1,
+        required=False,
+        widget=forms.NumberInput(attrs={"class": "vIntegerField"}),
+        help_text="Interval in seconds.",
+    )
+    args = NonEmptyJSONField(
+        initial=list,
+        widget=forms.Textarea(attrs={"class": "vLargeTextField", "rows": 4}),
+    )
+    kwargs = NonEmptyJSONField(
+        initial=dict,
+        widget=forms.Textarea(attrs={"class": "vLargeTextField", "rows": 4}),
+    )
+    labels = NonEmptyJSONField(
+        initial=dict,
+        widget=forms.Textarea(attrs={"class": "vLargeTextField", "rows": 4}),
+    )
+
+    def clean(self):
+        cleaned = super().clean() or {}
+        if not any((cleaned.get("cron"), cleaned.get("time"), cleaned.get("interval"))):
+            raise forms.ValidationError("One of cron, time or interval must be set.")
+        return cleaned
+
+    def to_scheduled_task(self) -> ScheduledTask:
+        cleaned = self.cleaned_data
+        return ScheduledTask(
+            schedule_id=cleaned.get("schedule_id") or uuid.uuid4().hex,
+            task_name=cleaned["task_name"],
+            labels=cleaned.get("labels") or {},
+            args=cleaned.get("args") or [],
+            kwargs=cleaned.get("kwargs") or {},
+            cron=cleaned.get("cron") or None,
+            cron_offset=cleaned.get("cron_offset") or None,
+            time=cleaned.get("time"),
+            interval=cleaned.get("interval"),
+        )
+
+    @classmethod
+    def from_scheduled_task(
+        cls,
+        task: ScheduledTask,
+        *,
+        task_names: list[str] | None = None,
+    ) -> "TaskiqTaskScheduleForm":
+        return cls(
+            initial={
+                "schedule_id": task.schedule_id,
+                "task_name": task.task_name,
+                "cron": task.cron,
+                "cron_offset": task.cron_offset,
+                "time": task.time,
+                "interval": task.interval,
+                "args": task.args,
+                "kwargs": task.kwargs,
+                "labels": task.labels,
+            },
+            task_names=task_names,
+        )

taskiq_django-0.0.1/src/taskiq_django/migrations/0001_initial.py

@@ -0,0 +1,35 @@
+# Generated by Django 6.0.5 on 2026-06-09 23:51
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='TaskiqTaskSchedule',
+            fields=[
+                ('schedule_id', models.CharField(max_length=64, primary_key=True, serialize=False)),
+                ('task_name', models.CharField(max_length=255)),
+                ('args', models.JSONField(db_default=[], default=list)),
+                ('kwargs', models.JSONField(db_default={}, default=dict)),
+                ('labels', models.JSONField(db_default={}, default=dict)),
+                ('cron', models.CharField(blank=True, max_length=255, null=True)),
+                ('cron_offset', models.CharField(blank=True, max_length=64, null=True)),
+                ('time', models.DateTimeField(blank=True, null=True)),
+                ('interval', models.PositiveIntegerField(blank=True, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'verbose_name': 'Task schedule',
+                'verbose_name_plural': 'Task schedules',
+                'db_table': 'taskiq_schedules',
+            },
+        ),
+    ]

taskiq_django-0.0.1/src/taskiq_django/models.py

@@ -0,0 +1,26 @@
+from django.db import models
+
+
+class TaskiqTaskSchedule(models.Model):
+    schedule_id = models.CharField(max_length=64, primary_key=True)
+    task_name = models.CharField(max_length=255)
+
+    args = models.JSONField(default=list, db_default=list())
+    kwargs = models.JSONField(default=dict, db_default=dict())
+    labels = models.JSONField(default=dict, db_default=dict())
+
+    cron = models.CharField(max_length=255, null=True, blank=True)
+    cron_offset = models.CharField(max_length=64, null=True, blank=True)
+    time = models.DateTimeField(null=True, blank=True)
+    interval = models.PositiveIntegerField(null=True, blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        verbose_name = "Task schedule"
+        verbose_name_plural = "Task schedules"
+        db_table = "taskiq_schedules"
+
+    def __str__(self) -> str:
+        return f"{self.task_name} ({self.schedule_id})"

taskiq_django-0.0.1/src/taskiq_django/schedule_source.py

@@ -0,0 +1,57 @@
+from datetime import timedelta
+
+from taskiq import ScheduleSource
+from taskiq.scheduler.scheduled_task import ScheduledTask
+
+from taskiq_django.models import TaskiqTaskSchedule
+
+
+def _to_scheduled_task(row: TaskiqTaskSchedule) -> ScheduledTask:
+    return ScheduledTask(
+        schedule_id=row.schedule_id,
+        task_name=row.task_name,
+        labels=row.labels or {},
+        args=row.args or [],
+        kwargs=row.kwargs or {},
+        cron=row.cron,
+        cron_offset=row.cron_offset,
+        time=row.time,
+        interval=row.interval,
+    )
+
+
+class DjangoScheduleSource(ScheduleSource):
+    """ScheduleSource backed by the Django ORM (TaskiqTaskSchedule model)."""
+
+    async def get_schedules(self) -> list[ScheduledTask]:
+        return [_to_scheduled_task(row) async for row in TaskiqTaskSchedule.objects.all()]
+
+    async def add_schedule(self, schedule: ScheduledTask) -> None:
+        interval = schedule.interval
+        if isinstance(interval, timedelta):
+            interval = int(interval.total_seconds())
+
+        cron_offset = schedule.cron_offset
+        if isinstance(cron_offset, timedelta):
+            cron_offset = str(int(cron_offset.total_seconds()))
+
+        await TaskiqTaskSchedule.objects.aupdate_or_create(
+            schedule_id=schedule.schedule_id,
+            defaults={
+                "task_name": schedule.task_name,
+                "labels": schedule.labels,
+                "args": schedule.args,
+                "kwargs": schedule.kwargs,
+                "cron": schedule.cron,
+                "cron_offset": cron_offset,
+                "time": schedule.time,
+                "interval": interval,
+            },
+        )
+
+    async def delete_schedule(self, schedule_id: str) -> None:
+        await TaskiqTaskSchedule.objects.filter(schedule_id=schedule_id).adelete()
+
+    async def post_send(self, task: ScheduledTask) -> None:
+        if task.time is not None:
+            await self.delete_schedule(task.schedule_id)

taskiq_django-0.0.1/src/taskiq_django/templates/taskiq_django/change_form.html

@@ -0,0 +1,16 @@
+{% extends "admin/change_form.html" %}
+{% load i18n admin_urls %}
+
+{% block object-tools %}{% endblock %}
+
+{% block breadcrumbs %}
+<div class="breadcrumbs">
+  <a href="{% url 'admin:index' %}">{% translate 'Home' %}</a>
+  &rsaquo;
+  <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
+  &rsaquo;
+  <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>
+  &rsaquo;
+  {{ title }}
+</div>
+{% endblock %}

taskiq_django-0.0.1/src/taskiq_django/templates/taskiq_django/delete_confirmation.html

@@ -0,0 +1,25 @@
+{% extends "admin/base_site.html" %}
+{% load i18n admin_urls %}
+
+{% block breadcrumbs %}
+<div class="breadcrumbs">
+  <a href="{% url 'admin:index' %}">{% translate 'Home' %}</a>
+  &rsaquo;
+  <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
+  &rsaquo;
+  <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_changelist' %}">{{ opts.verbose_name_plural|capfirst }}</a>
+  &rsaquo;
+  {% translate 'Delete' %}
+</div>
+{% endblock %}
+
+{% block content %}
+<p>{% blocktranslate %}Are you sure you want to delete schedule <strong>{{ object_id }}</strong>?{% endblocktranslate %}</p>
+<form method="post">
+  {% csrf_token %}
+  <input type="submit" value="{% translate "Yes, I'm sure" %}">
+  <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_change' object_id %}" class="button cancel-link">
+    {% translate 'No, take me back' %}
+  </a>
+</form>
+{% endblock %}

taskiq_django-0.0.1/src/taskiq_django/templates/taskiq_django/list_view.html

@@ -0,0 +1,83 @@
+{% extends "admin/change_list.html" %}
+{% load i18n admin_urls static %}
+
+{% block breadcrumbs %}
+<div class="breadcrumbs">
+  <a href="{% url 'admin:index' %}">{% translate 'Home' %}</a>
+  &rsaquo;
+  <a href="{% url 'admin:app_list' app_label=opts.app_label %}">{{ opts.app_config.verbose_name }}</a>
+  &rsaquo;
+  {{ opts.verbose_name_plural|capfirst }}
+</div>
+{% endblock %}
+
+{% block object-tools %}
+<ul class="object-tools">
+  <li>
+    <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_add' %}" class="addlink">Add taskiq schedule</a>
+  </li>
+</ul>
+{% endblock %}
+
+{% block search %}{% endblock %}
+{% block filters %}{% endblock %}
+{% block pagination %}{% endblock %}
+{% block date_hierarchy %}{% endblock %}
+
+{% block result_list %}
+<div class="results">
+  <table id="result_list">
+    <thead>
+      <tr>
+        <th scope="col">
+          <div class="text">
+            <span>Task name</span>
+          </div>
+        </th>
+        <th scope="col">
+          <div class="text">
+            <span>Schedule</span>
+          </div>
+        </th>
+        <th scope="col">
+          <div class="text">
+            <span>Created at</span>
+          </div>
+        </th>
+        <th scope="col">
+          <div class="text">
+            <span>Updated at</span>
+          </div>
+        </th>
+        <th scope="col">
+          <div class="text">
+            <span></span>
+          </div>
+        </th>
+      </tr>
+    </thead>
+    <tbody>
+      {% for row in rows %}
+      <tr>
+        <th class="field-task_name">
+          <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_change' row.id %}">
+            {{ row.task_name }}
+          </a>
+        </th>
+        <td>{{ row.schedule }}</td>
+        <td>{{ row.created_at }}</td>
+        <td>{{ row.updated_at }}</td>
+        <td>
+          <a href="{% url 'admin:taskiq_django_taskiqtaskschedule_delete' row.id %}"
+             class="deletelink">{% translate 'Delete' %}</a>
+        </td>
+      </tr>
+      {% empty %}
+      <tr>
+        <td colspan="5">No taskiq schedules available.</td>
+      </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+</div>
+{% endblock %}