hawkapi-celery 0.1.0__tar.gz → 0.2.0__tar.gz

hawkapi_celery-0.2.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.2.0 — 2026-05-16
+
+Security & correctness:
+
+- `_run_coroutine` no longer conflates the "no running loop" `RuntimeError` with the active-loop guard; it inspects `asyncio.get_running_loop()` explicitly and raises a clear error inside an event loop. Removed process-wide `asyncio.set_event_loop()` side effects.
+- `create_celery` validates `task_serializer` is contained in `accept_content` and raises `ValueError` otherwise.
+- `@task` no longer drops `max_retries=0` / `bind=False` / other falsy-but-meaningful overrides; only non-default kwargs are forwarded.
+- Context propagation stores reset tokens in a module-level `dict[str, Token]` keyed by `task.request.id` instead of mutating `task.request._hawkapi_token`.
+- `init_celery` / `resolve_celery` use `WeakKeyDictionary` keyed by the app object to avoid `id()` ABA collisions.
+
+## 0.1.0 — 2026-05-16
+
+Initial release.
+
+- `init_celery(app, ...)` + `app.state.celery`.
+- `@task(celery_app, ...)` decorator with `async def` support (runs coroutines on a private event loop) and auto-retry knobs.
+- Beat schedule helpers — `Periodic`, `add_periodic`, `every`, `every_seconds`, re-exported `crontab`.
+- Healthchecks — `check_broker`, `check_workers`, `healthcheck` → `HealthReport`.
+- Request-context propagation between HTTP handlers and workers (`bind_context`, `current_context`, `attach_context_signals`).
+- DI helpers — `Depends(get_celery)`, `get_task_result(task_id, request)`.
+- Test fixtures — `eager_mode`, `record_tasks` / `TaskRecorder`.
+- Retry helper — `compute_backoff` with decorrelated jitter.
+- Extras: `[redis]`.

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hawkapi-celery
-Version: 0.1.0
+Version: 0.2.0
 Summary: Celery integration for HawkAPI — async tasks, beat scheduler, context propagation, healthchecks, eager-mode fixtures
 Project-URL: Homepage, https://pypi.org/project/hawkapi-celery/
 Project-URL: Repository, https://github.com/ashimov/hawkapi-celery

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hawkapi-celery"
-version = "0.1.0"
+version = "0.2.0"
 description = "Celery integration for HawkAPI — async tasks, beat scheduler, context propagation, healthchecks, eager-mode fixtures"
 readme = "README.md"
 license = { file = "LICENSE" }

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/src/hawkapi_celery/__init__.py

@@ -21,7 +21,7 @@ from ._plugin import get_celery, get_task_result, init_celery, resolve_celery
 from ._tasks import compute_backoff, task
 from ._testing import CapturedTask, TaskRecorder, eager_mode, record_tasks
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "CapturedTask",

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/src/hawkapi_celery/_app.py

@@ -34,6 +34,11 @@ class CeleryConfig:
 def create_celery(name: str = "hawkapi", *, config: CeleryConfig | None = None) -> Celery:
     """Build a Celery app from :class:`CeleryConfig` with sensible defaults."""
     config = config or CeleryConfig()
+    if config.task_serializer not in config.accept_content:
+        raise ValueError(
+            f"task_serializer {config.task_serializer!r} not in "
+            f"accept_content {config.accept_content!r}"
+        )
     app = Celery(name, broker=config.broker_url, backend=config.result_backend)
     app.conf.update(
         broker_url=config.broker_url,

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/src/hawkapi_celery/_context.py

@@ -32,6 +32,11 @@ _CONTEXT_VAR: contextvars.ContextVar[dict[str, Any] | None] = contextvars.Contex
 )
 _HEADER_KEY = "hawkapi_context"
 
+# Keyed by task.request.id; tokens are popped in task_postrun. Living on a
+# module-level dict (rather than mutating ``task.request``) keeps Celery's
+# request stack immutable from our side.
+_PENDING_TOKENS: dict[str, contextvars.Token[dict[str, Any] | None]] = {}
+
 
 def current_context() -> dict[str, Any]:
     """Return the active context dict (empty if unset)."""
@@ -79,17 +84,22 @@ def attach_context_signals(celery_app: Celery) -> None:
             return
         try:
             headers = task.request.headers or {}
+            task_id = task.request.id
         except AttributeError:
             return
         ctx = headers.get(_HEADER_KEY) if isinstance(headers, dict) else None
-        if isinstance(ctx, dict):
-            task.request._hawkapi_token = _CONTEXT_VAR.set(dict(ctx))
+        if isinstance(ctx, dict) and task_id:
+            _PENDING_TOKENS[task_id] = _CONTEXT_VAR.set(dict(ctx))
 
     @task_postrun.connect(weak=False)
     def _postrun(task: Any = None, **_: Any) -> None:
         if task is None:
             return
-        token = getattr(task.request, "_hawkapi_token", None)
+        try:
+            task_id = task.request.id
+        except AttributeError:
+            return
+        token = _PENDING_TOKENS.pop(task_id, None) if task_id else None
         if token is not None:
             import contextlib
 

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/src/hawkapi_celery/_plugin.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import contextlib
+import weakref
 from typing import Any
 
 from celery import Celery
@@ -16,10 +18,16 @@ class _StateNamespace:
     celery: Any
 
 
-_ACTIVE_APPS: dict[int, Celery] = {}
+_ACTIVE_APPS: weakref.WeakKeyDictionary[Any, Celery] = weakref.WeakKeyDictionary()
 _LAST_APP: list[Celery | None] = [None]
 
 
+def _try_remember(app: Any, celery_app: Celery) -> None:
+    # Unhashable / non-weakref-able app — skip the cache silently.
+    with contextlib.suppress(TypeError):
+        _ACTIVE_APPS[app] = celery_app
+
+
 def init_celery(
     app: Any,
     *,
@@ -42,7 +50,7 @@ def init_celery(
     if getattr(app, "state", None) is None:
         app.state = _StateNamespace()
     app.state.celery = celery_app
-    _ACTIVE_APPS[id(app)] = celery_app
+    _try_remember(app, celery_app)
     _LAST_APP[0] = celery_app
     return celery_app
 
@@ -50,7 +58,10 @@ def init_celery(
 def resolve_celery(app: Any) -> Celery | None:
     if app is None:
         return _LAST_APP[0]
-    found = _ACTIVE_APPS.get(id(app))
+    try:
+        found = _ACTIVE_APPS.get(app)
+    except TypeError:
+        found = None
     if found is not None:
         return found
     state = getattr(app, "state", None)

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/src/hawkapi_celery/_tasks.py

@@ -37,16 +37,22 @@ def task(
     def decorator(fn: Callable[P, R]) -> Any:
         register_kwargs: dict[str, Any] = {
             "name": name or f"{fn.__module__}.{fn.__qualname__}",
-            "queue": queue,
-            "bind": bind,
-            "autoretry_for": autoretry_for,
-            "retry_backoff": retry_backoff,
-            "retry_backoff_max": retry_backoff_max,
-            "retry_jitter": retry_jitter,
-            "max_retries": max_retries,
-            **task_kwargs,
         }
-        register_kwargs = {k: v for k, v in register_kwargs.items() if v is not None}
+        if queue is not None:
+            register_kwargs["queue"] = queue
+        if bind:
+            register_kwargs["bind"] = True
+        if autoretry_for:
+            register_kwargs["autoretry_for"] = autoretry_for
+        if retry_backoff is not False:
+            register_kwargs["retry_backoff"] = retry_backoff
+        if retry_backoff_max != 600:
+            register_kwargs["retry_backoff_max"] = retry_backoff_max
+        if retry_jitter is not True:
+            register_kwargs["retry_jitter"] = retry_jitter
+        if max_retries != 3:
+            register_kwargs["max_retries"] = max_retries
+        register_kwargs.update(task_kwargs)
 
         if inspect.iscoroutinefunction(fn):
 
@@ -61,20 +67,22 @@ def task(
 
 
 def _run_coroutine(coro_fn: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
-    """Run ``coro_fn(*args, **kwargs)`` on a private event loop."""
+    """Run ``coro_fn(*args, **kwargs)`` on a private event loop.
+
+    Raises ``RuntimeError`` if called from within an already-running event loop —
+    we never want to block the outer loop or attempt re-entry.
+    """
     try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # Nested call — bail rather than block the outer loop.
-            raise RuntimeError("cannot run coroutine task inside an active event loop")
+        running = asyncio.get_running_loop()
     except RuntimeError:
-        loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
+        running = None
+    if running is not None and running.is_running():
+        raise RuntimeError("cannot run coroutine task inside an active event loop")
+    new_loop = asyncio.new_event_loop()
     try:
-        return loop.run_until_complete(coro_fn(*args, **kwargs))
+        return new_loop.run_until_complete(coro_fn(*args, **kwargs))
     finally:
-        loop.close()
-        asyncio.set_event_loop(None)
+        new_loop.close()
 
 
 def compute_backoff(

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/tests/test_app.py

@@ -33,3 +33,22 @@ def test_create_celery_applies_config() -> None:
 def test_create_celery_extra_kwargs() -> None:
     app = create_celery(config=CeleryConfig(extra_kwargs={"task_acks_late": True}))
     assert app.conf.task_acks_late is True
+
+
+def test_accept_content_validation() -> None:
+    """task_serializer must be listed in accept_content; otherwise create_celery rejects it."""
+    import pytest
+
+    bad_serializer = "pickle"  # deliberately not in accept_content
+    with pytest.raises(ValueError, match="not in accept_content"):
+        create_celery(config=CeleryConfig(task_serializer=bad_serializer, accept_content=["json"]))
+
+
+def test_accept_content_validation_passes_when_consistent() -> None:
+    app = create_celery(
+        config=CeleryConfig(
+            task_serializer="json",
+            accept_content=["json", "yaml"],
+        )
+    )
+    assert app.conf.task_serializer == "json"

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/tests/test_plugin.py

@@ -57,7 +57,7 @@ def test_get_celery_500_when_not_configured() -> None:
 
     saved = _p._LAST_APP[0]
     _p._LAST_APP[0] = None
-    _p._ACTIVE_APPS.pop(id(app), None)
+    _p._ACTIVE_APPS.pop(app, None)
     try:
         client = TestClient(app)
         r = client.get("/info")

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/tests/test_tasks.py

@@ -44,3 +44,42 @@ def test_compute_backoff_increases() -> None:
 
 def test_compute_backoff_capped() -> None:
     assert compute_backoff(20, base=1, cap=10, jitter=False) == 10
+
+
+def test_run_coroutine_raises_clear_error_in_async_context(celery_app: Celery) -> None:
+    """When invoked from inside an active event loop, the wrapper must bail loudly."""
+    import asyncio
+
+    import pytest
+
+    @task(celery_app, name="t.inner_async")
+    async def inner() -> int:
+        return 1
+
+    async def outer() -> None:
+        with eager_mode(celery_app):
+            # Calling .delay().get() inside an active loop hits _run_coroutine.
+            inner.delay().get()
+
+    with pytest.raises(RuntimeError, match="cannot run coroutine task inside an active event loop"):
+        asyncio.run(outer())
+
+
+def test_max_retries_zero_is_passed_through(celery_app: Celery) -> None:
+    @task(celery_app, name="t.no_retry", max_retries=0)
+    def fn() -> str:
+        return "ok"
+
+    registered = celery_app.tasks["t.no_retry"]
+    assert registered.max_retries == 0
+
+
+def test_bind_false_default_does_not_override(celery_app: Celery) -> None:
+    """``bind=False`` is the default and should not be forwarded as a kwarg."""
+
+    @task(celery_app, name="t.unbound")
+    def fn() -> str:
+        return "ok"
+
+    # The task should be registered cleanly without raising.
+    assert "t.unbound" in celery_app.tasks

{hawkapi_celery-0.1.0 → hawkapi_celery-0.2.0}/uv.lock

@@ -115,7 +115,7 @@ wheels = [
 
 [[package]]
 name = "hawkapi-celery"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "celery" },

hawkapi_celery-0.1.0/CHANGELOG.md

@@ -1,15 +0,0 @@
-# Changelog
-
-## 0.1.0 — 2026-05-16
-
-Initial release.
-
-- `init_celery(app, ...)` + `app.state.celery`.
-- `@task(celery_app, ...)` decorator with `async def` support (runs coroutines on a private event loop) and auto-retry knobs.
-- Beat schedule helpers — `Periodic`, `add_periodic`, `every`, `every_seconds`, re-exported `crontab`.
-- Healthchecks — `check_broker`, `check_workers`, `healthcheck` → `HealthReport`.
-- Request-context propagation between HTTP handlers and workers (`bind_context`, `current_context`, `attach_context_signals`).
-- DI helpers — `Depends(get_celery)`, `get_task_result(task_id, request)`.
-- Test fixtures — `eager_mode`, `record_tasks` / `TaskRecorder`.
-- Retry helper — `compute_backoff` with decorrelated jitter.
-- Extras: `[redis]`.