Injector Change Log¶
- Dropped Python 3.2 support
- Dropped Injector use_annotations constructor parameter. Whenever @inject is used parameter annotations will be used automatically.
- Dropped Python 2 support (this includes PyPy)
- Removed @provides decorator, use @provider instead
- Removed support for passing keyword arguments to @inject
- Fixed binding inference in presence of * and ** arguments (previously Injector would generate extra arguments, now it just ignores them)
- Improved error reporting
- Fixed compatibility with newer typing versions (that includes the one bundled with Python 3.6)
Technically backwards incompatible:
Forward references as PEP 484 understands them are being resolved now when Python 3-style annotations are used. See https://www.python.org/dev/peps/pep-0484/#forward-references for details.
Optional parameters are treated as compulsory for the purpose of injection.
- 0.11.0 packages uploaded to PyPI are broken (can’t be installed), this is a fix-only release.
The following way to declare dependencies is introduced and recommended now:
class SomeClass: @inject def __init__(self, other: OtherClass): # ...
The following ways are still supported but are deprecated and will be removed in the future:
# Python 2-compatible style class SomeClass @inject(other=OtherClass) def __init__(self, other): # ... # Python 3 style without @inject-decoration but with use_annotations class SomeClass: def __init__(self, other: OtherClass): # ... injector = Injector(use_annotations=True) # ...
The following way to declare Module provider methods is introduced and recommended now:
class MyModule(Module): @provider def provide_something(self, dependency: Dependency) -> Something: # ...
@provider implies @inject.
Previously it would look like this:
class MyModule(Module): @provides(Something) @inject def provide_something(self, dependency: Dependency): # ...
provides()decorator will be removed in the future.
noninjectable()decorator to mark parameters as not injectable (this serves as documentation and a way to avoid some runtime errors)
Removed support for decorating classes with
@inject(something=Something) class Class: pass
class Class: @inject def __init__(self, something: Something): self.something = something
Removed support for injecting partially applied functions, previously:
@inject(something=Something) def some_function(something): pass class Class: @inject(function=some_function) def __init__(self, function): # ...
Now you need to move the function with injectable dependencies to a class.
Removed support for getting
Dropped Python 2.6 support
Changed the way
ProviderOfare used. Previously:
builder1 = injector.get(AssistedBuilder(Something)) # or: builder1 = injector.get(AssistedBuilder(interface=Something)) builder2 = injector.get(AssistedBuilder(cls=SomethingElse)) provider = injector.get(ProviderOf(SomeOtherThing))
builder1 = injector.get(AssistedBuilder[Something]) builder2 = injector.get(ClassAssistedBuilder[cls=SomethingElse]) provider = injector.get(ProviderOf[SomeOtherThing])
Removed support for injecting into non-constructor methods
- Fixed a false positive bug in dependency cycle detection (AssistedBuilder can be used to break dependency cycles now)
injector.Provider.get()now requires an
injector.Injectorinstance as its parameter
- deprecated injecting arguments into modules (be it functions/callables,
- removed extends decorator
- few classes got useful __repr__ implementations
- fixed injecting ProviderOf and AssistedBuilders when
injector.Injectorauto_bind is set to False (previously would result in UnsatisfiedRequirement error)
- fixed crash occurring when Python 3-function annotation use is enabled and __init__ method has a return value annotation (“injector.UnknownProvider: couldn’t determine provider for None to None”), should also apply to free functions as well
- Bug fix release.
Injectorcan rebind dependancies bound in parent Injector (that changes
Providersemantics), thanks to Ilya Orlov
CallableProvidercallables can be injected into, thanks to Ilya Strukov
- One can request
ProviderOf(Interface) and get a
BoundProviderwhich can be used to get an implementation of Interface when needed
- Fixed regression with injecting unbound key resulting in None instead of raising an exception
- Exception is raised when
Injectorcan’t install itself into a class instance due to __slots__ presence
- Some of exception messages are now more detailed to make debugging easier when injection fails
- You can inject functions now -
Injectorprovides a wrapper that takes care of injecting dependencies into the original function
AssistedBuilderbehave more explicitly: it can build either innstance of a concrete class (
AssistedBuilder(cls=Class)) or it will follow Injector bindings (if exist) and construct instance of a class pointed by an interface (
AssistedBuilder(X)behaviour remains the same, it’s equivalent to
- Auto-convert README.md to RST for PyPi.
- Added a ChangeLog!
- Added support for using Python3 annotations as binding types.