hawkapi-taskiq 0.1.0__tar.gz

hawkapi_taskiq-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: ruff check
+        run: uv run ruff check .
+      - name: ruff format check
+        run: uv run ruff format --check .
+
+  typecheck:
+    name: Typecheck
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: pyright
+        run: uv run pyright src/
+
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: uv sync --extra dev
+      - name: Run tests
+        run: uv run pytest tests/ -q

hawkapi_taskiq-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,25 @@
+name: Release
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-and-publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write  # required for trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+      - name: Build package
+        run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

hawkapi_taskiq-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+dist/
+build/
+*.egg-info/
+*.egg
+.eggs/
+.venv/
+venv/
+env/
+.env
+*.log
+.mypy_cache/
+.pyright/
+.ruff_cache/
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+.hypothesis/
+.tox/
+.nox/
+*.swp
+*.swo
+*~
+.DS_Store
+.idea/
+.vscode/
+.history/
+site/
+.remember/

hawkapi_taskiq-0.1.0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.1.0 — 2026-05-17
+
+Initial release.
+
+Security review applied before ship:
+
+- `task_name` smuggled via `**task_kwargs` no longer bypasses the duplicate-name guard (defense in depth).
+- `extra={"serializer": ...}` is rejected to prevent a future broker release accepting that kwarg from bypassing the JSON-only enforcement (CWE-502 hardening).
+- `result_backend_url` now raises `NotImplementedError` rather than silently dropping the value — a misconfigured result backend can no longer be ignored.
+- Double-init guard on `init_taskiq` — calling it twice on the same app raises rather than double-registering startup/shutdown hooks.
+- `check_broker` actually probes the broker (was a static `True` before) and scrubs Redis/NATS credentials from any error string.
+- `add_scheduled` removed from the public API — it set labels in a format `TaskiqScheduler` does not consume. `Scheduled` remains as a cron-validation value type; README shows the direct `LabelScheduleSource` wiring.
+
+Features:
+
+- `create_broker(TaskIQConfig(...))` — URL-scheme allowlist (`memory://`, `redis://`, `rediss://`, `nats://`), JSON serializer enforced at construction.
+- `@task(broker, ...)` decorator with duplicate-name detection.
+- `Scheduled` value type with cron-syntax validation via `croniter` (extras `[cron]`).
+- `init_taskiq(app, ...)` wires startup/shutdown into the app lifecycle. `Depends(get_broker)` + `WeakKeyDictionary` registry.
+- `check_broker()` health probe + `HealthReport` with credential scrubbing.
+- `in_memory_broker()` async context manager for tests.
+- Extras: `[redis]` (taskiq-redis), `[nats]` (taskiq-nats), `[cron]` (croniter).

hawkapi_taskiq-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HawkAPI Contributors
+
+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.

hawkapi_taskiq-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: hawkapi-taskiq
+Version: 0.1.0
+Summary: TaskIQ integration for HawkAPI — modern async-native task queue, DI, scheduling, JSON-only formatter
+Project-URL: Homepage, https://pypi.org/project/hawkapi-taskiq/
+Project-URL: Repository, https://github.com/ashimov/hawkapi-taskiq
+Project-URL: Issues, https://github.com/ashimov/hawkapi-taskiq/issues
+Author-email: HawkAPI Contributors <hawkapi@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2026 HawkAPI Contributors
+        
+        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.
+License-File: LICENSE
+Keywords: async,hawkapi,queue,scheduling,taskiq,tasks
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: hawkapi>=0.1.7
+Requires-Dist: taskiq>=0.11
+Provides-Extra: cron
+Requires-Dist: croniter>=2.0; extra == 'cron'
+Provides-Extra: dev
+Requires-Dist: croniter>=2.0; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: nats
+Requires-Dist: taskiq-nats>=0.5; extra == 'nats'
+Provides-Extra: redis
+Requires-Dist: taskiq-redis>=1.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# hawkapi-taskiq
+
+[TaskIQ](https://taskiq-python.github.io/) integration for [HawkAPI](https://github.com/ashimov/HawkAPI). Modern async-native task queue — a lighter, async-first alternative to Celery.
+
+## Install
+
+```bash
+pip install hawkapi-taskiq
+pip install 'hawkapi-taskiq[redis]'    # + taskiq-redis
+pip install 'hawkapi-taskiq[nats]'     # + taskiq-nats
+pip install 'hawkapi-taskiq[cron]'     # + croniter for schedule validation
+```
+
+## Quickstart
+
+```python
+from hawkapi import Depends, HawkAPI
+from hawkapi_taskiq import TaskIQConfig, get_broker, init_taskiq, task
+
+app = HawkAPI()
+broker = init_taskiq(app, config=TaskIQConfig(broker_url="redis://localhost:6379/0"))
+
+
+@task(broker, name="emails.send")
+async def send_email(to: str, subject: str) -> None:
+    ...
+
+
+@app.post("/notify")
+async def notify(email: str, b = Depends(get_broker)):
+    await send_email.kiq(email, "Hello")
+    return {"ok": True}
+```
+
+## Broker selection
+
+Choose by URL scheme — all others are rejected:
+
+| URL | Broker |
+|---|---|
+| `memory://` | `InMemoryBroker` (tests, single-process) |
+| `redis://host:6379/0` | `ListQueueBroker` (taskiq-redis) |
+| `rediss://...` | same, with TLS |
+| `nats://server:4222` | `NatsBroker` (taskiq-nats) |
+
+Any other scheme raises `ValueError` at `create_broker()` — this is a security feature, not a limitation. The allowlist prevents accidentally enabling brokers that use unsafe deserialization formats.
+
+## Scheduling
+
+v0.1.0 ships a `Scheduled` value type with cron-syntax validation. Wire it to TaskIQ's native scheduler yourself — we deliberately avoid a "magic" registration helper that doesn't compose cleanly with the upstream `TaskiqScheduler`:
+
+```python
+from hawkapi_taskiq import Scheduled
+from taskiq import TaskiqScheduler
+from taskiq.schedule_sources import LabelScheduleSource
+
+
+@task(broker, name="myapp.cleanup")
+async def cleanup() -> None:
+    ...
+
+
+# 1. Validate the schedule (cron syntax) up front.
+schedule = Scheduled(cron="0 * * * *")    # raises ValueError if malformed
+
+# 2. Apply it as a label LabelScheduleSource reads.
+cleanup.labels["schedule"] = [{"cron": schedule.cron, "args": [], "kwargs": {}}]
+
+
+# 3. Run a scheduler process alongside the worker.
+scheduler = TaskiqScheduler(broker=broker, sources=[LabelScheduleSource(broker)])
+```
+
+`Scheduled(cron="...")` validates via [`croniter`](https://github.com/kiorky/croniter) (install with `[cron]` extra). Both `cron` and `interval_seconds` set are rejected (exactly one is required).
+
+## Health
+
+```python
+from hawkapi_taskiq import check_broker
+
+report = await check_broker(broker)
+# HealthReport(broker_ok=True, broker_type="ListQueueBroker", error="")
+```
+
+## Testing
+
+```python
+from hawkapi_taskiq import in_memory_broker, task
+
+
+async def test_my_task():
+    async with in_memory_broker() as broker:
+        @task(broker, name="t.work")
+        async def work(x: int) -> int:
+            return x * 2
+
+        await work.kiq(21)
+        # Execute pending tasks via TaskIQ's normal flow.
+```
+
+## Security
+
+- **JSON-only serialization** — TaskIQ defaults are fine; we explicitly reject any other serializer via `TaskIQConfig.serializer` to prevent arbitrary-deserialization at consume time (CWE-502).
+- **Broker URL scheme allowlist** — only `memory://`, `redis://`, `rediss://`, `nats://`.
+- **Task name registry** — duplicate `@task(name=...)` raises at registration. TaskIQ silently overrides; we disallow.
+- **Cron expression validation** at registration time — malformed expressions fail fast.
+
+## Development
+
+```bash
+git clone https://github.com/ashimov/hawkapi-taskiq.git
+cd hawkapi-taskiq
+uv sync --extra dev
+uv run pytest -q
+uv run ruff check . && uv run ruff format --check .
+uv run pyright src/
+```
+
+## License
+
+MIT.

hawkapi_taskiq-0.1.0/README.md

@@ -0,0 +1,121 @@
+# hawkapi-taskiq
+
+[TaskIQ](https://taskiq-python.github.io/) integration for [HawkAPI](https://github.com/ashimov/HawkAPI). Modern async-native task queue — a lighter, async-first alternative to Celery.
+
+## Install
+
+```bash
+pip install hawkapi-taskiq
+pip install 'hawkapi-taskiq[redis]'    # + taskiq-redis
+pip install 'hawkapi-taskiq[nats]'     # + taskiq-nats
+pip install 'hawkapi-taskiq[cron]'     # + croniter for schedule validation
+```
+
+## Quickstart
+
+```python
+from hawkapi import Depends, HawkAPI
+from hawkapi_taskiq import TaskIQConfig, get_broker, init_taskiq, task
+
+app = HawkAPI()
+broker = init_taskiq(app, config=TaskIQConfig(broker_url="redis://localhost:6379/0"))
+
+
+@task(broker, name="emails.send")
+async def send_email(to: str, subject: str) -> None:
+    ...
+
+
+@app.post("/notify")
+async def notify(email: str, b = Depends(get_broker)):
+    await send_email.kiq(email, "Hello")
+    return {"ok": True}
+```
+
+## Broker selection
+
+Choose by URL scheme — all others are rejected:
+
+| URL | Broker |
+|---|---|
+| `memory://` | `InMemoryBroker` (tests, single-process) |
+| `redis://host:6379/0` | `ListQueueBroker` (taskiq-redis) |
+| `rediss://...` | same, with TLS |
+| `nats://server:4222` | `NatsBroker` (taskiq-nats) |
+
+Any other scheme raises `ValueError` at `create_broker()` — this is a security feature, not a limitation. The allowlist prevents accidentally enabling brokers that use unsafe deserialization formats.
+
+## Scheduling
+
+v0.1.0 ships a `Scheduled` value type with cron-syntax validation. Wire it to TaskIQ's native scheduler yourself — we deliberately avoid a "magic" registration helper that doesn't compose cleanly with the upstream `TaskiqScheduler`:
+
+```python
+from hawkapi_taskiq import Scheduled
+from taskiq import TaskiqScheduler
+from taskiq.schedule_sources import LabelScheduleSource
+
+
+@task(broker, name="myapp.cleanup")
+async def cleanup() -> None:
+    ...
+
+
+# 1. Validate the schedule (cron syntax) up front.
+schedule = Scheduled(cron="0 * * * *")    # raises ValueError if malformed
+
+# 2. Apply it as a label LabelScheduleSource reads.
+cleanup.labels["schedule"] = [{"cron": schedule.cron, "args": [], "kwargs": {}}]
+
+
+# 3. Run a scheduler process alongside the worker.
+scheduler = TaskiqScheduler(broker=broker, sources=[LabelScheduleSource(broker)])
+```
+
+`Scheduled(cron="...")` validates via [`croniter`](https://github.com/kiorky/croniter) (install with `[cron]` extra). Both `cron` and `interval_seconds` set are rejected (exactly one is required).
+
+## Health
+
+```python
+from hawkapi_taskiq import check_broker
+
+report = await check_broker(broker)
+# HealthReport(broker_ok=True, broker_type="ListQueueBroker", error="")
+```
+
+## Testing
+
+```python
+from hawkapi_taskiq import in_memory_broker, task
+
+
+async def test_my_task():
+    async with in_memory_broker() as broker:
+        @task(broker, name="t.work")
+        async def work(x: int) -> int:
+            return x * 2
+
+        await work.kiq(21)
+        # Execute pending tasks via TaskIQ's normal flow.
+```
+
+## Security
+
+- **JSON-only serialization** — TaskIQ defaults are fine; we explicitly reject any other serializer via `TaskIQConfig.serializer` to prevent arbitrary-deserialization at consume time (CWE-502).
+- **Broker URL scheme allowlist** — only `memory://`, `redis://`, `rediss://`, `nats://`.
+- **Task name registry** — duplicate `@task(name=...)` raises at registration. TaskIQ silently overrides; we disallow.
+- **Cron expression validation** at registration time — malformed expressions fail fast.
+
+## Development
+
+```bash
+git clone https://github.com/ashimov/hawkapi-taskiq.git
+cd hawkapi-taskiq
+uv sync --extra dev
+uv run pytest -q
+uv run ruff check . && uv run ruff format --check .
+uv run pyright src/
+```
+
+## License
+
+MIT.

hawkapi_taskiq-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hawkapi-taskiq"
+version = "0.1.0"
+description = "TaskIQ integration for HawkAPI — modern async-native task queue, DI, scheduling, JSON-only formatter"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.12"
+authors = [
+    { name = "HawkAPI Contributors", email = "hawkapi@users.noreply.github.com" },
+]
+keywords = ["hawkapi", "taskiq", "tasks", "queue", "async", "scheduling"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Distributed Computing",
+    "Typing :: Typed",
+]
+dependencies = [
+    "hawkapi>=0.1.7",
+    "taskiq>=0.11",
+]
+
+[project.optional-dependencies]
+redis = ["taskiq-redis>=1.0"]
+nats = ["taskiq-nats>=0.5"]
+cron = ["croniter>=2.0"]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "croniter>=2.0",
+    "ruff>=0.8",
+    "pyright>=1.1",
+]
+
+[project.urls]
+Homepage = "https://pypi.org/project/hawkapi-taskiq/"
+Repository = "https://github.com/ashimov/hawkapi-taskiq"
+Issues = "https://github.com/ashimov/hawkapi-taskiq/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hawkapi_taskiq"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "S"]
+ignore = ["S101", "S105", "S110", "B008", "SIM105", "SIM108", "SIM113"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S"]
+
+[tool.pyright]
+pythonVersion = "3.12"
+typeCheckingMode = "strict"
+reportUnknownVariableType = false
+reportUnknownMemberType = false
+reportUnknownArgumentType = false
+reportMissingTypeStubs = false
+reportUntypedFunctionDecorator = false
+reportGeneralTypeIssues = false

hawkapi_taskiq-0.1.0/src/hawkapi_taskiq/__init__.py

@@ -0,0 +1,35 @@
+"""hawkapi-taskiq — TaskIQ integration for HawkAPI.
+
+Modern async-native task queue. URL-scheme allowlist enforces JSON-only
+serialization to prevent arbitrary-deserialization vulnerabilities. Broker
+DI via ``init_taskiq(app, ...)`` + ``Depends(get_broker)``. ``Scheduled``
+provides cron-syntax validation; wire it into TaskIQ's own scheduler
+sources (see README).
+"""
+
+from __future__ import annotations
+
+from ._broker import create_broker
+from ._config import ALLOWED_BROKER_SCHEMES, TaskIQConfig
+from ._health import HealthReport, check_broker
+from ._plugin import get_broker, init_taskiq, resolve_broker
+from ._schedule import Scheduled
+from ._tasks import task
+from ._testing import in_memory_broker
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ALLOWED_BROKER_SCHEMES",
+    "HealthReport",
+    "Scheduled",
+    "TaskIQConfig",
+    "__version__",
+    "check_broker",
+    "create_broker",
+    "get_broker",
+    "in_memory_broker",
+    "init_taskiq",
+    "resolve_broker",
+    "task",
+]

hawkapi_taskiq-0.1.0/src/hawkapi_taskiq/_broker.py

@@ -0,0 +1,68 @@
+"""Broker factory — URL-scheme dispatch with strict allowlist."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._config import ALLOWED_BROKER_SCHEMES, TaskIQConfig, _scheme
+
+
+def create_broker(config: TaskIQConfig | None = None) -> Any:
+    """Build an :class:`AsyncBroker` from ``config``. Raises ``ValueError`` for
+    any URL scheme not in :data:`ALLOWED_BROKER_SCHEMES`."""
+    cfg = config or TaskIQConfig()
+
+    if cfg.serializer != "json":
+        raise ValueError(
+            f"hawkapi-taskiq only supports the JSON serializer in v0.1.0; got {cfg.serializer!r}"
+        )
+
+    # Defense in depth — block ``serializer`` from ``extra`` so a future broker
+    # release that accepts the kwarg cannot bypass the JSON-only guarantee above.
+    if "serializer" in cfg.extra:
+        raise ValueError("'serializer' in extra is not permitted; JSON is enforced")
+
+    broker_url = cfg.broker_url.strip()
+    scheme = _scheme(broker_url)
+    if scheme not in ALLOWED_BROKER_SCHEMES:
+        raise ValueError(
+            f"broker_url scheme {scheme!r} is not in the allowlist "
+            f"{sorted(ALLOWED_BROKER_SCHEMES)!r}"
+        )
+
+    if cfg.result_backend_url:
+        # v0.1.0 does not yet plumb result_backend_url through to the broker —
+        # raise early so a misconfigured result backend cannot be silently dropped.
+        raise NotImplementedError(
+            "result_backend_url is not wired in v0.1.0; configure the result backend "
+            "on the broker directly via TaskIQConfig.extra"
+        )
+
+    if scheme == "memory":
+        from taskiq import InMemoryBroker
+
+        return InMemoryBroker()
+
+    if scheme in ("redis", "rediss"):
+        try:
+            from taskiq_redis import ListQueueBroker  # type: ignore[import-not-found]
+        except ImportError as exc:  # pragma: no cover
+            raise ImportError(
+                "taskiq-redis is required for redis brokers; pip install 'hawkapi-taskiq[redis]'"
+            ) from exc
+        return ListQueueBroker(url=broker_url, **cfg.extra)
+
+    if scheme == "nats":
+        try:
+            from taskiq_nats import NatsBroker  # type: ignore[import-not-found]
+        except ImportError as exc:  # pragma: no cover
+            raise ImportError(
+                "taskiq-nats is required for nats brokers; pip install 'hawkapi-taskiq[nats]'"
+            ) from exc
+        return NatsBroker(servers=[broker_url], **cfg.extra)
+
+    # Unreachable — the allowlist check above gates this.
+    raise ValueError(f"unsupported scheme {scheme!r}")
+
+
+__all__ = ["create_broker"]

hawkapi_taskiq-0.1.0/src/hawkapi_taskiq/_config.py

@@ -0,0 +1,38 @@
+"""TaskIQ configuration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class TaskIQConfig:
+    """Builder for a TaskIQ broker via :func:`hawkapi_taskiq.create_broker`."""
+
+    broker_url: str = "memory://"
+    """Broker connection string. Only ``memory://``, ``redis://``, ``rediss://``,
+    ``nats://`` are accepted — anything else raises ``ValueError`` to prevent
+    accidentally enabling unsafe-deserialization brokers."""
+
+    result_backend_url: str = ""
+    """Optional result-backend URL. Same scheme allowlist as ``broker_url``."""
+
+    timezone: str = "UTC"
+    task_default_queue: str = "default"
+    serializer: str = "json"
+    """Always ``"json"`` for v0.1.0. Other serializers are rejected at runtime
+    to prevent arbitrary-deserialization vulns (CWE-502)."""
+
+    extra: dict[str, Any] = field(default_factory=dict)
+    """Forwarded as keyword args to the broker constructor."""
+
+
+ALLOWED_BROKER_SCHEMES = frozenset({"memory", "redis", "rediss", "nats"})
+
+
+def _scheme(url: str) -> str:
+    return url.split("://", 1)[0].lower() if "://" in url else ""
+
+
+__all__ = ["ALLOWED_BROKER_SCHEMES", "TaskIQConfig", "_scheme"]