Injector Change Log¶
- Fixed handling of Union combined with Annotated, thanks to Tobias Nilsson
- Fixed AssitedBuilder/child Injector interaction, thanks to Erik Cederberg
- Made get_bindings() and injections work even if a injectee’s return type annotation is a forward reference that can’t be resolved
- Dropped Python 3.6 support
- Added the license to the source distribution, thanks to Joshua Adelman
- Added Python 3.9 and 3.10 support, this includes fixing Python 3.10 compatibility, thanks to Torge Matthies
- Improved the documentation, thanks to Takahiro Kojima
- Improved the source distribution so that it can be used to build and install wheels, thanks to Janusz Skonieczny
- Added requirements files for easier development, thanks to Greg Eremeev
- Removed Python 3.5 support
- Fixed a bug where only one of multiple NoInject annotations was interpreted
- Fixed Python 3.5.3 compatibility
- Added remaining type hints to the codebase so that the client code can have better static typing safety
- Fixed UnsatisfiedRequirement string representation (this time for real)
- Added forward return type reference support to provider methods
- Fixed UnsatisfiedRequirement instantiation (trying to get its string representation would fail)
- Fixed injecting a subclass of a generic type on Python versions older than 3.7.0
- Fixed regression that caused BoundKey injection failure
- Added new public
get_bindingsfunction to see what parameters will be injected into a function
- Added new generic types using a draft implementation of PEP 593:
NoInject. Those serve as additional ways to declare (non)injectable parameters while
injectwon’t go away any time soon
noninjectablemay be removed once NoInject is cofirmed to work.
- Removed previously deprecated Key, BindingKey, SequenceKey and MappingKey pseudo-types
- Added support for using typing.Dict and typing.List in multibindings. See
- Added multibinding-specific
- Deprecated using
- Fixed failure to provide a default value to a NewType-aliased type with auto_bind enabled
MappingKey– use real types or type aliases instead
- Deprecated using single-item lists and dictionaries for multibindings - use real types or type aliases instead
Technically backwards incompatible:
- Reuploaded to fix incorrectly formatted project description
- Added support for overriding injectable parameters with positional arguments (previously only possible with keyword arguments)
- Fixed crashes caused by typed self in method signatures
- Improved typing coverage
- Dropped Python 3.4 support
- Removed previously deprecated constructs: with_injector, Injector.install_into, Binder.bind_scope
- Dependencies are no longer injected into Module.configure and raw module functions (previously deprecated)
- Removed unofficial support for injecting into parent class constructors
- Added type information for Injector.create_object() (patch #101 thanks to David Pärsson)
- Made the code easier to understand (patch #105 thanks to Christian Clauss)
- Opted the package into distributing type information and checking it (PEP 561)
- Fixed regression that required all noninjectable parameters to be typed
- Added NewType support
- Added type hints
- Passing invalid parameter names to @noninjectable() will now result in an error
- Dropped Python 3.3 support
- Deprecated with_injector. There’s no one migration path recommended, it depends on a particular case.
- Deprecated install_into.
- Fixed a bug with classes deriving from PyQt classes not being able to be instantiated manually (bug #75, patch #76 thanks to David Pärsson)
- Fixed a bug with values shared between Injectors in a hierarchy (bugs #52 and #72)
- Binding scopes explicitly (
Binder.bind_scope) is no longer necessary and
bind_scopeis a no-op now.
- Improved some error messages
- 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
- Binding annotations are removed. Use
Key()to create unique types instead.
- 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.