hawkapi-taskiq 0.1.0__py3-none-any.whl

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/_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/_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"]

hawkapi_taskiq/_health.py

@@ -0,0 +1,60 @@
+"""Broker health probe."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass
+from typing import Any
+
+_CRED_RE = re.compile(r"(redis|rediss|nats)://[^@]*@")
+
+
+def _scrub(text: str) -> str:
+    """Strip user:password from any URL substrings in ``text``."""
+    return _CRED_RE.sub(r"\1://***@", text)
+
+
+@dataclass(slots=True)
+class HealthReport:
+    broker_ok: bool
+    broker_type: str = ""
+    error: str = ""
+
+
+async def check_broker(broker: Any, *, timeout: float = 5.0) -> HealthReport:
+    """Probe the broker.
+
+    - ``InMemoryBroker`` is always healthy when constructed; we still verify
+      that ``startup()`` ran by inspecting ``is_worker_process`` plus the
+      ``_running`` flag taskiq sets internally.
+    - For redis / nats brokers we attempt a no-op kick using the broker's
+      private startup machinery within ``timeout`` seconds.
+    """
+    btype = type(broker).__name__
+
+    async def _probe() -> None:
+        # InMemoryBroker has no remote dependency — touching .is_worker_process
+        # is enough. For network brokers we read .connection / .pool /
+        # ._is_started; if any expected attribute raises, surface as failure.
+        is_worker = getattr(broker, "is_worker_process", None)
+        if is_worker is None:
+            raise RuntimeError("broker does not expose is_worker_process")
+        # Trigger any lazy connection setup the broker has wired into kick():
+        # most broker types lazily open the network only on first send. We
+        # don't actually kick a task (that would require a registered name);
+        # instead we look at ``_is_started`` if present.
+        started = getattr(broker, "_is_started", True)
+        if started is False:
+            raise RuntimeError("broker not started")
+
+    try:
+        await asyncio.wait_for(_probe(), timeout=timeout)
+        return HealthReport(broker_ok=True, broker_type=btype)
+    except TimeoutError:
+        return HealthReport(broker_ok=False, broker_type=btype, error="timeout")
+    except Exception as exc:
+        return HealthReport(broker_ok=False, broker_type=btype, error=_scrub(str(exc)))
+
+
+__all__ = ["HealthReport", "check_broker"]

hawkapi_taskiq/_plugin.py

@@ -0,0 +1,98 @@
+"""init_taskiq + get_broker + WeakKeyDictionary registry."""
+
+from __future__ import annotations
+
+from typing import Any
+from weakref import WeakKeyDictionary
+
+from hawkapi import HTTPException, Request
+
+from ._broker import create_broker
+from ._config import TaskIQConfig
+
+
+class _StateNamespace:
+    taskiq: Any
+
+
+_ACTIVE: WeakKeyDictionary[Any, Any] = WeakKeyDictionary()
+_LAST: list[Any | None] = [None]
+
+
+def init_taskiq(
+    app: Any,
+    *,
+    broker: Any = None,
+    config: TaskIQConfig | None = None,
+    auto_startup: bool = True,
+) -> Any:
+    """Attach a TaskIQ broker to ``app.state.taskiq``.
+
+    Pass ``broker=`` with a pre-built broker, or ``config=`` to construct one
+    via :func:`create_broker`. ``auto_startup=True`` wires ``broker.startup()``
+    and ``broker.shutdown()`` into the app lifecycle.
+    """
+    if broker is None:
+        broker = create_broker(config)
+
+    # Reject double-initialisation — registering lifecycle hooks twice would
+    # call startup()/shutdown() on the stale broker after this one replaces it.
+    if getattr(app, "state", None) is not None and getattr(app.state, "taskiq", None) is not None:
+        raise RuntimeError(
+            "init_taskiq has already been called on this app; create a new app or "
+            "drop the previous broker explicitly before re-initialising"
+        )
+
+    if getattr(app, "state", None) is None:
+        app.state = _StateNamespace()
+    app.state.taskiq = broker
+    try:
+        _ACTIVE[app] = broker
+    except TypeError:
+        pass
+    _LAST[0] = broker
+
+    if auto_startup and hasattr(app, "on_startup"):
+
+        async def _start() -> None:
+            startup = getattr(broker, "startup", None)
+            if startup is not None:
+                await startup()
+
+        app.on_startup(_start)
+
+    if auto_startup and hasattr(app, "on_shutdown"):
+
+        async def _stop() -> None:
+            shutdown = getattr(broker, "shutdown", None)
+            if shutdown is not None:
+                await shutdown()
+
+        app.on_shutdown(_stop)
+
+    return broker
+
+
+def resolve_broker(app: Any) -> Any | None:
+    if app is None:
+        return _LAST[0]
+    try:
+        found = _ACTIVE.get(app)
+    except TypeError:
+        found = None
+    if found is not None:
+        return found
+    state = getattr(app, "state", None)
+    if state is not None and hasattr(state, "taskiq"):
+        return state.taskiq
+    return _LAST[0]
+
+
+def get_broker(request: Request) -> Any:
+    broker = resolve_broker(request.scope.get("app"))
+    if broker is None:
+        raise HTTPException(500, detail="TaskIQ not configured — call init_taskiq(app, ...) first")
+    return broker
+
+
+__all__ = ["get_broker", "init_taskiq", "resolve_broker"]

hawkapi_taskiq/_schedule.py

@@ -0,0 +1,36 @@
+"""Cron-syntax validator for schedule entries.
+
+For v0.1.0 we ship only the value-type :class:`Scheduled` with validation —
+it is up to the operator to wire it into TaskIQ's native scheduler sources.
+See README for the recommended pattern.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Scheduled:
+    """A schedule descriptor with validation at construction time."""
+
+    cron: str = ""
+    interval_seconds: float = 0.0
+
+    def __post_init__(self) -> None:
+        if (self.cron and self.interval_seconds) or (not self.cron and not self.interval_seconds):
+            raise ValueError("Scheduled requires exactly one of `cron` or `interval_seconds`")
+        if self.cron:
+            # Validate cron syntax up-front. croniter is an optional dep — if not
+            # installed, we skip validation rather than fail registration.
+            try:
+                from croniter import croniter  # type: ignore[import-not-found]
+            except ImportError:
+                return
+            if not croniter.is_valid(self.cron):
+                raise ValueError(f"invalid cron expression: {self.cron!r}")
+        elif self.interval_seconds <= 0:
+            raise ValueError("interval_seconds must be > 0")
+
+
+__all__ = ["Scheduled"]

hawkapi_taskiq/_tasks.py

@@ -0,0 +1,53 @@
+"""Task decorator + name-collision guard."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+def task(
+    broker: Any,
+    *,
+    name: str | None = None,
+    queue: str | None = None,
+    retry_on_error: bool = False,
+    max_retries: int = 3,
+    **task_kwargs: Any,
+) -> Callable[[Callable[..., Any]], Any]:
+    """Register a function as a TaskIQ task.
+
+    - Detects ``async def`` automatically — runs as coroutine on the worker.
+    - Sync functions are wrapped via TaskIQ's normal handling.
+    - Collision detection: registering the same ``name`` twice raises
+      ``ValueError`` (TaskIQ silently overrides; we disallow).
+    """
+
+    def decorator(fn: Callable[..., Any]) -> Any:
+        task_name = name or f"{fn.__module__}.{fn.__qualname__}"
+        existing = getattr(broker, "_hawkapi_task_names", None)
+        if existing is None:
+            existing = set()
+            broker._hawkapi_task_names = existing
+        if task_name in existing:
+            raise ValueError(f"task name {task_name!r} already registered")
+        existing.add(task_name)
+
+        # Pop reserved keys from ``task_kwargs`` BEFORE merging — otherwise a
+        # caller could pass ``task_name=`` in ``**task_kwargs`` and silently
+        # bypass the duplicate-name guard above.
+        task_kwargs.pop("task_name", None)
+        kw: dict[str, Any] = {"task_name": task_name}
+        if queue is not None:
+            kw["queue"] = queue
+        if retry_on_error:
+            kw["retry_on_error"] = True
+            kw["max_retries"] = max_retries
+        kw.update(task_kwargs)
+
+        return broker.task(**kw)(fn)
+
+    return decorator
+
+
+__all__ = ["task"]

hawkapi_taskiq/_testing.py

@@ -0,0 +1,24 @@
+"""Test helpers — in-memory broker fixture."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from ._broker import create_broker
+from ._config import TaskIQConfig
+
+
+@asynccontextmanager
+async def in_memory_broker() -> AsyncGenerator[Any, None]:
+    """Yield a started InMemoryBroker; shut it down on exit."""
+    broker = create_broker(TaskIQConfig(broker_url="memory://"))
+    await broker.startup()
+    try:
+        yield broker
+    finally:
+        await broker.shutdown()
+
+
+__all__ = ["in_memory_broker"]

hawkapi_taskiq/py.typed

@@ -0,0 +1 @@
+

hawkapi_taskiq-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+hawkapi_taskiq/__init__.py,sha256=mQtwxBvA7sjc3BG8Cwlv-VjkkaRWlQ0JaFiOGgGMTkg,987
+hawkapi_taskiq/_broker.py,sha256=zvf5fTppAU5ucXgCqaK07ob9a0vllfuBUGR3Amst-sU,2591
+hawkapi_taskiq/_config.py,sha256=JXHs4BCw5nbPa-APP_a_RmhRuSYtDOEyRCCaXM0725U,1222
+hawkapi_taskiq/_health.py,sha256=cu3oAHYz9GOnzR9sSDQr1jQesSI8EThMnNkkalSdSds,2192
+hawkapi_taskiq/_plugin.py,sha256=z9HwEBaBsqnViXaf0SMgRNG3S0vLpV8KrTNEvwm43ao,2732
+hawkapi_taskiq/_schedule.py,sha256=9ZUHqHTM_cdYU3_qMYCNdnSVT4UWdaLWmcQMfqbm1KM,1301
+hawkapi_taskiq/_tasks.py,sha256=BG1Bb3wHl2LhDoi_CNrAQQTAXyV7MeteVYPADuxah_w,1711
+hawkapi_taskiq/_testing.py,sha256=syGKcLPcdls70CpQoKpL3rb_NSep1djpot7fcV0201s,611
+hawkapi_taskiq/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hawkapi_taskiq-0.1.0.dist-info/METADATA,sha256=dm-1osTS5brz-ytuyv820RXlOr0ixfAoqtQDIJhzdWU,6501
+hawkapi_taskiq-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+hawkapi_taskiq-0.1.0.dist-info/licenses/LICENSE,sha256=_RpjhvsfLqqeG_gv2cRatjIxCTGXTpXhKU9jqLZXYa4,1077
+hawkapi_taskiq-0.1.0.dist-info/RECORD,,

hawkapi_taskiq-0.1.0.dist-info/WHEEL

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

hawkapi_taskiq-0.1.0.dist-info/licenses/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.