python-injection 0.7.3__tar.gz → 0.7.5__tar.gz

{python_injection-0.7.3 → python_injection-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.7.3
+Version: 0.7.5
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT

{python_injection-0.7.3 → python_injection-0.7.5}/injection/_pkg.py

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

{python_injection-0.7.3 → python_injection-0.7.5}/injection/_pkg.pyi

@@ -39,19 +39,11 @@ class Module:
 
     def __init__(self, name: str = ...): ...
     def __contains__(self, cls: type | UnionType, /) -> bool: ...
-    def inject(
-        self,
-        wrapped: Callable[..., Any] = ...,
-        /,
-        *,
-        force: bool = ...,
-    ):
+    def inject(self, wrapped: Callable[..., Any] = ..., /):
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
         will be those of the `__init__` method.
-
-        With `force=True`, parameters passed to replace dependencies will be ignored.
         """
 
     def injectable(
@@ -85,14 +77,7 @@ class Module:
         always be the same.
         """
 
-    def should_be_injectable(
-        self,
-        wrapped: Callable[..., Any] = ...,
-        /,
-        *,
-        on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
-    ):
+    def should_be_injectable(self, wrapped: type = ..., /):
         """
         Decorator applicable to a class. It is used to specify whether an injectable
         should be registered. Raise an exception at injection time if the class isn't
@@ -128,7 +113,7 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
-    def use(self, module: Module, priority: ModulePriorities = ...):
+    def use(self, module: Module, priority: ModulePriority = ...):
         """
         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
@@ -143,13 +128,13 @@ class Module:
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriorities = ...,
+        priority: ModulePriority = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
         """
 
-    def change_priority(self, module: Module, priority: ModulePriorities):
+    def change_priority(self, module: Module, priority: ModulePriority):
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -164,7 +149,7 @@ class Module:
         """
 
 @final
-class ModulePriorities(Enum):
+class ModulePriority(Enum):
     HIGH = ...
     LOW = ...
 

{python_injection-0.7.3 → python_injection-0.7.5}/injection/common/event.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass, field
 from typing import ContextManager
 from weakref import WeakSet
 
+from injection.common.tools.threading import frozen_collection
+
 __all__ = ("Event", "EventChannel", "EventListener")
 
 
@@ -26,7 +28,7 @@ class EventChannel:
     @contextmanager
     def dispatch(self, event: Event) -> ContextManager | ContextDecorator:
         with ExitStack() as stack:
-            for listener in tuple(self.__listeners):
+            for listener in frozen_collection(self.__listeners):
                 context_manager = listener.on_event(event)
 
                 if context_manager is None:

{python_injection-0.7.3 → python_injection-0.7.5}/injection/common/lazy.py

@@ -1,12 +1,11 @@
 from collections.abc import Callable, Iterator, Mapping
-from threading import RLock
+from contextlib import suppress
 from types import MappingProxyType
 from typing import Any, Generic, TypeVar
 
-__all__ = ("Lazy", "LazyMapping")
+from injection.common.tools.threading import thread_lock
 
-_sentinel = object()
-_thread_lock = RLock()
+__all__ = ("Lazy", "LazyMapping")
 
 _T = TypeVar("_T")
 _K = TypeVar("_K")
@@ -14,39 +13,40 @@ _V = TypeVar("_V")
 
 
 class Lazy(Generic[_T]):
-    __slots__ = ("__factory", "__value")
+    __slots__ = ("is_set", "__generator")
 
     def __init__(self, factory: Callable[[], _T]):
-        self.__factory = factory
-        self.__value = _sentinel
+        def generator() -> Iterator[_T]:
+            nonlocal factory
+
+            with thread_lock:
+                value = factory()
+                self.is_set = True
+                del factory
+
+            while True:
+                yield value
+
+        self.is_set = False
+        self.__generator = generator()
 
     def __invert__(self) -> _T:
-        if not self.is_set:
-            with _thread_lock:
-                self.__value = self.__factory()
-                self.__factory = _sentinel
+        return next(self.__generator)
 
-        return self.__value
+    def __call__(self) -> _T:
+        return ~self
 
     def __setattr__(self, name: str, value: Any, /):
-        if self.is_set:
-            raise TypeError(f"`{self}` is frozen.")
+        with suppress(AttributeError):
+            if self.is_set:
+                raise TypeError(f"`{self}` is frozen.")
 
         return super().__setattr__(name, value)
 
-    @property
-    def is_set(self) -> bool:
-        try:
-            return self.__factory is _sentinel
-        except AttributeError:
-            return False
-
 
 class LazyMapping(Mapping[_K, _V]):
     __slots__ = ("__lazy",)
 
-    __lazy: Lazy[MappingProxyType[_K, _V]]
-
     def __init__(self, iterator: Iterator[tuple[_K, _V]]):
         self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
 
@@ -58,3 +58,7 @@ class LazyMapping(Mapping[_K, _V]):
 
     def __len__(self) -> int:
         return len(~self.__lazy)
+
+    @property
+    def is_set(self) -> bool:
+        return self.__lazy.is_set

python_injection-0.7.5/injection/common/tools/threading.py

@@ -0,0 +1,28 @@
+from collections.abc import Callable, Collection, Iterator
+from functools import wraps
+from threading import RLock
+from typing import Any, TypeVar
+
+__all__ = ("frozen_collection", "synchronized", "thread_lock")
+
+_T = TypeVar("_T")
+thread_lock = RLock()
+
+
+def synchronized(function: Callable[..., Any] = None, /):
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            with thread_lock:
+                return fn(*args, **kwargs)
+
+        return wrapper
+
+    return decorator(function) if function else decorator
+
+
+def frozen_collection(collection: Collection[_T]) -> Iterator[_T]:
+    with thread_lock:
+        t = tuple(collection)
+
+    yield from t

{python_injection-0.7.3 → python_injection-0.7.5}/injection/core/module.py

@@ -11,16 +11,22 @@ 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, wraps
+from functools import (
+    partialmethod,
+    singledispatchmethod,
+    update_wrapper,
+    wraps,
+)
 from inspect import Signature, isclass
-from threading import RLock
-from types import MappingProxyType, UnionType
+from types import UnionType
 from typing import (
     Any,
+    ClassVar,
     ContextManager,
     NamedTuple,
     NoReturn,
@@ -32,7 +38,12 @@ from typing import (
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools import find_types, format_type, get_origins
+from injection.common.tools.threading import (
+    frozen_collection,
+    synchronized,
+    thread_lock,
+)
+from injection.common.tools.type import find_types, format_type, get_origins
 from injection.exceptions import (
     InjectionError,
     ModuleError,
@@ -41,10 +52,9 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Module", "ModulePriorities")
+__all__ = ("Injectable", "Module", "ModulePriority")
 
 _logger = logging.getLogger(__name__)
-_thread_lock = RLock()
 
 _T = TypeVar("_T")
 Types = Iterable[type] | UnionType
@@ -117,7 +127,7 @@ class ModuleRemoved(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModulePriorityUpdated(ModuleEvent):
     module_updated: Module
-    priority: ModulePriorities
+    priority: ModulePriority
 
     def __str__(self) -> str:
         return (
@@ -135,13 +145,15 @@ Injectables
 class Injectable(Protocol[_T]):
     __slots__ = ()
 
-    def __init__(self, __factory: Callable[[], _T] = ..., /): ...
+    def __init__(self, __factory: Callable[[], _T] = None, /):
+        pass
 
     @property
     def is_locked(self) -> bool:
         return False
 
-    def unlock(self): ...
+    def unlock(self):
+        pass
 
     @abstractmethod
     def get_instance(self) -> _T:
@@ -163,7 +175,7 @@ class NewInjectable(BaseInjectable[_T]):
 class SingletonInjectable(BaseInjectable[_T]):
     __slots__ = ("__dict__",)
 
-    __INSTANCE_KEY = "$instance"
+    __INSTANCE_KEY: ClassVar[str] = "$instance"
 
     @property
     def cache(self) -> MutableMapping[str, Any]:
@@ -180,38 +192,22 @@ class SingletonInjectable(BaseInjectable[_T]):
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
-        with _thread_lock:
+        with thread_lock:
             instance = self.factory()
             self.cache[self.__INSTANCE_KEY] = instance
 
         return instance
 
 
-class InjectableWarning(BaseInjectable[_T], ABC):
-    __slots__ = ()
+@dataclass(repr=False, frozen=True, slots=True)
+class ShouldBeInjectable(Injectable[_T]):
+    cls: type[_T]
 
     def __bool__(self) -> bool:
         return False
 
-    @property
-    def formatted_type(self) -> str:
-        return format_type(self.factory)
-
-    @property
-    @abstractmethod
-    def exception(self) -> BaseException:
-        raise NotImplementedError
-
     def get_instance(self) -> NoReturn:
-        raise self.exception
-
-
-class ShouldBeInjectable(InjectableWarning[_T]):
-    __slots__ = ()
-
-    @property
-    def exception(self) -> BaseException:
-        return InjectionError(f"`{self.formatted_type}` should be an injectable.")
+        raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
 
 
 """
@@ -265,26 +261,34 @@ class Container(Broker):
     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.keys())
+
     @property
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Types, injectable: Injectable, override: bool):
-        values = MappingProxyType(
-            {origin: injectable for origin in get_origins(*classes)}
-        )
+    def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
+        classes = frozenset(get_origins(*classes))
 
-        if values:
-            event = ContainerDependenciesUpdated(self, values, override)
+        with thread_lock:
+            if not injectable:
+                classes -= self.__classes
+                override = True
 
-            with self.notify(event):
-                if not override:
-                    self.__check_if_exists(*values)
+            if classes:
+                event = ContainerDependenciesUpdated(self, classes, override)
+
+                with self.notify(event):
+                    if not override:
+                        self.__check_if_exists(classes)
 
-                self.__data.update(values)
+                    self.__data.update((cls, injectable) for cls in classes)
 
         return self
 
+    @synchronized
     def unlock(self):
         for injectable in self.__injectables:
             injectable.unlock()
@@ -296,9 +300,11 @@ class Container(Broker):
     def notify(self, event: Event) -> ContextManager | ContextDecorator:
         return self.__channel.dispatch(event)
 
-    def __check_if_exists(self, *classes: type):
-        for cls in classes:
-            if self.__data.get(cls):
+    def __check_if_exists(self, classes: Set[type]):
+        intersection = classes & self.__classes
+
+        for cls in intersection:
+            if self.__data[cls]:
                 raise RuntimeError(
                     f"An injectable already exists for the class `{format_type(cls)}`."
                 )
@@ -309,7 +315,7 @@ Module
 """
 
 
-class ModulePriorities(Enum):
+class ModulePriority(Enum):
     HIGH = auto()
     LOW = auto()
 
@@ -339,7 +345,7 @@ class Module(EventListener, Broker):
         raise NoInjectable(cls)
 
     def __setitem__(self, cls: type | UnionType, injectable: Injectable, /):
-        self.update((cls,), injectable, override=True)
+        self.update((cls,), injectable)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
@@ -353,7 +359,7 @@ class Module(EventListener, Broker):
 
     @property
     def __brokers(self) -> Iterator[Broker]:
-        yield from tuple(self.__modules)
+        yield from frozen_collection(self.__modules)
         yield self.__container
 
     def injectable(
@@ -376,11 +382,13 @@ class Module(EventListener, Broker):
         return decorator(wrapped) if wrapped else decorator
 
     singleton = partialmethod(injectable, cls=SingletonInjectable)
-    should_be_injectable = partialmethod(
-        injectable,
-        cls=ShouldBeInjectable,
-        inject=False,
-    )
+
+    def should_be_injectable(self, wrapped: type = None, /):
+        def decorator(wp):
+            self[wp] = ShouldBeInjectable(wp)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
 
     def set_constant(
         self,
@@ -403,21 +411,15 @@ class Module(EventListener, Broker):
         wrapped: Callable[..., Any] = None,
         /,
         *,
-        force: bool = False,
         return_factory: bool = False,
     ):
         def decorator(wp):
             if not return_factory and isclass(wp):
-                wp.__init__ = self.inject(wp.__init__, force=force)
+                wp.__init__ = self.inject(wp.__init__)
                 return wp
 
-            lazy_binder = Lazy[Binder](lambda: self.__new_binder(wp))
-
-            @wraps(wp)
-            def wrapper(*args, **kwargs):
-                arguments = (~lazy_binder).bind(args, kwargs, force)
-                return wp(*arguments.args, **arguments.kwargs)
-
+            wrapper = InjectedFunction(wp).update(self)
+            self.add_listener(wrapper)
             return wrapper
 
         return decorator(wrapped) if wrapped else decorator
@@ -437,14 +439,19 @@ class Module(EventListener, Broker):
     def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         return Lazy(lambda: self.get_instance(cls))
 
-    def update(self, classes: Types, injectable: Injectable, override: bool = False):
+    def update(
+        self,
+        classes: Iterable[type],
+        injectable: Injectable,
+        override: bool = False,
+    ):
         self.__container.update(classes, injectable, override)
         return self
 
     def use(
         self,
         module: Module,
-        priority: ModulePriorities = ModulePriorities.get_default(),
+        priority: ModulePriority = ModulePriority.get_default(),
     ):
         if module is self:
             raise ModuleError("Module can't be used by itself.")
@@ -475,13 +482,13 @@ class Module(EventListener, Broker):
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriorities = ModulePriorities.get_default(),
+        priority: ModulePriority = ModulePriority.get_default(),
     ) -> ContextManager | ContextDecorator:
         self.use(module, priority)
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: ModulePriorities):
+    def change_priority(self, module: Module, priority: ModulePriority):
         event = ModulePriorityUpdated(self, module, priority)
 
         with self.notify(event):
@@ -489,6 +496,7 @@ class Module(EventListener, Broker):
 
         return self
 
+    @synchronized
     def unlock(self):
         for broker in self.__brokers:
             broker.unlock()
@@ -517,8 +525,8 @@ class Module(EventListener, Broker):
         if self.is_locked:
             raise ModuleLockError(f"`{self}` is locked.")
 
-    def __move_module(self, module: Module, priority: ModulePriorities):
-        last = priority == ModulePriorities.LOW
+    def __move_module(self, module: Module, priority: ModulePriority):
+        last = priority == ModulePriority.LOW
 
         try:
             self.__modules.move_to_end(module, last=last)
@@ -527,44 +535,45 @@ class Module(EventListener, Broker):
                 f"`{module}` can't be found in the modules used by `{self}`."
             ) from exc
 
-    def __new_binder(self, target: Callable[..., Any]) -> Binder:
-        signature = inspect.signature(target, eval_str=True)
-        binder = Binder(signature).update(self)
-        self.add_listener(binder)
-        return binder
-
 
 """
-Binder
+InjectedFunction
 """
 
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Dependencies:
-    __mapping: MappingProxyType[str, Injectable]
+    mapping: Mapping[str, Injectable]
 
     def __bool__(self) -> bool:
-        return bool(self.__mapping)
+        return bool(self.mapping)
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for name, injectable in self.__mapping.items():
+        for name, injectable in self.mapping.items():
             yield name, injectable.get_instance()
 
+    @property
+    def are_resolved(self) -> bool:
+        if isinstance(self.mapping, LazyMapping) and not self.mapping.is_set:
+            return False
+
+        return bool(self)
+
     @property
     def arguments(self) -> OrderedDict[str, Any]:
         return OrderedDict(self)
 
     @classmethod
     def from_mapping(cls, mapping: Mapping[str, Injectable]):
-        return cls(MappingProxyType(mapping))
+        return cls(mapping=mapping)
 
     @classmethod
     def empty(cls):
         return cls.from_mapping({})
 
     @classmethod
-    def resolve(cls, signature: Signature, module: Module):
-        dependencies = LazyMapping(cls.__resolver(signature, module))
+    def resolve(cls, signature: Signature, module: Module, owner: type = None):
+        dependencies = LazyMapping(cls.__resolver(signature, module, owner))
         return cls.from_mapping(dependencies)
 
     @classmethod
@@ -572,33 +581,88 @@ class Dependencies:
         cls,
         signature: Signature,
         module: Module,
+        owner: type = None,
     ) -> Iterator[tuple[str, Injectable]]:
-        for name, parameter in signature.parameters.items():
+        for name, annotation in cls.__get_annotations(signature, owner):
             try:
-                injectable = module[parameter.annotation]
+                injectable = module[annotation]
             except KeyError:
                 continue
 
             yield name, injectable
 
+    @staticmethod
+    def __get_annotations(
+        signature: Signature,
+        owner: type = None,
+    ) -> Iterator[tuple[str, type | Any]]:
+        parameters = iter(signature.parameters.items())
+
+        if owner:
+            name, _ = next(parameters)
+            yield name, owner
+
+        for name, parameter in parameters:
+            yield name, parameter.annotation
+
 
 class Arguments(NamedTuple):
     args: Iterable[Any]
     kwargs: Mapping[str, Any]
 
 
-class Binder(EventListener):
-    __slots__ = ("__signature", "__dependencies")
+class InjectedFunction(EventListener):
+    __slots__ = ("__dict__", "__wrapper", "__dependencies", "__owner")
+
+    def __init__(self, wrapped: Callable[..., Any], /):
+        update_wrapper(self, wrapped)
+        self.__signature__ = Lazy[Signature](
+            lambda: inspect.signature(wrapped, eval_str=True)
+        )
+
+        @wraps(wrapped)
+        def wrapper(*args, **kwargs):
+            args, kwargs = self.bind(args, kwargs)
+            return wrapped(*args, **kwargs)
 
-    def __init__(self, signature: Signature):
-        self.__signature = signature
+        self.__wrapper = wrapper
         self.__dependencies = Dependencies.empty()
+        self.__owner = None
+
+    def __repr__(self) -> str:
+        return repr(self.__wrapper)
+
+    def __str__(self) -> str:
+        return str(self.__wrapper)
+
+    def __call__(self, /, *args, **kwargs) -> Any:
+        return self.__wrapper(*args, **kwargs)
+
+    def __get__(self, instance: object | None, owner: type):
+        if instance is None:
+            return self
+
+        return self.__wrapper.__get__(instance, owner)
+
+    def __set_name__(self, owner: type, name: str):
+        if self.__dependencies.are_resolved:
+            raise TypeError(
+                "`__set_name__` is called after dependencies have been resolved."
+            )
+
+        if self.__owner:
+            raise TypeError("Function owner is already defined.")
+
+        self.__owner = owner
+
+    @property
+    def signature(self) -> Signature:
+        return self.__signature__()
 
     def bind(
         self,
         args: Iterable[Any] = (),
         kwargs: Mapping[str, Any] = None,
-        force: bool = False,
     ) -> Arguments:
         if kwargs is None:
             kwargs = {}
@@ -606,22 +670,25 @@ class Binder(EventListener):
         if not self.__dependencies:
             return Arguments(args, kwargs)
 
-        bound = self.__signature.bind_partial(*args, **kwargs)
+        bound = self.signature.bind_partial(*args, **kwargs)
         dependencies = self.__dependencies.arguments
-
-        if force:
-            bound.arguments |= dependencies
-        else:
-            bound.arguments = dependencies | bound.arguments
+        bound.arguments = dependencies | bound.arguments
 
         return Arguments(bound.args, bound.kwargs)
 
     def update(self, module: Module):
-        self.__dependencies = Dependencies.resolve(self.__signature, module)
+        with thread_lock:
+            self.__dependencies = Dependencies.resolve(
+                self.signature,
+                module,
+                self.__owner,
+            )
+
         return self
 
     @singledispatchmethod
-    def on_event(self, event: Event, /): ...
+    def on_event(self, event: Event, /):
+        pass
 
     @on_event.register
     @contextmanager

{python_injection-0.7.3 → python_injection-0.7.5}/injection/exceptions.py

@@ -1,4 +1,4 @@
-from injection.common.tools import format_type
+from injection.common.tools.type import format_type
 
 __all__ = (
     "InjectionError",
@@ -10,7 +10,7 @@ __all__ = (
 
 
 class InjectionError(Exception):
-    __slots__ = ()
+    pass
 
 
 class NoInjectable(KeyError, InjectionError):
@@ -26,12 +26,12 @@ class NoInjectable(KeyError, InjectionError):
 
 
 class ModuleError(InjectionError):
-    __slots__ = ()
+    pass
 
 
 class ModuleLockError(ModuleError):
-    __slots__ = ()
+    pass
 
 
 class ModuleNotUsedError(KeyError, ModuleError):
-    __slots__ = ()
+    pass

python_injection-0.7.5/pyproject.toml

@@ -0,0 +1,56 @@
+[tool.poetry]
+name = "python-injection"
+version = "0.7.5"
+description = "Fast and easy dependency injection framework."
+authors = ["remimd"]
+keywords = ["dependencies", "inject", "injection"]
+license = "MIT"
+packages = [{ include = "injection" }]
+readme = "documentation/basic-usage.md"
+repository = "https://github.com/100nm/python-injection"
+
+[tool.poetry.dependencies]
+python = ">=3.10, <4"
+
+[tool.poetry.group.dev.dependencies]
+blacksheep = "*"
+pydantic = "*"
+pytest = "*"
+pytest-asyncio = "*"
+pytest-cov = "*"
+ruff = "*"
+
+[tool.coverage.report]
+exclude_lines = [
+    "pass",
+    "pragma: no cover",
+    "raise NotImplementedError",
+]
+
+[tool.pytest.ini_options]
+python_files = "test_*.py"
+addopts = "-p no:warnings --tb=short"
+asyncio_mode = "auto"
+testpaths = "tests/"
+
+[tool.ruff]
+line-length = 88
+indent-width = 4
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.ruff.lint]
+extend-select = ["F", "I", "N"]
+ignore = ["N818"]
+fixable = ["ALL"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F403"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

python_injection-0.7.3/injection/common/tools/__init__.py

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

python_injection-0.7.3/pyproject.toml

@@ -1,27 +0,0 @@
-[tool.poetry]
-name = "python-injection"
-version = "0.7.3"
-description = "Fast and easy dependency injection framework."
-authors = ["remimd"]
-keywords = ["dependencies", "inject", "injection"]
-license = "MIT"
-packages = [{ include = "injection" }]
-readme = "documentation/basic-usage.md"
-repository = "https://github.com/100nm/python-injection"
-
-[tool.poetry.dependencies]
-python = ">=3.10, <4"
-
-[tool.poetry.group.dev.dependencies]
-black = "*"
-blacksheep = "^2.0.7"
-flake8 = "*"
-isort = "*"
-pydantic = "^2.6.3"
-pytest = "*"
-pytest-asyncio = "*"
-pytest-cov = "*"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"