dynamicforms-fastapi-viewsets 0.3.4__tar.gz → 0.3.6__tar.gz

{dynamicforms_fastapi_viewsets-0.3.4 → dynamicforms_fastapi_viewsets-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dynamicforms-fastapi-viewsets
-Version: 0.3.4
+Version: 0.3.6
 Summary: Django REST Framework-style viewsets for FastAPI, with optional Celery-backed async execution and a Vue/TypeScript client counterpart.
 Project-URL: Homepage, https://github.com/dynamicforms/fastapi-viewsets
 Project-URL: Repository, https://github.com/dynamicforms/fastapi-viewsets

dynamicforms_fastapi_viewsets-0.3.6/fastapi_viewsets/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.6"

dynamicforms_fastapi_viewsets-0.3.6/fastapi_viewsets/decorators/celery_viewset/__init__.py

@@ -0,0 +1,82 @@
+import logging
+import sys
+
+from ..lifecycle_runner import LifecycleType
+from .client import celery_viewset_client, get_registered_queue_keys
+from .result_reader import get_result_queue_key, get_running_queue_keys, push_result, start_result_reader, stop_result_reader
+from .server import celery_viewset_server
+
+logger = logging.getLogger(__name__)
+
+# Allow explicit override via set_is_celery_worker()
+_is_celery_worker: bool | None = None
+
+
+def set_is_celery_worker(is_worker: bool) -> None:
+    """Explicitly set whether we are running in a Celery worker context."""
+    global _is_celery_worker
+    _is_celery_worker = is_worker
+
+
+def _detect_is_celery_worker() -> bool:
+    """Auto-detect if we are running inside a Celery worker by inspecting sys.argv."""
+    if _is_celery_worker is not None:
+        return _is_celery_worker
+    return len(sys.argv) > 0 and "celery" in sys.argv[0].lower()
+
+
+def celery_viewset(celery_app, task_prefix: str, lifecycle: LifecycleType = "singleton", redis_client=None):
+    """
+    Convenience decorator that auto-detects whether to use client or server mode.
+
+    - In a Celery worker (detected via sys.argv or set_is_celery_worker): uses celery_viewset_server
+    - In a FastAPI app: uses celery_viewset_client
+
+    For explicit control, use celery_viewset_client or celery_viewset_server directly.
+    """
+    if _detect_is_celery_worker():
+        return celery_viewset_server(celery_app, task_prefix, lifecycle=lifecycle, redis_client=redis_client)
+    else:
+        if redis_client is None:
+            raise ValueError("redis_client is required for celery_viewset in client (FastAPI) mode")
+        return celery_viewset_client(celery_app, task_prefix, redis_client=redis_client)
+
+
+def check_result_readers() -> frozenset[str]:
+    """
+    Verify that every queue_key registered by a celery_viewset_client decorator (client/FastAPI
+    mode only) has a running result reader task, logging a warning for each one that doesn't.
+
+    celery_viewset_client decorators register their queue_key at import/decoration time, so by the
+    time FastAPI startup code runs, every queue_key in use is already known - call this once, right
+    after starting all result readers in the FastAPI lifespan. A queue_key with no running reader
+    means requests dispatched to that celery_viewset hang forever waiting for a result that never
+    arrives (the Celery task itself runs fine - only the FastAPI-side pickup is missing).
+
+    Returns the set of queue_keys that are missing a reader (empty if everything is running).
+    Never raises - this is a diagnostic aid, not a correctness check enforced by the library.
+    """
+    missing = get_registered_queue_keys() - get_running_queue_keys()
+    for queue_key in sorted(missing):
+        logger.warning(
+            "No result reader is running for queue_key=%s - requests dispatched to this "
+            "celery_viewset will hang waiting for a result that never arrives. Call "
+            "start_result_reader(redis_client, %r) in your FastAPI lifespan.",
+            queue_key, queue_key,
+        )
+    return frozenset(missing)
+
+
+__all__ = [
+    "celery_viewset",
+    "celery_viewset_client",
+    "celery_viewset_server",
+    "set_is_celery_worker",
+    "start_result_reader",
+    "stop_result_reader",
+    "check_result_readers",
+    "push_result",
+    "get_result_queue_key",
+    "get_registered_queue_keys",
+    "get_running_queue_keys",
+]

{dynamicforms_fastapi_viewsets-0.3.4 → dynamicforms_fastapi_viewsets-0.3.6}/fastapi_viewsets/decorators/celery_viewset/client.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, TypeVar
 from fastapi.routing import APIRoute
 from pydantic import BaseModel
 
-from ...context import serialize_context
+from ...context import Context, serialize_context
 from ..build_schema import build_schema
 from . import result_reader
 from .result_reader import get_result_queue_key
@@ -21,6 +21,15 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 logger = logging.getLogger(__name__)
 
+# queue_keys registered by celery_viewset_client so far - populated at decoration (import) time,
+# used by check_result_readers() to spot a queue_key with no running result reader.
+_registered_queue_keys: set[str] = set()
+
+
+def get_registered_queue_keys() -> frozenset[str]:
+    """Return the queue_keys registered by celery_viewset_client decorators applied so far."""
+    return frozenset(_registered_queue_keys)
+
 
 def celery_viewset_client(
     celery_app: "Celery",
@@ -53,12 +62,22 @@ def celery_viewset_client(
             "queue_key": queue_key,
             "mode": "client",
         }
+        _registered_queue_keys.add(queue_key)
 
         return cls
 
     return decorator
 
 
+async def _serialize_value(value):
+    """Convert a Context or BaseModel value into a JSON-safe structure for Celery/Kombu transport."""
+    if isinstance(value, Context):
+        return await serialize_context(value.raw())
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="json")
+    return value
+
+
 def _patch_method(cls: type, original_endpoint, task_name: str, celery_app, redis_client, queue_key: str):
     """Replace the method on cls with an async version that sends a Celery task and awaits the result."""
     method_name = original_endpoint.__name__
@@ -71,18 +90,17 @@ def _patch_method(cls: type, original_endpoint, task_name: str, celery_app, redi
         result_reader.register_future(correlation_id, future)
 
         try:
+            serializable_args = [await _serialize_value(v) for v in args]
             serializable_kwargs = {}
             for k, v in kwargs.items():
                 if k == "context":
                     serializable_kwargs[k] = await serialize_context(v.raw())
-                elif isinstance(v, BaseModel):
-                    serializable_kwargs[k] = v.model_dump()
                 else:
-                    serializable_kwargs[k] = v
+                    serializable_kwargs[k] = await _serialize_value(v)
             logger.info("Celery task scheduling: %s (correlation_id=%s)", task_name, correlation_id)
             celery_app.send_task(
                     task_name,
-                    args=args,
+                    args=serializable_args,
                     kwargs={**serializable_kwargs, "_correlation_id": correlation_id, "_result_queue_key": queue_key},
             )
             return await future

{dynamicforms_fastapi_viewsets-0.3.4 → dynamicforms_fastapi_viewsets-0.3.6}/fastapi_viewsets/decorators/celery_viewset/result_reader.py

@@ -14,8 +14,8 @@ logger = logging.getLogger(__name__)
 # Global registry: correlation_id -> asyncio.Future
 _pending_futures: dict[str, asyncio.Future] = {}
 
-# Global reader task reference
-_reader_task: asyncio.Task | None = None
+# Global reader task registry, keyed by queue_key - one reader per Celery viewset task_prefix
+_reader_tasks: dict[str, asyncio.Task] = {}
 
 
 def register_future(correlation_id: str, future: asyncio.Future) -> None:
@@ -78,22 +78,39 @@ def push_result(redis_client: "redis.Redis", queue_key: str, correlation_id: str
     redis_client.rpush(queue_key, json.dumps(data))
 
 
+def get_running_queue_keys() -> frozenset[str]:
+    """Return the queue_keys that currently have a running (not done) reader task."""
+    return frozenset(key for key, task in _reader_tasks.items() if not task.done())
+
+
 async def start_result_reader(redis_client: "redis.Redis", queue_key: str, poll_interval: float = 0.05) -> asyncio.Task:
-    """Start the background result reader task. Should be called on FastAPI startup."""
-    global _reader_task
-    if _reader_task is not None and not _reader_task.done():
-        return _reader_task
-    _reader_task = asyncio.create_task(result_reader_loop(redis_client, queue_key, poll_interval))
-    return _reader_task
-
-
-async def stop_result_reader() -> None:
-    """Stop the background result reader task. Should be called on FastAPI shutdown."""
-    global _reader_task
-    if _reader_task is not None and not _reader_task.done():
-        _reader_task.cancel()
-        try:
-            await _reader_task
-        except asyncio.CancelledError:
-            pass
-    _reader_task = None
+    """
+    Start the background result reader task for the given queue_key.
+
+    Should be called once per queue_key (i.e. once per celery_viewset task_prefix) on FastAPI
+    startup. Calling it again with the same queue_key while its reader is still running returns
+    the existing task; a different queue_key gets its own independent reader task.
+    """
+    existing = _reader_tasks.get(queue_key)
+    if existing is not None and not existing.done():
+        return existing
+    task = asyncio.create_task(result_reader_loop(redis_client, queue_key, poll_interval))
+    _reader_tasks[queue_key] = task
+    return task
+
+
+async def stop_result_reader(queue_key: str | None = None) -> None:
+    """
+    Stop background result reader task(s). Should be called on FastAPI shutdown.
+
+    If queue_key is given, stop only that reader; otherwise stop all running readers.
+    """
+    keys = [queue_key] if queue_key is not None else list(_reader_tasks.keys())
+    for key in keys:
+        task = _reader_tasks.pop(key, None)
+        if task is not None and not task.done():
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass

{dynamicforms_fastapi_viewsets-0.3.4 → dynamicforms_fastapi_viewsets-0.3.6}/fastapi_viewsets/decorators/celery_viewset/server.py

@@ -27,7 +27,7 @@ T = TypeVar("T")
 def _to_jsonable(value):
     """Recursively convert Pydantic models and lists to JSON-serializable structures."""
     if isinstance(value, BaseModel):
-        return value.model_dump()
+        return value.model_dump(mode="json")
     if isinstance(value, list):
         return [_to_jsonable(v) for v in value]
     return value

dynamicforms_fastapi_viewsets-0.3.4/fastapi_viewsets/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.4"

dynamicforms_fastapi_viewsets-0.3.4/fastapi_viewsets/decorators/celery_viewset/__init__.py

@@ -1,51 +0,0 @@
-import sys
-
-from ..lifecycle_runner import LifecycleType
-from .client import celery_viewset_client
-from .result_reader import get_result_queue_key, push_result, start_result_reader, stop_result_reader
-from .server import celery_viewset_server
-
-# Allow explicit override via set_is_celery_worker()
-_is_celery_worker: bool | None = None
-
-
-def set_is_celery_worker(is_worker: bool) -> None:
-    """Explicitly set whether we are running in a Celery worker context."""
-    global _is_celery_worker
-    _is_celery_worker = is_worker
-
-
-def _detect_is_celery_worker() -> bool:
-    """Auto-detect if we are running inside a Celery worker by inspecting sys.argv."""
-    if _is_celery_worker is not None:
-        return _is_celery_worker
-    return len(sys.argv) > 0 and "celery" in sys.argv[0].lower()
-
-
-def celery_viewset(celery_app, task_prefix: str, lifecycle: LifecycleType = "singleton", redis_client=None):
-    """
-    Convenience decorator that auto-detects whether to use client or server mode.
-
-    - In a Celery worker (detected via sys.argv or set_is_celery_worker): uses celery_viewset_server
-    - In a FastAPI app: uses celery_viewset_client
-
-    For explicit control, use celery_viewset_client or celery_viewset_server directly.
-    """
-    if _detect_is_celery_worker():
-        return celery_viewset_server(celery_app, task_prefix, lifecycle=lifecycle, redis_client=redis_client)
-    else:
-        if redis_client is None:
-            raise ValueError("redis_client is required for celery_viewset in client (FastAPI) mode")
-        return celery_viewset_client(celery_app, task_prefix, redis_client=redis_client)
-
-
-__all__ = [
-    "celery_viewset",
-    "celery_viewset_client",
-    "celery_viewset_server",
-    "set_is_celery_worker",
-    "start_result_reader",
-    "stop_result_reader",
-    "push_result",
-    "get_result_queue_key",
-]