Injector Change Log¶
0.21.0¶
Improved the documentation, thanks to jonathanmach and Jakub Wilk
Fixed a thread-safety regression
Improved the type annotations, thanks to David Pärsson
Fixed singleton scope behavior with parent/child injectors, thanks to David Pärsson
Stopped using a deprecated test function, thanks to ljnsn
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 functionAdded 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 multibindingsFixed 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 insteadDeprecated 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 parameterdeprecated 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 OrlovCallableProvider
callables can be injected into, thanks to Ilya StrukovOne 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__ presenceSome 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.