ashka-lifecycle 0.2.2__tar.gz → 0.3.0__tar.gz

{ashka_lifecycle-0.2.2 → ashka_lifecycle-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ashka-lifecycle
-Version: 0.2.2
+Version: 0.3.0
 Summary: dishka lifecycle support
 Author: handsome-Druid
 Author-email: handsome-Druid <102826168@qq.com>

{ashka_lifecycle-0.2.2 → ashka_lifecycle-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ashka-lifecycle"
-version = "0.2.2"
+version = "0.3.0"
 description = "dishka lifecycle support"
 readme = "README.md"
 requires-python = ">=3.10,<3.15"

{ashka_lifecycle-0.2.2 → ashka_lifecycle-0.3.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "ashka-lifecycle"
-version = "0.2.2"
+version = "0.3.0"
 description = "dishka lifecycle support"
 readme = "README.md"
 authors = [

{ashka_lifecycle-0.2.2 → ashka_lifecycle-0.3.0}/src/ashka_lifecycle/__init__.py

@@ -1,5 +1,8 @@
 import ashka_lifecycle.async_container
 import ashka_lifecycle.container
+import ashka_lifecycle.provider
+import ashka_lifecycle.provider.make_factory
+import ashka_lifecycle.provider.provider
 from ashka_lifecycle.entities.scope import AshkaScope
 from ashka_lifecycle.provider import (
     provide,  # pyright: ignore[reportUnknownVariableType]
@@ -20,3 +23,5 @@ def activate_lifecycle() -> None:
     """
     ashka_lifecycle.container.activate()
     ashka_lifecycle.async_container.activate()
+    ashka_lifecycle.provider.provider.activate()
+    ashka_lifecycle.provider.make_factory.activate()

ashka_lifecycle-0.3.0/src/ashka_lifecycle/entities/scope.py

@@ -0,0 +1,7 @@
+from dishka import BaseScope, new_scope
+
+__all__ = ["AshkaScope"]
+
+
+class AshkaScope(BaseScope):
+    BOOTSTRAP = new_scope("BOOTSTRAP")

ashka_lifecycle-0.3.0/src/ashka_lifecycle/provider/make_factory.bak

@@ -0,0 +1,124 @@
+# type: ignore
+from collections.abc import Callable
+from inspect import isbuiltin, isclass, isfunction
+from logging import getLogger
+from typing import Any, NewType, get_origin, get_type_hints, overload
+
+from ashka_lifecycle.entities.bootstrap import (
+    bootstrap_types,
+)
+from ashka_lifecycle.entities.scope import AshkaScope
+
+from dishka import AnyOf, BaseScope, Scope
+from dishka import provide as _provide
+from dishka.dependency_source.composite import CompositeDependencySource
+from dishka.provider.exceptions import MissingReturnHintError
+from dishka.provider.make_factory import (
+    ProvideSource,
+    _clean_result_hint,
+    _guess_factory_type,
+)
+
+__all__: list[str] = ["provide"]
+
+_logger = getLogger(__name__)
+
+
+def activate(): ...
+
+
+
+@overload
+def provide(
+    *, scope: BaseScope | AshkaScope | None = None, **kwargs: Any
+) -> Callable[[Callable[..., Any]], CompositeDependencySource]: ...
+
+
+@overload
+def provide(
+    source: ProvideSource,
+    *,
+    scope: BaseScope | AshkaScope | None = None,
+    **kwargs: Any,
+) -> CompositeDependencySource: ...
+
+
+def provide(
+    source: ProvideSource | None = None,
+    *,
+    scope: BaseScope | AshkaScope | None = None,
+    **kwargs: Any,
+) -> (
+    CompositeDependencySource
+    | Callable[
+        [Callable[..., Any]],
+        CompositeDependencySource,
+    ]
+):
+    return (
+        _provide(source, scope=scope, **kwargs)
+        if scope is not AshkaScope.BOOTSTRAP
+        else (
+            scoped
+            if (
+                scoped := (
+                    lambda source: (
+                        _provide(
+                            source,
+                            scope=Scope.APP,
+                            provides=AnyOf[
+                                NewType_, (_kwargs := kwargs.copy()).pop(provides)
+                            ],
+                            **_kwargs,
+                        )
+                        if bootstrap_types.add(
+                            NewType_ := NewType(
+                                "ashka_lifecycle.provider.make_factory.provide",
+                                AshkaScope,
+                            )
+                        )
+                        is None
+                        and _logger.debug(
+                            f"Adding {getattr(source, '__name__', source)!r} to bootstrap list..."
+                        )
+                        is None
+                        and (provides := "provides") in kwargs
+                        else _provide(
+                            source,
+                            scope=Scope.APP,
+                            provides=AnyOf[
+                                NewType_,
+                                source
+                                if isclass(source) or isclass(get_origin(source))
+                                else _clean_result_hint(
+                                    _guess_factory_type(
+                                        func := getattr(source, "__func__", None)
+                                        or (
+                                            source
+                                            if isfunction(source) or isbuiltin(source)
+                                            else getattr(
+                                                source.__call__,
+                                                "__func__",
+                                                source.__call__,
+                                            )
+                                        )
+                                    ),
+                                    type_hints[return_]
+                                    if (return_ := "return")
+                                    in (type_hints := get_type_hints(func))
+                                    or bootstrap_types.remove(NewType_) is not None
+                                    else (_ for _ in ()).throw(
+                                        MissingReturnHintError(source)
+                                    ),
+                                ),
+                            ],
+                            **kwargs,
+                        )
+                    )
+                )
+            )
+            is not None
+            and source is None
+            else scoped(source)
+        )
+    )

ashka_lifecycle-0.3.0/src/ashka_lifecycle/provider/make_factory.py

@@ -0,0 +1,131 @@
+from collections.abc import Callable
+from inspect import isbuiltin, isclass, isfunction
+from logging import getLogger
+from typing import Any, NewType, get_origin, get_type_hints, overload
+
+from ashka_lifecycle.entities.bootstrap import (
+    bootstrap_types,
+)
+from ashka_lifecycle.entities.scope import AshkaScope
+
+import dishka
+from dishka import AnyOf, BaseScope, Scope
+from dishka import provide as _provide  # pyright: ignore[reportUnknownVariableType]
+from dishka.dependency_source.composite import CompositeDependencySource
+from dishka.provider.exceptions import MissingReturnHintError
+from dishka.provider.make_factory import (
+    ProvideSource,
+    _clean_result_hint,  # pyright: ignore[reportPrivateUsage]
+    _guess_factory_type,  # pyright: ignore[reportPrivateUsage]
+)
+
+__all__: list[str] = ["provide"]
+
+_logger = getLogger(__name__)
+
+
+def activate(): ...
+
+
+@overload
+def provide(
+    *, scope: BaseScope | AshkaScope | None = None, **kwargs: Any
+) -> Callable[[Callable[..., Any]], CompositeDependencySource]: ...
+
+
+@overload
+def provide(
+    source: ProvideSource,  # pyright: ignore[reportUnknownParameterType]
+    *,
+    scope: BaseScope | AshkaScope | None = None,
+    **kwargs: Any,
+) -> CompositeDependencySource: ...
+
+
+def provide(
+    source: ProvideSource | None = None,  # pyright: ignore[reportUnknownParameterType]
+    *,
+    scope: BaseScope | AshkaScope | None = None,
+    **kwargs: Any,
+) -> (
+    CompositeDependencySource
+    | Callable[
+        [Callable[..., Any]],
+        CompositeDependencySource,
+    ]
+):
+
+    is_bootstrap = scope is AshkaScope.BOOTSTRAP
+
+    def scoped(source: Any) -> CompositeDependencySource:
+        _logger.debug(
+            f"Adding {getattr(source, '__name__', source)!r} to bootstrap list..."
+        )
+
+        bootstrap_type = NewType(
+            "bootstrap_type",
+            AshkaScope,
+        )
+        if is_bootstrap:
+            bootstrap_types.add(bootstrap_type)
+
+        provides = "provides"
+
+        if provides in kwargs:
+            _kwargs = kwargs.copy()
+
+            _provides = _kwargs.pop(provides)
+
+            return _provide(
+                source,
+                scope=Scope.APP if is_bootstrap else scope,
+                provides=AnyOf[bootstrap_type, _provides],
+                **_kwargs,
+            )
+
+        if isclass(source) or isclass(get_origin(source)):
+            return _provide(
+                source,
+                scope=Scope.APP if is_bootstrap else scope,
+                provides=AnyOf[bootstrap_type, source],
+                **kwargs,
+            )
+
+        return_ = "return"
+
+        if isfunction(source) or isbuiltin(source):
+            func = source
+
+        elif hasattr(source, "__func__"):
+            func = source.__func__
+
+        else:
+            func = getattr(source.__call__, "__func__", source.__call__)
+
+        factory_type = _guess_factory_type(func)
+
+        type_hints = get_type_hints(func)
+
+        if return_ not in type_hints:
+            raise MissingReturnHintError(source)
+
+        possible_dependency = type_hints[return_]
+
+        type_hint = _clean_result_hint(factory_type, possible_dependency)
+
+        return _provide(
+            source,
+            scope=Scope.APP if is_bootstrap else scope,
+            provides=AnyOf[bootstrap_type, type_hint],
+            **kwargs,
+        )
+
+    if source is None:
+        return scoped
+
+    return scoped(source)
+
+
+dishka.provide = dishka.provider.provide = dishka.provider.make_factory.provide = (
+    provide
+)

ashka_lifecycle-0.3.0/src/ashka_lifecycle/provider/provider.py

@@ -0,0 +1,42 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Any
+
+from ashka_lifecycle.entities.bootstrap import bootstrap_types
+from ashka_lifecycle.entities.scope import AshkaScope
+
+from dishka import Provider, Scope
+from dishka.dependency_source import CompositeDependencySource
+
+
+def activate(): ...
+
+
+def __init__(__init__: Callable[..., None]) -> Callable[..., None]:
+    @wraps(__init__)
+    def inner(self: Provider, *args: Any, **kwargs: Any):
+        is_bootstrap = False
+        args_ = kwargs_ = None
+        if args and args[0] is AshkaScope.BOOTSTRAP:
+            args_ = (Scope.APP,) + args[1:]
+            is_bootstrap = True
+        elif kwargs.get("scope", None) is AshkaScope.BOOTSTRAP:
+            (kwargs_ := kwargs.copy())["scope"] = Scope.APP
+            is_bootstrap = True
+        elif self.scope is AshkaScope.BOOTSTRAP:
+            self.scope = Scope.APP
+            is_bootstrap = True
+
+        if is_bootstrap:
+            for v in type(self).__dict__.values():
+                if (
+                    isinstance(v, CompositeDependencySource)
+                    and not v.dependency_sources[1].scope  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+                ):
+                    bootstrap_types.add(v.dependency_sources[1].provides.type_hint)  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType, reportAttributeAccessIssue]
+        return __init__(self, *(args_ or args), **(kwargs_ or kwargs))
+
+    return inner
+
+
+Provider.__init__ = __init__(Provider.__init__)

ashka_lifecycle-0.2.2/src/ashka_lifecycle/entities/scope.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-__all__ = ["AshkaScope"]
-
-
-class AshkaScope(Enum):
-    BOOTSTRAP = "BOOTSTRAP"

ashka_lifecycle-0.2.2/src/ashka_lifecycle/provider/make_factory.py

@@ -1,110 +0,0 @@
-from collections.abc import Callable
-from inspect import isbuiltin, isclass, isfunction
-from logging import getLogger
-from typing import Any, NewType, get_origin, get_type_hints, overload
-
-from ashka_lifecycle.entities.bootstrap import (
-    bootstrap_types,
-)
-from ashka_lifecycle.entities.scope import AshkaScope
-
-from dishka import BaseScope, Scope
-from dishka import provide as _provide  # pyright: ignore[reportUnknownVariableType]
-from dishka.dependency_source.composite import CompositeDependencySource
-from dishka.entities.provides_marker import ProvideMultiple
-from dishka.provider.exceptions import MissingReturnHintError
-from dishka.provider.make_factory import (
-    ProvideSource,
-    _clean_result_hint,  # pyright: ignore[reportPrivateUsage]
-    _guess_factory_type,  # pyright: ignore[reportPrivateUsage]
-)
-
-__all__: list[str] = ["provide"]
-
-_logger = getLogger(__name__)
-
-
-def activate(): ...
-
-
-@overload
-def provide(
-    *, scope: BaseScope | AshkaScope | None = None, **kwargs: Any
-) -> Callable[[Callable[..., Any]], CompositeDependencySource]: ...
-
-
-@overload
-def provide(
-    source: ProvideSource,  # pyright: ignore[reportUnknownParameterType]
-    *,
-    scope: BaseScope | AshkaScope | None = None,
-    **kwargs: Any,
-) -> CompositeDependencySource: ...
-
-
-def provide(
-    source: ProvideSource | None = None,  # pyright: ignore[reportUnknownParameterType]
-    *,
-    scope: BaseScope | AshkaScope | None = None,
-    **kwargs: Any,
-) -> (
-    CompositeDependencySource
-    | Callable[
-        [Callable[..., Any]],
-        CompositeDependencySource,
-    ]
-):
-    if scope is not AshkaScope.BOOTSTRAP:
-        return _provide(source, scope=scope, **kwargs)
-
-    def scoped(source: ProvideSource) -> CompositeDependencySource:  # pyright: ignore[reportUnknownParameterType]
-        _logger.debug(
-            f"Adding {getattr(source, '__name__', source)!r} to bootstrap list..."  # pyright: ignore[reportUnknownArgumentType]
-        )
-        bootstrap_types.add(
-            new_type := NewType(
-                "ashka_lifecycle.provider.make_factory.provide", AshkaScope
-            )
-        )
-        try:
-            return (
-                _provide(
-                    source,
-                    scope=Scope.APP,
-                    provides=ProvideMultiple[
-                        new_type, (_kwargs := kwargs.copy()).pop(provides)  # pyright: ignore[reportInvalidTypeArguments]
-                    ],
-                    **_kwargs,
-                )
-                if (provides := "provides") in kwargs
-                else _provide(
-                    source,
-                    scope=Scope.APP,
-                    provides=ProvideMultiple[
-                        new_type,
-                        source  # pyright: ignore[reportInvalidTypeArguments]
-                        if isclass(source) or isclass(get_origin(source))  # pyright: ignore[reportUnknownArgumentType]
-                        else _clean_result_hint(
-                            _guess_factory_type(
-                                func := getattr(source, "__func__", None)  # pyright: ignore[reportUnknownVariableType, reportUnknownArgumentType]
-                                or (
-                                    source
-                                    if isfunction(source) or isbuiltin(source)  # pyright: ignore[reportUnknownArgumentType]
-                                    else getattr(
-                                        source.__call__,  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType, reportUnknownArgumentType]
-                                        "__func__",
-                                        source.__call__,  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType, reportUnknownArgumentType]
-                                    )
-                                )
-                            ),
-                            get_type_hints(func)["return"],  # pyright: ignore[reportUnknownArgumentType]
-                        ),
-                    ],
-                    **kwargs,
-                )
-            )
-        except KeyError as e:
-            bootstrap_types.remove(new_type)
-            raise MissingReturnHintError(source) from e
-
-    return scoped if source is None else scoped(source)  # pyright: ignore[reportUnknownVariableType]