https://github.com/guardicode/ophidian
A dependency injection container for Python
https://github.com/guardicode/ophidian
Last synced: 3 months ago
JSON representation
A dependency injection container for Python
- Host: GitHub
- URL: https://github.com/guardicode/ophidian
- Owner: guardicode
- License: gpl-3.0
- Created: 2023-09-27T23:21:36.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2023-11-22T13:46:25.000Z (over 2 years ago)
- Last Synced: 2025-09-21T12:26:46.598Z (10 months ago)
- Language: Python
- Size: 685 KB
- Stars: 1
- Watchers: 8
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# ophiDIan
---
[](http://badge.fury.io/py/ophidian)
[](https://github.com/psf/black)
[](https://timothycrosley.github.io/isort/)
[](https://img.shields.io/pypi/l/ophidian)
[](https://img.shields.io/github/issues-pr/guardicode/ophidian)
[](https://github.com/pre-commit/pre-commit)
[](http://mypy-lang.org/)
[](https://codecov.io/gh/guardicode/ophidian)
---
## Description
ophiDIan is a Dependency Injection (DI) container for Python. Unlike other DI
containers that utilize decorators or configuration files to accomplish their
goal, ophiDIan uses type hints to identify and resolve dependencies. In other
words, by using type hinting to resolve dependencies, ophiDIan avoids making
your components dependent upon the DI framework.
Ophidian follows the [Register, Resolve, Release (RRR)
pattern](https://blog.ploeh.dk/2010/09/29/TheRegisterResolveReleasepattern/).
## Installation
Install with `pip install ophidian`
## Tutorial
### Dependency definitions
For this tutorial, we'll use the following class definitions:
```python
from abc import ABC, abstractmethod
class AbstractA(ABC):
@abstractmethod
def do_something(self):
pass
class AbstractB(ABC):
@abstractmethod
def do_something_else(self):
pass
class DependencyA(AbstractA):
def do_something(self):
print(f"{id(self)}: I am dependency A")
class DependencyB(AbstractB):
def __init__(self, name: str):
self._name = name
def do_something_else(self):
print(f"{id(self)} My name is {self._name}")
class TestClass1:
def __init__(self, a: AbstractA):
self.a = a
class TestClass2:
__test__ = False
def __init__(self, b: AbstractB):
self.b = b
class TestClass3:
def __init__(self, a: AbstractA, b: AbstractB):
self.a = a
self.b = b
```
### RRR
The first step in the RRR pattern is to *R*egister dependencies. This can be
performed using either the `register()` or `register_instance()` methods. Next,
objects can be built by *R*esolving. Finally, when the dependency is no
longer needed, it can be *R*eleased.
```python
from ophidian import DIContainer
dependency_b_instance = DependencyB("Mike")
di_container = DIContainer()
di_container.register(AbstractA, DependencyA)
di_container.register_instance(AbstractB, dependency_b_instance)
test_class_1 = di_container.resolve(TestClass1)
test_class_2 = di_container.resolve(TestClass2)
test_class_3 = di_container.resolve(TestClass3)
assert id(test_class_1.a) != id(test_class_3.a)
assert id(test_class_2.b) == id(dependency_b_instance)
assert id(test_class_2.b) == id(test_class_3.b)
assert isinstance(test_class_1.a, AbstractA)
assert isinstance(test_class_1.a, DependencyA)
assert isinstance(test_class_2.b, AbstractB)
assert isinstance(test_class_2.b, DependencyB)
# Note: All dependencies will automatically be released when the `di_container`
# instance is cleaned up by the garbage collector.
di_container.release(AbstractA)
di_container.release(AbstractB)
```
In the above example, the `DIContainer.register()` method is used tell the DI
container that components that depend upon `AbstractA` should be supplied a new
instance of the concrete class `DependencyA`. The
`DiContainer.register_instance()` method is used to tell the DI container that
all components that depend upon `AbstractB` should be supplied with the same
instance of `DependencyB`.
### Conventions
Conventions are mainly used to resolve primitive dependencies. For example, if
a component depends upon a file path for a configuration file passed as a
string, a convention can be registered to provide the dependency.
```python
from ophidian import DIContainer
class Configuration:
def __init__(self, a: DependencyA, config_file_path: str):
...
di_container = DIContainer()
di_container.register(AbstractA, DependencyA)
di_container.register_convention(str, "config_file_path", "/tmp/my_config_file")
configuration = di_container.resolve(Configuration)
di_container.release(AbstractA)
di_container.release_convention(str, "config_file_path")
```
We wouldn't want to use `register()` or `register_instance()`, as we wouldn't
want all string dependencies to be resolved with the configuration file path.
Instead, the DI container is informed about an established "convention" within
the code: components that depend upon the configuration file path expect a
string parameter named "config_file_path". See [Primitive Dependencies by Mark
Seemann](https://blog.ploeh.dk/2012/07/02/PrimitiveDependencies/) for more
information about conventions.
## Documentation
### DIContainer
```python
class DIContainer()
```
A dependency injection (DI) container that uses type annotations to resolve and
inject dependencies.
#### \_\_init\_\_
```python
def __init__()
```
#### register
```python
@no_type_check
def register(interface: Type[T], concrete_type: Type[T])
```
Register a concrete `type` that satisfies a given interface.
:param interface: An interface or abstract base class that other classes depend
upon
:param concrete_type: A `type` (class) that implements `interface`
:raises TypeError: If `concrete_type` is not a class, or not a subclass of
`interface`
#### register\_instance
```python
@no_type_check
def register_instance(interface: Type[T], instance: T)
```
Register a concrete instance that satisfies a given interface.
:param interface: An interface or abstract base class that other classes depend
upon
:param instance: An instance (object) of a `type` that implements
`interface`
:raises TypeError: If `instance` is not an instance of `interface`
#### register\_convention
```python
@no_type_check
def register_convention(type_: Type[T], name: str, instance: T)
```
Register an instance as a convention
At times — particularly when dealing with primitive types — it can be useful to
define a convention for how dependencies should be resolved. For example, you
might want any class that specifies `hostname: str` in its constructor to
receive the hostname of the system it's running on. Registering a convention
allows you to assign an object instance to a type, name pair.
**Example:**
class TestClass:
def __init__(self, hostname: str):
self.hostname = hostname
di_container = DIContainer()
di_container.register_convention(str, "hostname", "my_hostname.domain")
test = di_container.resolve(TestClass)
assert test.hostname == "my_hostname.domain"
:param type_: The `type` (class) of the dependency
:param name: The name of the dependency parameter
:param instance: An instance (object) of `type_` that will be injected into constructors
that specify `[name]: [type_]` as parameters
### Errors
#### UnresolvableDependencyError
```python
class UnresolvableDependencyError(ValueError):
```
Raised when one or more dependencies cannot be successfully resolved.
## Running the tests
Running the tests is as simple as `poetry install && poetry run pytest`