python-injection 0.8.1__tar.gz → 0.8.2__tar.gz

{python_injection-0.8.1 → python_injection-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.1
+Version: 0.8.2
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -27,7 +27,7 @@ If you wish to inject a singleton, use `singleton` decorator.
 from injection import singleton
 
 @singleton
-class Singleton:
+class ServiceA:
     """ class implementation """
 ```
 
@@ -37,7 +37,7 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 from injection import injectable
 
 @injectable
-class Injectable:
+class ServiceB:
     """ class implementation """
 ```
 
@@ -47,7 +47,10 @@ function.
 ```python
 from injection import set_constant
 
-app = set_constant(Application())
+class ServiceC:
+    """ class implementation """
+
+service_c = set_constant(ServiceC())
 ```
 
 ## Inject an instance
@@ -59,7 +62,7 @@ _Don't forget to annotate type of parameter to inject._
 from injection import inject
 
 @inject
-def my_function(instance: Injectable):
+def some_function(service_a: ServiceA):
     """ function implementation """
 ```
 
@@ -76,8 +79,8 @@ from injection import inject
 
 @inject
 @dataclass
-class DataClass:
-    instance: Injectable = ...
+class SomeDataClass:
+    service_a: ServiceA = ...
 ```
 
 ## Get an instance
@@ -87,7 +90,7 @@ _Example with `get_instance` function:_
 ```python
 from injection import get_instance
 
-instance = get_instance(Injectable)
+service_a = get_instance(ServiceA)
 ```
 
 _Example with `get_lazy_instance` function:_
@@ -95,9 +98,9 @@ _Example with `get_lazy_instance` function:_
 ```python
 from injection import get_lazy_instance
 
-lazy_instance = get_lazy_instance(Injectable)
+lazy_service_a = get_lazy_instance(ServiceA)
 # ...
-instance = ~lazy_instance
+service_a = ~lazy_service_a
 ```
 
 ## Inheritance
@@ -111,43 +114,39 @@ classes.
 _Example with one class:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-@singleton(on=A)
-class B(A):
+@injectable(on=AbstractService)
+class ConcreteService(AbstractService):
     ...
 ```
 
 _Example with several classes:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-class B(A):
+class ConcreteService(AbstractService):
     ...
 
-@singleton(on=(A, B))
-class C(B):
+@injectable(on=(AbstractService, ConcreteService))
+class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
-If a class is registered in a package and you want to override it, there is the `override` parameter:
+If a class is registered in a package and you want to override it, there is the `mode` parameter:
 
 ```python
-@singleton
-class A:
+@injectable
+class InaccessibleService:
     ...
 
 # ...
 
-@singleton(on=A, override=True)
-class B(A):
+@injectable(on=InaccessibleService, mode="override")
+class ServiceOverload(InaccessibleService):
     ...
 ```
 
@@ -157,10 +156,10 @@ A recipe is a function that tells the injector how to construct the instance to
 the return type annotation when defining the recipe.
 
 ```python
-from injection import singleton
+from injection import injectable
 
-@singleton
-def my_recipe() -> Singleton:
+@injectable
+def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```
 

{python_injection-0.8.1 → python_injection-0.8.2}/documentation/basic-usage.md

@@ -10,7 +10,7 @@ If you wish to inject a singleton, use `singleton` decorator.
 from injection import singleton
 
 @singleton
-class Singleton:
+class ServiceA:
     """ class implementation """
 ```
 
@@ -20,7 +20,7 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 from injection import injectable
 
 @injectable
-class Injectable:
+class ServiceB:
     """ class implementation """
 ```
 
@@ -30,7 +30,10 @@ function.
 ```python
 from injection import set_constant
 
-app = set_constant(Application())
+class ServiceC:
+    """ class implementation """
+
+service_c = set_constant(ServiceC())
 ```
 
 ## Inject an instance
@@ -42,7 +45,7 @@ _Don't forget to annotate type of parameter to inject._
 from injection import inject
 
 @inject
-def my_function(instance: Injectable):
+def some_function(service_a: ServiceA):
     """ function implementation """
 ```
 
@@ -59,8 +62,8 @@ from injection import inject
 
 @inject
 @dataclass
-class DataClass:
-    instance: Injectable = ...
+class SomeDataClass:
+    service_a: ServiceA = ...
 ```
 
 ## Get an instance
@@ -70,7 +73,7 @@ _Example with `get_instance` function:_
 ```python
 from injection import get_instance
 
-instance = get_instance(Injectable)
+service_a = get_instance(ServiceA)
 ```
 
 _Example with `get_lazy_instance` function:_
@@ -78,9 +81,9 @@ _Example with `get_lazy_instance` function:_
 ```python
 from injection import get_lazy_instance
 
-lazy_instance = get_lazy_instance(Injectable)
+lazy_service_a = get_lazy_instance(ServiceA)
 # ...
-instance = ~lazy_instance
+service_a = ~lazy_service_a
 ```
 
 ## Inheritance
@@ -94,43 +97,39 @@ classes.
 _Example with one class:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-@singleton(on=A)
-class B(A):
+@injectable(on=AbstractService)
+class ConcreteService(AbstractService):
     ...
 ```
 
 _Example with several classes:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-class B(A):
+class ConcreteService(AbstractService):
     ...
 
-@singleton(on=(A, B))
-class C(B):
+@injectable(on=(AbstractService, ConcreteService))
+class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
-If a class is registered in a package and you want to override it, there is the `override` parameter:
+If a class is registered in a package and you want to override it, there is the `mode` parameter:
 
 ```python
-@singleton
-class A:
+@injectable
+class InaccessibleService:
     ...
 
 # ...
 
-@singleton(on=A, override=True)
-class B(A):
+@injectable(on=InaccessibleService, mode="override")
+class ServiceOverload(InaccessibleService):
     ...
 ```
 
@@ -140,9 +139,9 @@ A recipe is a function that tells the injector how to construct the instance to
 the return type annotation when defining the recipe.
 
 ```python
-from injection import singleton
+from injection import injectable
 
-@singleton
-def my_recipe() -> Singleton:
+@injectable
+def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```

python_injection-0.8.1/injection/_pkg.py → python_injection-0.8.2/injection/__init__.py

@@ -1,9 +1,8 @@
-from .core import Injectable, Module, ModulePriority
+from .core import Injectable, Module
 
 __all__ = (
     "Injectable",
     "Module",
-    "ModulePriority",
     "default_module",
     "get_instance",
     "get_lazy_instance",

python_injection-0.8.1/injection/_pkg.pyi → python_injection-0.8.2/injection/__init__.pyi

@@ -1,19 +1,19 @@
 from abc import abstractmethod
 from collections.abc import Callable, Iterable
 from contextlib import ContextDecorator
-from enum import Enum
 from types import UnionType
 from typing import (
     Any,
     ContextManager,
     Final,
+    Literal,
     Protocol,
     TypeVar,
     final,
     runtime_checkable,
 )
 
-from injection.common.invertible import Invertible
+from .common.invertible import Invertible
 
 _T = TypeVar("_T")
 
@@ -54,7 +54,7 @@ class Module:
         cls: type[Injectable] = ...,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -69,7 +69,7 @@ class Module:
         *,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -89,7 +89,7 @@ class Module:
         instance: _T,
         on: type | Iterable[type] | UnionType = ...,
         *,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ) -> _T:
         """
         Function for registering a specific instance to be injected. This is useful for
@@ -97,7 +97,7 @@ class Module:
         that no dependencies are resolved, so the module doesn't need to be locked.
         """
 
-    def get_instance(self, cls: type[_T], none: bool = ...) -> _T | None:
+    def get_instance(self, cls: type[_T], *, none: bool = ...) -> _T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None` but if `none` parameter is `False` an exception
@@ -107,6 +107,7 @@ class Module:
     def get_lazy_instance(
         self,
         cls: type[_T],
+        *,
         cache: bool = ...,
     ) -> Invertible[_T | None]:
         """
@@ -118,7 +119,7 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
-    def use(self, module: Module, priority: ModulePriority = ...):
+    def use(self, module: Module, *, priority: Literal["low", "high"] = ...):
         """
         Function for using another module. Using another module replaces the module's
         dependencies with those of the module used. If the dependency is not found, it
@@ -133,13 +134,14 @@ class Module:
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriority = ...,
+        *,
+        priority: Literal["low", "high"] = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
         """
 
-    def change_priority(self, module: Module, priority: ModulePriority):
+    def change_priority(self, module: Module, priority: Literal["low", "high"]):
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -153,11 +155,6 @@ class Module:
         Function to unlock the module by deleting cached instances of singletons.
         """
 
-@final
-class ModulePriority(Enum):
-    HIGH = ...
-    LOW = ...
-
 @runtime_checkable
 class Injectable(Protocol[_T]):
     def __init__(self, factory: Callable[[], _T] = ..., /): ...

{python_injection-0.8.1 → python_injection-0.8.2}/injection/core/module.py

@@ -11,28 +11,23 @@ from collections.abc import (
     Iterator,
     Mapping,
     MutableMapping,
-    Set,
 )
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
-from enum import Enum, auto
-from functools import (
-    partialmethod,
-    singledispatchmethod,
-    update_wrapper,
-    wraps,
-)
+from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
-from types import UnionType
+from types import MethodType, UnionType
 from typing import (
     Any,
     ClassVar,
     ContextManager,
+    Literal,
     NamedTuple,
     NoReturn,
     Protocol,
     TypeVar,
     cast,
+    get_args,
     runtime_checkable,
 )
 
@@ -50,12 +45,21 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Module", "ModulePriority")
+__all__ = ("Injectable", "Module")
 
 _logger = logging.getLogger(__name__)
 
 _T = TypeVar("_T")
-Types = Iterable[type] | UnionType
+_Types = Iterable[type] | UnionType
+
+
+"""
+Literal types
+"""
+
+
+_Mode = Literal["fallback", "normal", "override"]
+_Priority = Literal["low", "high"]
 
 
 """
@@ -71,7 +75,7 @@ class ContainerEvent(Event, ABC):
 @dataclass(frozen=True, slots=True)
 class ContainerDependenciesUpdated(ContainerEvent):
     classes: Collection[type]
-    override: bool
+    mode: _Mode
 
     def __str__(self) -> str:
         length = len(self.classes)
@@ -125,11 +129,11 @@ class ModuleRemoved(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModulePriorityUpdated(ModuleEvent):
     module_updated: Module
-    priority: ModulePriority
+    priority: _Priority
 
     def __str__(self) -> str:
         return (
-            f"In `{self.on_module}`, the priority `{self.priority.name}` "
+            f"In `{self.on_module}`, the priority `{self.priority}` "
             f"has been applied to `{self.module_updated}`."
         )
 
@@ -158,13 +162,6 @@ class Injectable(Protocol[_T]):
         raise NotImplementedError
 
 
-class FallbackInjectable(Injectable[_T], ABC):
-    __slots__ = ()
-
-    def __bool__(self) -> bool:
-        return False
-
-
 @dataclass(repr=False, frozen=True, slots=True)
 class BaseInjectable(Injectable[_T], ABC):
     factory: Callable[[], _T]
@@ -205,7 +202,7 @@ class SingletonInjectable(BaseInjectable[_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(FallbackInjectable[_T]):
+class ShouldBeInjectable(Injectable[_T]):
     cls: type[_T]
 
     def get_instance(self) -> NoReturn:
@@ -244,49 +241,50 @@ Container
 """
 
 
+class Record(NamedTuple):
+    injectable: Injectable
+    mode: _Mode
+
+
 @dataclass(repr=False, frozen=True, slots=True)
 class Container(Broker):
-    __data: dict[type, Injectable] = field(default_factory=dict, init=False)
+    __data: dict[type, Record] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
     def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
-        for origin in get_origins(cls):
-            with suppress(KeyError):
-                return self.__data[origin]
+        for cls in get_origins(cls):
+            try:
+                injectable, _ = self.__data[cls]
+            except KeyError:
+                continue
+
+            return injectable
 
         raise NoInjectable(cls)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
-        return any(origin in self.__data for origin in get_origins(cls))
+        return any(cls in self.__data for cls in get_origins(cls))
 
     @property
     def is_locked(self) -> bool:
         return any(injectable.is_locked for injectable in self.__injectables)
 
-    @property
-    def __classes(self) -> frozenset[type]:
-        return frozenset(self.__data)
-
     @property
     def __injectables(self) -> frozenset[Injectable]:
-        return frozenset(self.__data.values())
+        return frozenset(injectable for injectable, _ in self.__data.values())
 
     @synchronized()
-    def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
-        classes = frozenset(get_origins(*classes))
-
-        if not injectable:
-            classes -= self.__classes
-            override = True
+    def update(self, classes: Iterable[type], injectable: Injectable, mode: _Mode):
+        records = {
+            cls: Record(injectable, mode)
+            for cls in self.__filter_classes(classes, mode)
+        }
 
-        if classes:
-            event = ContainerDependenciesUpdated(self, classes, override)
+        if records:
+            event = ContainerDependenciesUpdated(self, records.keys(), mode)
 
             with self.notify(event):
-                if not override:
-                    self.__check_if_exists(classes)
-
-                self.__data.update((cls, injectable) for cls in classes)
+                self.__data.update(records)
 
         return self
 
@@ -304,28 +302,32 @@ class Container(Broker):
     def notify(self, event: Event) -> ContextManager | ContextDecorator:
         return self.__channel.dispatch(event)
 
-    def __check_if_exists(self, classes: Set[type]):
-        intersection = classes & self.__classes
+    def __filter_classes(self, classes: Iterable[type], mode: _Mode) -> Iterator[type]:
+        modes = get_args(_Mode)
+        rank = modes.index(mode)
 
-        for cls in intersection:
-            if self.__data[cls]:
-                raise RuntimeError(
-                    f"An injectable already exists for the class `{format_type(cls)}`."
-                )
+        for cls in frozenset(get_origins(*classes)):
+            try:
+                _, current_mode = self.__data[cls]
 
+            except KeyError:
+                pass
 
-"""
-Module
-"""
+            else:
+                if mode == current_mode:
+                    raise RuntimeError(
+                        f"An injectable already exists for the class `{format_type(cls)}`."
+                    )
 
+                elif rank < modes.index(current_mode):
+                    continue
 
-class ModulePriority(Enum):
-    HIGH = auto()
-    LOW = auto()
+            yield cls
 
-    @classmethod
-    def get_default(cls):
-        return cls.LOW
+
+"""
+Module
+"""
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -373,14 +375,14 @@ class Module(EventListener, Broker):
         *,
         cls: type[Injectable] = NewInjectable,
         inject: bool = True,
-        on: type | Types = None,
-        override: bool = False,
+        on: type | _Types = None,
+        mode: _Mode = "normal",
     ):
         def decorator(wp):
             factory = self.inject(wp, return_factory=True) if inject else wp
             injectable = cls(factory)
             classes = find_types(wp, on)
-            self.update(classes, injectable, override)
+            self.update(classes, injectable, mode)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -389,7 +391,11 @@ class Module(EventListener, Broker):
 
     def should_be_injectable(self, wrapped: type = None, /):
         def decorator(wp):
-            self[wp] = ShouldBeInjectable(wp)
+            self.update(
+                (wp,),
+                ShouldBeInjectable(wp),
+                mode="fallback",
+            )
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -397,16 +403,16 @@ class Module(EventListener, Broker):
     def set_constant(
         self,
         instance: _T,
-        on: type | Types = None,
+        on: type | _Types = None,
         *,
-        override: bool = False,
+        mode: _Mode = "normal",
     ) -> _T:
         cls = type(instance)
         self.injectable(
             lambda: instance,
             inject=False,
             on=(cls, on),
-            override=override,
+            mode=mode,
         )
         return instance
 
@@ -433,7 +439,7 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def get_instance(self, cls: type[_T], none: bool = True) -> _T | None:
+    def get_instance(self, cls: type[_T], *, none: bool = True) -> _T | None:
         try:
             injectable = self[cls]
         except KeyError as exc:
@@ -448,6 +454,7 @@ class Module(EventListener, Broker):
     def get_lazy_instance(
         self,
         cls: type[_T],
+        *,
         cache: bool = False,
     ) -> Invertible[_T | None]:
         if cache:
@@ -461,16 +468,12 @@ class Module(EventListener, Broker):
         self,
         classes: Iterable[type],
         injectable: Injectable,
-        override: bool = False,
+        mode: _Mode = "normal",
     ):
-        self.__container.update(classes, injectable, override)
+        self.__container.update(classes, injectable, mode)
         return self
 
-    def use(
-        self,
-        module: Module,
-        priority: ModulePriority = ModulePriority.get_default(),
-    ):
+    def use(self, module: Module, *, priority: _Priority = "low"):
         if module is self:
             raise ModuleError("Module can't be used by itself.")
 
@@ -500,13 +503,14 @@ class Module(EventListener, Broker):
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriority = ModulePriority.get_default(),
+        *,
+        priority: _Priority = "low",
     ) -> ContextManager | ContextDecorator:
-        self.use(module, priority)
+        self.use(module, priority=priority)
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: ModulePriority):
+    def change_priority(self, module: Module, priority: _Priority):
         event = ModulePriorityUpdated(self, module, priority)
 
         with self.notify(event):
@@ -545,8 +549,8 @@ class Module(EventListener, Broker):
         if self.is_locked:
             raise ModuleLockError(f"`{self}` is locked.")
 
-    def __move_module(self, module: Module, priority: ModulePriority):
-        last = priority == ModulePriority.LOW
+    def __move_module(self, module: Module, priority: _Priority):
+        last = priority != "high"
 
         try:
             self.__modules.move_to_end(module, last=last)
@@ -635,48 +639,45 @@ class InjectedFunction(EventListener):
     __slots__ = (
         "__dict__",
         "__signature__",
+        "__wrapped__",
         "__dependencies",
         "__owner",
         "__setup_queue",
-        "__wrapper",
     )
 
     def __init__(self, wrapped: Callable[..., Any], /):
-        update_wrapper(self, wrapped)
-
-        @wraps(wrapped)
-        def wrapper(*args, **kwargs):
-            self.__consume_setup_queue()
-            args, kwargs = self.bind(args, kwargs)
-            return wrapped(*args, **kwargs)
-
-        self.__wrapper = wrapper
+        try:
+            variables = vars(wrapped)
+        except TypeError:
+            pass
+        else:
+            self.__update_vars(variables)
+            del variables
+
+        update_wrapper(self, wrapped, updated=())
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
-        self.on_setup(
-            lambda: self.__set_signature(
-                inspect.signature(
-                    wrapped,
-                    eval_str=True,
-                )
-            )
-        )
+        self.on_setup(self.__set_signature)
 
     def __repr__(self) -> str:
-        return repr(self.__wrapper)
+        return repr(self.wrapped)
 
     def __str__(self) -> str:
-        return str(self.__wrapper)
+        return str(self.wrapped)
 
     def __call__(self, /, *args, **kwargs) -> Any:
-        return self.__wrapper(*args, **kwargs)
+        for function in self.__setup_queue:
+            function()
+
+        args, kwargs = self.bind(args, kwargs)
+        return self.wrapped(*args, **kwargs)
 
     def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
             return self
 
-        return self.__wrapper.__get__(instance, owner)
+        return MethodType(self, instance)
 
     def __set_name__(self, owner: type, name: str):
         self.set_owner(owner)
@@ -685,6 +686,10 @@ class InjectedFunction(EventListener):
     def signature(self) -> Signature:
         return self.__signature__
 
+    @property
+    def wrapped(self) -> Callable[..., Any]:
+        return self.__wrapped__
+
     def bind(
         self,
         args: Iterable[Any] = (),
@@ -736,12 +741,18 @@ class InjectedFunction(EventListener):
         yield
         self.update(event.on_module)
 
-    def __consume_setup_queue(self):
-        for function in self.__setup_queue:
-            function()
-
+    def __set_signature(self):
+        self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self
 
-    def __set_signature(self, signature: Signature):
-        self.__signature__ = signature
-        return self
+    def __update_vars(self, variables: Mapping[str, Any], /):
+        def is_dunder(var: str) -> bool:
+            return var.startswith("__") and var.endswith("__")
+
+        restricted_vars = frozenset(var for var in dir(self) if not is_dunder(var))
+        variables = (
+            (var, value)
+            for var, value in variables.items()
+            if var not in restricted_vars
+        )
+        vars(self).update(variables)

{python_injection-0.8.1 → python_injection-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.1"
+version = "0.8.2"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -13,7 +13,9 @@ repository = "https://github.com/100nm/python-injection"
 python = ">=3.10, <4"
 
 [tool.poetry.group.dev.dependencies]
+argon2-cffi = "*"
 blacksheep = "*"
+faker = "*"
 pydantic = "*"
 pytest = "*"
 pytest-asyncio = "*"
@@ -31,7 +33,7 @@ exclude_lines = [
 python_files = "test_*.py"
 addopts = "-p no:warnings --tb=short"
 asyncio_mode = "auto"
-testpaths = "tests/"
+testpaths = "**/tests/"
 
 [tool.ruff]
 line-length = 88

python_injection-0.8.1/injection/__init__.py

@@ -1 +0,0 @@
-from ._pkg import *