Injector Change Log — Injector 0.21.0 documentation

# 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 function

- Added new generic types using a draft implementation of PEP 593: `Inject` and `NoInject`. Those serve as additional ways to declare (non)injectable parameters while `inject` won’t go away any time soon `noninjectable` 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` and `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:

- typing.List and typing.Dict specializations are now explicitly disallowed as `bind` interfaces and types returned by `provider`-decorated methods

## 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 and `bind_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` 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))

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

## 0.9.1

- Bug fix release.

## 0.9.0

- 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

## 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 to `AssistedBuilder(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.