pysyringe 1.0.0__tar.gz

pysyringe-1.0.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.3
+Name: pysyringe
+Version: 1.0.0
+Summary: An opinionated dependency injection library for Python
+Author: Hugo Chinchilla
+Author-email: hugoasecas@gmail.com
+Requires-Python: >=3.12,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# PySyringe
+
+An opinionated dependency injection library for Python.
+
+A container that does not rely on adding decorators to your domain classes. It only wraps views in the infrastructure layer to keep your domain and app layer decoupled from the framework and the container.
+
+## Usage
+
+
+```python
+# container.py
+from myapp.domain import CalendarInterface
+from myapp.infra import LoggingEmailSender, SmtpEmailSender, Calendar
+from django.core.http import HttpRequest, HttpResponse
+
+
+class Factory:
+    def __init__(self, environment: str) -> None:
+        self.environment = environment
+
+    def get_mailer(self) -> EmailSender:
+        if self.environment == "production":
+            return SmtpEmailSender("mta.example.org", 25)
+
+        return LoggingEmailSender()
+
+
+factory = Factory(str(settings.ENVIRONMENT))
+
+container = Container(factory)
+container.never_provide(HttpRequest)
+container.never_provide(HttpResponse)
+container.alias(CalendarInterface, Calendar)
+
+
+# views.py
+from container import container
+
+@container.inject
+def my_view(request: HttpRequest, calendar: CalendarInterface) -> HttpResponse:
+    now = calendar.now()
+    return HttpResponse(f"Hello, World! The current time is {now}")
+```
+

pysyringe-1.0.0/README.md

@@ -0,0 +1,43 @@
+# PySyringe
+
+An opinionated dependency injection library for Python.
+
+A container that does not rely on adding decorators to your domain classes. It only wraps views in the infrastructure layer to keep your domain and app layer decoupled from the framework and the container.
+
+## Usage
+
+
+```python
+# container.py
+from myapp.domain import CalendarInterface
+from myapp.infra import LoggingEmailSender, SmtpEmailSender, Calendar
+from django.core.http import HttpRequest, HttpResponse
+
+
+class Factory:
+    def __init__(self, environment: str) -> None:
+        self.environment = environment
+
+    def get_mailer(self) -> EmailSender:
+        if self.environment == "production":
+            return SmtpEmailSender("mta.example.org", 25)
+
+        return LoggingEmailSender()
+
+
+factory = Factory(str(settings.ENVIRONMENT))
+
+container = Container(factory)
+container.never_provide(HttpRequest)
+container.never_provide(HttpResponse)
+container.alias(CalendarInterface, Calendar)
+
+
+# views.py
+from container import container
+
+@container.inject
+def my_view(request: HttpRequest, calendar: CalendarInterface) -> HttpResponse:
+    now = calendar.now()
+    return HttpResponse(f"Hello, World! The current time is {now}")
+```

pysyringe-1.0.0/pyproject.toml

@@ -0,0 +1,149 @@
+[tool.poetry]
+name = "pysyringe"
+version = "1.0.0"
+description = "An opinionated dependency injection library for Python"
+authors = ["Hugo Chinchilla <hugoasecas@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "~3.12"
+
+[tool.poetry.group.dev.dependencies]
+coverage = "^7.3"
+pre-commit = "^3.4.0"
+ruff = "^0.2.0"
+mypy = "^1.6.1"
+pytest = "^8.3.5"
+
+[tool.ruff]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+lint.select = [
+    "E4",
+    "E7",
+    "E9",
+    "F",
+    "W",
+    "I",
+    "N",
+    "UP",
+    "YTT",
+    "ANN001",
+    "ANN2",
+    "ANN4",
+    "ASYNC",
+    "S",
+    "BLE",
+    "B",
+    "A001",
+    "A002",
+    "COM",
+    "C",
+    #"DTZ",
+    "T",
+    #"DJ",
+    "EXE",
+    "FA",
+    "ISC",
+    "ICN",
+    "INP",
+    "PIE",
+    "T20",
+    "PYI",
+    "Q",
+    "RSE",
+    "RET",
+    "SLF",
+    "SIM",
+    "TID",
+    "TCH",
+    "ARG",
+    "ERA",
+    "PGH",
+    "PL",
+    "TRY",
+    "FLY",
+    "PERF",
+    "RUF",
+]
+lint.ignore = ["ANN401", "UP015", "COM812", "TRY401", "PLR2004"]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+lint.fixable = ["ALL"]
+lint.unfixable = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".cache",
+    ".direnv",
+    ".git",
+    ".git-rewrite",
+    ".venv",
+    "venv",
+    "__pypackages__",
+    "__pycache__",
+]
+
+# Same as Black.
+line-length = 88
+
+# Allow unused variables when underscore-prefixed.
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Assume Python 3.12
+target-version = "py312"
+
+cache-dir = ".cache/ruff"
+
+[tool.ruff.lint.per-file-ignores]
+"./tests/*" = ["ANN201", "S101"]
+
+[tool.ruff.lint.mccabe]
+# Unlike Flake8, default to a complexity level of 10.
+max-complexity = 10
+
+[tool.mypy]
+python_version = "3.12"
+ignore_missing_imports = true
+no_implicit_optional = true
+strict_equality = true
+warn_redundant_casts = true
+warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+warn_unused_ignores = true
+cache_dir = '.cache/mypy'
+
+
+[tool.coverage.run]
+branch = true
+relative_files = true
+source = ["./"]
+omit = [
+    "tests/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "raise NotImplementedError",
+    "if __name__ == \"__main__\":",
+    "pass",
+]
+precision = 2
+skip_covered = true
+skip_empty = true
+fail_under = 95
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+testpaths = "tests"
+python_files = "test_*.py"
+python_classes = "*Test"
+python_functions = "test_*"
+cache_dir = ".cache/pytest"
+filterwarnings = []
+
+[tool.isort]
+profile = "black"

pysyringe-1.0.0/pysyringe/container.py

@@ -0,0 +1,206 @@
+import inspect
+import typing
+from collections.abc import Callable
+from types import UnionType
+from typing import Any, TypeVar, cast
+
+T = TypeVar("T")
+NoneType = type(None)
+
+
+class _Unresolved:
+    pass
+
+
+class UnknownDependencyError(Exception):
+    def __init__(self, type_: type) -> None:
+        super().__init__(f"Container does not know how to provide {type_}")
+
+
+class UnresolvableUnionTypeError(Exception):
+    def __init__(self, type_: type) -> None:
+        super().__init__(
+            f"Cannot resolve [{type_}]: remove UnionType or define a factory",
+        )
+
+
+class _Resolver:
+    def __init__(self, factory: object) -> None:
+        self.factory = factory
+        self.mocks: dict = {}
+        self.aliases: dict = {}
+        self.never_provide: list[type] = []
+
+    def resolve(self, cls: type[T]) -> T | _Unresolved:  # noqa: PLR0911
+        try:
+            if issubclass(cls, tuple(self.never_provide)):
+                return _Unresolved()
+        except TypeError:
+            return _Unresolved()
+
+        if cls in self.mocks:
+            return cast(T, self.mocks[cls])
+
+        if cls in self.aliases:
+            return self.resolve(self.aliases[cls])
+
+        instance = self.__make_from_factory(cls)
+        if instance:
+            return instance
+
+        instance = self.__make_from_inference(cls)
+        if instance:
+            return instance
+
+        return _Unresolved()
+
+    def __make_from_factory(self, cls: type[T]) -> T | None:
+        for factory in self.__get_factories():
+            if cls == _TypeHelper.get_return_type(factory):
+                return cast(T, factory())
+
+        return None
+
+    def __get_factories(self) -> list[Callable]:
+        attrs = [
+            getattr(self.factory, x) for x in dir(self.factory) if not x.startswith("_")
+        ]
+        return [attr for attr in attrs if callable(attr)]
+
+    def __make_from_inference(self, cls: type[T]) -> T | None:
+        dependencies = {}
+        for arg_name, arg_type in _TypeHelper.get_constructor_arguments(cls):
+            resolved = self.resolve(arg_type)
+            if isinstance(resolved, _Unresolved):
+                return None
+            dependencies[arg_name] = resolved
+
+        return cls(**dependencies)
+
+
+class Container:
+    def __init__(self, factory: object) -> None:
+        self._resolver = _Resolver(factory)
+
+    def never_provide(self, cls: type[T]) -> None:
+        self._resolver.never_provide.append(cls)
+
+    def provide(self, cls: type[T]) -> T:
+        resolved = self._resolver.resolve(cls)
+        if isinstance(resolved, _Unresolved):
+            raise UnknownDependencyError(cls)
+
+        return resolved
+
+    def inject(self, function: Callable) -> Callable:
+        injector = _Injector(self._resolver)
+        return injector.inject(function)
+
+    def clear_mocks(self) -> None:
+        self._resolver.mocks = {}
+
+    def use_mock(self, cls: type[T], mock: T) -> None:
+        self._resolver.mocks[cls] = mock
+
+    def alias(self, interface: type, implementation: type) -> None:
+        self._resolver.aliases[interface] = implementation
+
+
+class _Injector:
+    def __init__(self, _resolver: _Resolver) -> None:
+        self._resolver = _resolver
+
+    def inject(self, function: Callable) -> Callable:
+        injections = self.__get_injectable_arguments(function)
+
+        def partial_function(*args, **kwargs) -> Any:
+            injections = self.__get_injectable_arguments(function)
+            return function(*args, **kwargs, **injections)
+
+        partial_function.__signature__ = self.__create_new_signature(  # type: ignore[attr-defined]
+            function,
+            injections,
+        )
+        partial_function.__name__ = function.__name__
+
+        return partial_function
+
+    def __get_injectable_arguments(self, function: Callable) -> dict[str, object]:
+        signature = inspect.signature(function)
+        resolved_arguments = {
+            (p.name, self._resolver.resolve(p.annotation))
+            for p in signature.parameters.values()
+            if p.name != "self"
+        }
+        only_resolved = {
+            (parameter_name, value)
+            for (parameter_name, value) in resolved_arguments
+            if not isinstance(value, _Unresolved)
+        }
+        return dict(only_resolved)
+
+    def __create_new_signature(
+        self,
+        function: Callable,
+        injections: dict[str, T],
+    ) -> inspect.Signature:
+        remaining_parameters = [
+            p
+            for p in inspect.signature(function).parameters.values()
+            if p.name not in injections
+        ]
+
+        return inspect.Signature(
+            parameters=remaining_parameters,
+            return_annotation=(_TypeHelper.get_return_type(function)),
+        )
+
+
+class _TypeHelper:
+    @classmethod
+    def get_constructor_arguments(cls, subject: type[T]) -> list[tuple]:
+        try:
+            parameters = inspect.signature(subject).parameters.values()
+        except ValueError:
+            return []
+
+        return [
+            (p.name, cls._desambiguate(p.annotation))
+            for p in parameters
+            if p.name != "return"
+        ]
+
+    @classmethod
+    def _desambiguate(cls, type_: type[T]) -> type[T]:
+        if cls._is_union(type_):
+            if cls._is_optional(type_):
+                return cls._resolve_optional(type_)
+            raise UnresolvableUnionTypeError(type_)
+        return type_
+
+    @classmethod
+    def _is_union(cls, type_: T) -> bool:
+        if typing.get_origin(type_) is typing.Union:
+            return True  # Syntax using "Union[object, str]"
+
+        if isinstance(type_, UnionType):
+            return True  # Syntax using "object | str"
+
+        return False
+
+    @staticmethod
+    def _is_optional(type_: object) -> bool:
+        types = set(typing.get_args(type_))
+        has_two_types = len(types) == 2
+        one_of_them_is_optional = NoneType in types
+        return has_two_types and one_of_them_is_optional
+
+    @staticmethod
+    def _resolve_optional(type_: type[T | None]) -> type[T]:
+        types = set(typing.get_args(type_))
+        types.remove(type(None))
+        return cast(type[T], types.pop())
+
+    @staticmethod
+    def get_return_type(method: Callable) -> type:
+        return cast(type, inspect.signature(method).return_annotation)

pysyringe-1.0.0/pysyringe/singleton.py

@@ -0,0 +1,32 @@
+from typing import ClassVar, TypeVar
+
+T = TypeVar("T")
+CacheKey = tuple[T, ...]
+
+
+class _Cache:
+    _entries: ClassVar[dict] = {}
+
+    @classmethod
+    def has(cls, key: CacheKey[T]) -> bool:
+        return key in cls._entries
+
+    @classmethod
+    def get(cls, key: CacheKey[T]) -> T:
+        instance: T = cls._entries[key]
+        return instance
+
+    @classmethod
+    def set(cls, key: CacheKey[T], value: T) -> None:
+        cls._entries[key] = value
+
+
+def singleton(type_: type[T], *type_args, **type_kwargs) -> T:
+    key = (*(type_,), *(type_args,), *tuple(*sorted(type_kwargs.items())))
+
+    if not _Cache.has(key):
+        instance: T = type_(*type_args, **type_kwargs)
+        _Cache.set(key, instance)
+
+    inst: T = _Cache.get(key)
+    return inst