Highly extensible Dependency injection framework for humans
Project description
hexdi
Highly extensible Dependency Injection framework for humans
Project location: https://github.com/zibertscrem/hexdi
Installation
pip install hexdiYou should have python 3.5.* or higher
Usage
All of that usages you can find in examples directory
Quick usage reference
import hexdi
class SomeA:
def foo(self): pass
# mark that class as injectable with permanent lifetime for class SomeA
@hexdi.permanent(SomeA)
class SomeAimplementation(SomeA):
def foo(self):
return 42
# inject instance of SomeA as a first argument
@hexdi.inject(SomeA)
def test_injection(a: SomeA):
print('test_injection:', a.foo())
class ClassWithDependency:
# constructor injection
@hexdi.inject(SomeA)
def __init__(self, a: SomeA):
print('ClassWithDependency.__init__:', a.foo())
# after that we can use property like an instance of SomeA class
@property
@hexdi.dependency(SomeA)
def some_a(self) -> SomeA: pass
def foo(self):
print('ClassWithDependency.foo:', self.some_a.foo())
# method injection also works fine.
# Because injection members are passing after all transmitted positional arguments
@hexdi.inject(SomeA)
def foo_with_injection(self, a: SomeA):
print('ClassWithDependency.foo_with_injection:', a.foo())
if __name__ == '__main__':
# You don't need to provide any argument. DI container does it self
# There also should not be cycle dependencies due to lazy loading of any injections
test_injection() # prints: test_injection: 42
cwd = ClassWithDependency() # prints: ClassWithDependency.__init__: 42
cwd.foo() # prints: ClassWithDependency.foo: 42
cwd.foo_with_injection() # prints: ClassWithDependency.foo_with_injection: 42Self-binding
import hexdi
@hexdi.permanent()
class SomeA:
def foo(self):
return 42
@hexdi.inject(SomeA)
def test(a):
print(a.foo())
if __name__ == '__main__':
test() # prints: 42Multiple injection arguments
import hexdi
@hexdi.permanent()
class SomeA:
def foo(self):
return 42
@hexdi.permanent()
class SomeB:
def foo(self):
return 69
@hexdi.inject(SomeA, SomeB)
def test(a, b):
print(a.foo() + b.foo())
if __name__ == '__main__':
test() # prints: 111Permanent lifetime and transient lifetime
import hexdi
@hexdi.permanent()
class SomeA:
NUMBER = 0
def __init__(self):
self.num = SomeA.NUMBER
SomeA.NUMBER += 1
def foo(self):
print(self.__class__.__name__, self.num)
@hexdi.transient()
class SomeB:
NUMBER = 0
def __init__(self):
self.num = SomeB.NUMBER
SomeB.NUMBER += 1
def foo(self):
print(self.__class__.__name__, self.num)
@hexdi.inject(SomeA)
def test_a(a):
a.foo()
@hexdi.inject(SomeB)
def test_b(b):
b.foo()
if __name__ == '__main__':
test_a() # prints: SomeA 0
test_a() # prints: SomeA 0
test_a() # prints: SomeA 0
test_b() # prints: SomeB 0
test_b() # prints: SomeB 1
test_b() # prints: SomeB 2Usage of container. Demonstration of lazy injection
import hexdi
class SomeA:
def foo(self): pass
class SomeAImplementation(SomeA):
def foo(self):
return 42
@hexdi.permanent()
class SomeB:
def foo(self):
return 69
class SomeC:
def foo(self):
return 100500
@hexdi.inject(SomeC)
def test(c):
print(c.foo())
if __name__ == '__main__':
# getting of container
container = hexdi.get_root_container()
# binding SomeAImplementation on SomeA type with permanent lifetime
container.bind_type(SomeAImplementation, SomeA, hexdi.lifetime.PermanentLifeTimeManager)
instance = container.resolve(SomeA)
print(instance.foo()) # prints: 42
# resolve decorator-binded SomeB
instance = container.resolve(SomeB)
print(instance.foo()) # prints: 69
# bind SomeC on itself with permanent lifetime
container.bind_type(SomeC, SomeC, hexdi.lifetime.PermanentLifeTimeManager)
# we mark SomeC for injection above in test func,
# but all works fine, because it is lazy injection
test() # prints: 100500Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
hexdi-0.1.2b2.tar.gz
(4.4 kB
view hashes)
