Injector Change Log¶
0.20.1¶
- Added support for PEP 604 union types (Python 3.10+), thanks to David Pärsson
- Fixed building with pypandoc 1.8+, thanks to Søren Fuglede Jørgensen
0.20.0¶
- 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
Backwards incompatible:
- Dropped Python 3.6 support
0.19.0¶
- 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
Backwards incompatible:
- Removed Python 3.5 support
0.18.4¶
- Fixed a bug where only one of multiple NoInject annotations was interpreted
0.18.3¶
- Fixed Python 3.5.3 compatibility
0.18.2¶
- 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
0.18.1¶
- 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
0.18.0¶
- Added new public
get_bindings
function to see what parameters will be injected into a function - Added new generic types using a draft implementation of PEP 593:
Inject
andNoInject
. Those serve as additional ways to declare (non)injectable parameters whileinject
won’t go away any time soonnoninjectable
may be removed once NoInject is cofirmed to work.
Backwards incompatible:
- Removed previously deprecated Key, BindingKey, SequenceKey and MappingKey pseudo-types
0.17.0¶
- Added support for using typing.Dict and typing.List in multibindings. See
multibind
. - Added multibinding-specific
provider
variant:multiprovider
- Deprecated using
provider
for multibindings - Fixed failure to provide a default value to a NewType-aliased type with auto_bind enabled
- Deprecated
Key
,SequenceKey
andMappingKey
– 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:
0.16.2¶
- (Re)added support for decorating classes themselves with
@inject
. This is the same as decorating their constructors. Among other things this gives us dataclasses integration.
0.16.1¶
- Reuploaded to fix incorrectly formatted project description
0.16.0¶
- 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
Backwards incompatible:
- 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
0.15.0¶
- 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)
0.14.1¶
- Fixed regression that required all noninjectable parameters to be typed
0.14.0¶
- Added NewType support
- Added type hints
Backwards incompatible:
- Passing invalid parameter names to @noninjectable() will now result in an error
- Dropped Python 3.3 support
0.13.4¶
- Deprecated with_injector. There’s no one migration path recommended, it depends on a particular case.
- Deprecated install_into.
0.13.3¶
- 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)
0.13.2¶
- 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 andbind_scope
is a no-op now.
0.13.1¶
- Improved some error messages
0.13.0¶
Backwards incompatible:
- 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
0.12.0¶
- 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.1¶
- 0.11.0 packages uploaded to PyPI are broken (can’t be installed), this is a fix-only release.
0.11.0¶
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): # ...
The
provides()
decorator will be removed in the future.Added a
noninjectable()
decorator to mark parameters as not injectable (this serves as documentation and a way to avoid some runtime errors)
Backwards incompatible:
Removed support for decorating classes with
@inject
. Previously:@inject(something=Something) class Class: pass
Now:
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
AssistedBuilder(callable=...)
Dropped Python 2.6 support
Changed the way
AssistedBuilder
andProviderOf
are 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))
Now:
builder1 = injector.get(AssistedBuilder[Something]) builder2 = injector.get(ClassAssistedBuilder[cls=SomethingElse]) provider = injector.get(ProviderOf[SomeOtherThing])
Removed support for injecting into non-constructor methods
0.10.1¶
- Fixed a false positive bug in dependency cycle detection (AssistedBuilder can be used to break dependency cycles now)
0.10.0¶
injector.Provider.get()
now requires aninjector.Injector
instance as its parameter- deprecated injecting arguments into modules (be it functions/callables,
Module
constructors orinjector.Module.configure()
methods) - removed extends decorator
- few classes got useful __repr__ implementations
- fixed injecting ProviderOf and AssistedBuilders when
injector.Injector
auto_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
0.9.1¶
- Bug fix release.
0.9.0¶
- Child
Injector
can rebind dependancies bound in parent Injector (that changesProvider
semantics), thanks to Ilya Orlov CallableProvider
callables can be injected into, thanks to Ilya Strukov- One can request
ProviderOf
(Interface) and get aBoundProvider
which can be used to get an implementation of Interface when needed
0.8.0¶
- Binding annotations are removed. Use
Key()
to create unique types instead.
0.7.9¶
- Fixed regression with injecting unbound key resulting in None instead of raising an exception
0.7.8¶
- Exception is raised when
Injector
can’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 -
Injector
provides a wrapper that takes care of injecting dependencies into the original function
0.7.7¶
- Made
AssistedBuilder
behave 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(interface=Interface)
).AssistedBuilder(X)
behaviour remains the same, it’s equivalent toAssistedBuilder(interface=X)
0.7.6¶
- Auto-convert README.md to RST for PyPi.
0.7.5¶
- Added a ChangeLog!
- Added support for using Python3 annotations as binding types.