Injector Change Log


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


  • 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:


  • 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:
        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
        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):
        def provide_something(self, dependency: Dependency) -> Something:
            # ...

    @provider implies @inject.

    Previously it would look like this:

    class MyModule(Module):
        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:

    class Class:


    class Class:
        def __init__(self, something: Something):
            self.something = something
  • Removed support for injecting partially applied functions, previously:

    def some_function(something):
    class Class:
        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 and ProviderOf 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))


    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.Injector instance as its parameter
  • deprecated injecting arguments into modules (be it functions/callables, Module constructors or injector.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


  • Bug fix release.


  • Child Injector can rebind dependancies bound in parent Injector (that changes Provider semantics), thanks to Ilya Orlov
  • CallableProvider callables can be injected into, thanks to Ilya Strukov
  • One can request ProviderOf (Interface) and get a BoundProvider which 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 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


  • 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 to AssistedBuilder(interface=X)


  • Auto-convert to RST for PyPi.


  • Added a ChangeLog!
  • Added support for using Python3 annotations as binding types.