lcdp-fastapi-utils 1.5.8__tar.gz

lcdp_fastapi_utils-1.5.8/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: lcdp-fastapi-utils
+Version: 1.5.8
+Summary: FastApi Utils
+Author: Le Comptoir Des Pharmacies
+Author-email: webmaster@lecomptoirdespharmacies.fr
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: uvicorn (==0.34.2)

lcdp_fastapi_utils-1.5.8/lcdp_fastapi_utils/background_task.py

@@ -0,0 +1,74 @@
+import asyncio
+import functools
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from typing import Callable, Any, TypeVar, Coroutine
+
+log = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+
+def background_task(
+        interval: int,
+        name: str = None,
+        max_workers: int = 0,
+) -> Callable[[Callable[..., Coroutine[Any, Any, T]]], Callable[..., Coroutine[Any, Any, None]]]:
+    """
+    Decorator that turns a coroutine into a background task
+    with proper cancellation handling for a graceful shutdown.
+
+    Args:
+        interval: Interval in seconds between each execution
+        name: Name of the task for logging (optional)
+        max_workers: Maximum number of workers. 0 means no ThreadPoolExecutor
+
+    Returns:
+        The decorated function that runs at regular intervals
+    """
+
+    def decorator(func: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., Coroutine[Any, Any, None]]:
+        task_name = name or func.__name__
+
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> None:
+            try:
+                if max_workers > 0:
+                    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+                        try:
+                            kwargs['pool'] = pool
+                            await _run_task_loop(func, task_name, interval, *args, **kwargs)
+                        finally:
+                            # When task is finished (normal or cancelled by SIGTERM) then shutdown the pool and cancel any futures
+                            pool.shutdown(wait=False, cancel_futures=True)
+                else:
+                    await _run_task_loop(func, task_name, interval, *args, **kwargs)
+            except asyncio.CancelledError:
+                log.info(f"{task_name} cancelled, shutting down gracefully")
+            finally:
+                log.info(f"{task_name} shut down complete")
+
+        return wrapper
+
+    return decorator
+
+
+async def _run_task_loop(
+        func: Callable[..., Coroutine[Any, Any, T]],
+        task_name: str,
+        interval: int,
+        *args: Any,
+        **kwargs: Any
+) -> None:
+    """Runs the function in a loop with cancellation handling."""
+    while True:
+        try:
+            await func(*args, **kwargs)
+        except Exception:
+            log.exception(f"Error in {task_name}")
+
+        try:
+            await asyncio.sleep(interval)
+        except asyncio.CancelledError:
+            log.info(f"{task_name} received cancellation signal, shutting down gracefully")
+            break

lcdp_fastapi_utils-1.5.8/pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "lcdp-fastapi-utils"
+# https://github.com/python-poetry/poetry/issues/1208
+version = "1.5.8"
+description = "FastApi Utils"
+authors = ["Le Comptoir Des Pharmacies <webmaster@lecomptoirdespharmacies.fr>"]
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+
+[tool.poetry.requires-plugins]
+poetry-dynamic-versioning = { version = ">=1.0.0,<2.0.0", extras = ["plugin"] }
+
+[tool.poetry.dependencies]
+python = ">=3.12"
+uvicorn = "0.34.2"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry_dynamic_versioning.backend"