modern-di-celery 2.0.0__tar.gz

modern_di_celery-2.0.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: modern-di-celery
+Version: 2.0.0
+Summary: modern-di integration for Celery
+Keywords: dependency-injection,di,ioc-container,modern-di,celery,python
+Author: Artur Shiriev
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: celery>=5,<6
+Requires-Dist: modern-di>=2.25,<3
+Requires-Python: >=3.10, <4
+Project-URL: Homepage, https://modern-di.modern-python.org
+Project-URL: Documentation, https://modern-di.modern-python.org
+Project-URL: Repository, https://github.com/modern-python/modern-di-celery
+Project-URL: Issues, https://github.com/modern-python/modern-di-celery/issues
+Project-URL: Changelog, https://github.com/modern-python/modern-di-celery/releases
+Description-Content-Type: text/markdown
+
+# modern-di-celery
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [Celery](https://docs.celeryq.dev) 5.x.
+
+## Quickstart
+
+```python
+import typing
+
+from celery import Celery
+from modern_di import Container, Group, Scope, providers
+from modern_di_celery import DITask, FromDI, setup_di
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.greeting = "hello"
+
+
+class Dependencies(Group):
+    settings = providers.Factory(scope=Scope.APP, creator=Settings)
+
+
+app = Celery("myapp", broker="redis://localhost", task_cls=DITask)
+setup_di(app, Container(groups=[Dependencies], validate=True))
+
+
+@app.task
+def greet(name: str, settings: typing.Annotated[Settings, FromDI(Dependencies.settings)]) -> str:
+    return f"{settings.greeting}, {name}"
+```
+
+With `task_cls=DITask` every task is injected; alternatively decorate individual
+tasks with `@inject`. See the [documentation](https://modern-di.modern-python.org).

modern_di_celery-2.0.0/README.md

@@ -0,0 +1,34 @@
+# modern-di-celery
+
+[Modern-DI](https://github.com/modern-python/modern-di) integration for [Celery](https://docs.celeryq.dev) 5.x.
+
+## Quickstart
+
+```python
+import typing
+
+from celery import Celery
+from modern_di import Container, Group, Scope, providers
+from modern_di_celery import DITask, FromDI, setup_di
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.greeting = "hello"
+
+
+class Dependencies(Group):
+    settings = providers.Factory(scope=Scope.APP, creator=Settings)
+
+
+app = Celery("myapp", broker="redis://localhost", task_cls=DITask)
+setup_di(app, Container(groups=[Dependencies], validate=True))
+
+
+@app.task
+def greet(name: str, settings: typing.Annotated[Settings, FromDI(Dependencies.settings)]) -> str:
+    return f"{settings.greeting}, {name}"
+```
+
+With `task_cls=DITask` every task is injected; alternatively decorate individual
+tasks with `@inject`. See the [documentation](https://modern-di.modern-python.org).

modern_di_celery-2.0.0/modern_di_celery/__init__.py

@@ -0,0 +1,10 @@
+from modern_di_celery.main import DITask, FromDI, fetch_di_container, inject, setup_di
+
+
+__all__ = [
+    "DITask",
+    "FromDI",
+    "fetch_di_container",
+    "inject",
+    "setup_di",
+]

modern_di_celery-2.0.0/modern_di_celery/main.py

@@ -0,0 +1,99 @@
+import dataclasses
+import inspect
+import typing
+
+from celery import Celery, Task, current_app, signals
+from celery.utils.functional import head_from_fun
+from modern_di import Container, Scope, providers
+
+
+# The root container lives on ``app.conf`` under this named key; read back with
+# ``current_app.conf`` inside ``inject``. A named constant keeps writer and
+# reader in provable agreement.
+_ROOT_CONTAINER_KEY = "modern_di_container"
+
+
+def setup_di(app: Celery, container: Container) -> Container:
+    app.conf[_ROOT_CONTAINER_KEY] = container
+
+    def _open_container(**_: typing.Any) -> None:  # noqa: ANN401
+        container.open()
+
+    def _close_container(**_: typing.Any) -> None:  # noqa: ANN401
+        container.close_sync()
+
+    # weak=False is required: Celery signals default to weak refs, which would
+    # garbage-collect these handlers before a worker process ever fires them.
+    signals.worker_process_init.connect(_open_container, weak=False)
+    signals.worker_process_shutdown.connect(_close_container, weak=False)
+    return container
+
+
+def fetch_di_container(app: Celery) -> Container:
+    return typing.cast(Container, app.conf[_ROOT_CONTAINER_KEY])
+
+
+T = typing.TypeVar("T")
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class _FromDI(typing.Generic[T_co]):
+    dependency: providers.AbstractProvider[T_co] | type[T_co]
+
+
+def FromDI(dependency: providers.AbstractProvider[T] | type[T]) -> T:  # noqa: N802
+    return typing.cast(T, _FromDI(dependency))
+
+
+def _parse_inject_params(func: typing.Callable[..., typing.Any]) -> dict[str, _FromDI[typing.Any]]:
+    hints = typing.get_type_hints(func, include_extras=True)
+    di_params: dict[str, _FromDI[typing.Any]] = {}
+    for name, hint in hints.items():
+        if name == "return":
+            continue
+        if typing.get_origin(hint) is typing.Annotated:
+            for meta in typing.get_args(hint)[1:]:
+                if isinstance(meta, _FromDI):
+                    di_params[name] = meta
+                    break
+    return di_params
+
+
+def inject(func: typing.Callable[..., T]) -> typing.Callable[..., T]:
+    di_params = _parse_inject_params(func)
+    if not di_params:
+        func.__modern_di_injected__ = True  # ty: ignore[unresolved-attribute]
+        return func
+
+    signature = inspect.signature(func)
+    visible_params = [p for name, p in signature.parameters.items() if name not in di_params]
+    visible_signature = signature.replace(parameters=visible_params)
+
+    def wrapper(*args: typing.Any, **kwargs: typing.Any) -> T:  # noqa: ANN401
+        container = fetch_di_container(typing.cast(Celery, current_app)).build_child_container(scope=Scope.REQUEST)
+        try:
+            resolved = {name: container.resolve_dependency(marker.dependency) for name, marker in di_params.items()}
+            bound = visible_signature.bind(*args, **kwargs)
+            bound.apply_defaults()
+            return func(**bound.arguments, **resolved)
+        finally:
+            container.close_sync()
+
+    # NOT functools.wraps — keep Celery's arg-binding reading the stripped signature.
+    wrapper.__name__ = func.__name__  # ty: ignore[unresolved-attribute]
+    wrapper.__qualname__ = func.__qualname__  # ty: ignore[unresolved-attribute]
+    wrapper.__doc__ = func.__doc__
+    wrapper.__module__ = func.__module__
+    wrapper.__signature__ = visible_signature  # ty: ignore[unresolved-attribute]
+    wrapper.__modern_di_injected__ = True  # ty: ignore[unresolved-attribute]
+    return wrapper
+
+
+class DITask(Task):
+    def __init__(self) -> None:
+        super().__init__()
+        if not getattr(self.run, "__modern_di_injected__", False):
+            injected = inject(self.run)
+            self.run = injected  # ty: ignore[invalid-assignment]
+            self.__header__ = head_from_fun(injected)

modern_di_celery-2.0.0/pyproject.toml

@@ -0,0 +1,81 @@
+[project]
+name = "modern-di-celery"
+description = "modern-di integration for Celery"
+authors = [{ name = "Artur Shiriev", email = "me@shiriev.ru" }]
+requires-python = ">=3.10,<4"
+license = "MIT"
+readme = "README.md"
+keywords = ["dependency-injection", "di", "ioc-container", "modern-di", "celery", "python"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = ["celery>=5,<6", "modern-di>=2.25,<3"]
+version = "2.0.0"
+
+[project.urls]
+Homepage = "https://modern-di.modern-python.org"
+Documentation = "https://modern-di.modern-python.org"
+Repository = "https://github.com/modern-python/modern-di-celery"
+Issues = "https://github.com/modern-python/modern-di-celery/issues"
+Changelog = "https://github.com/modern-python/modern-di-celery/releases"
+
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+]
+lint = [
+    "ty",
+    "ruff",
+    "eof-fixer",
+    "typing-extensions",
+]
+
+[build-system]
+requires = ["uv_build>=0.11,<1.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "modern_di_celery"
+module-root = ""
+
+[tool.ruff]
+fix = false
+unsafe-fixes = true
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "D1", # allow missing docstrings
+    "S101", # allow asserts
+    "TCH", # ignore flake8-type-checking
+    "FBT", # allow boolean args
+    "D203", # "one-blank-line-before-class" conflicting with D211
+    "D213", # "multi-line-summary-second-line" conflicting with D212
+    "COM812", # flake8-commas "Trailing comma missing"
+    "ISC001", # flake8-implicit-str-concat
+    "G004", # allow f-strings in logging
+]
+isort.lines-after-imports = 2
+isort.no-lines-before = ["standard-library", "local-folder"]
+
+[tool.pytest.ini_options]
+addopts = ""
+
+[tool.coverage.report]
+exclude_also = [
+    "if typing.TYPE_CHECKING:",
+]