ets-labs/python-dependency-injector
1
1
Fork 0
mirror of https://github.com/ets-labs/python-dependency-injector.git synced 2025-01-31 03:36:41 +03:00
Code Issues Packages Projects Releases Wiki Activity

Update @inject decorator docs

Browse Source
This commit is contained in:
Roman Mogilatov 2015-11-23 19:26:39 +02:00
parent ec1c488c44
commit 876081fac6
1 changed files with 21 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
docs/advanced_usage/index.rst
View File

@ -7,28 +7,35 @@ Current section of documentation describes advanced usage of
@inject decorator
-----------------
``@di.inject()`` decorator can be used for making *inline* dependency
.. module:: dependency_injector.injections
:py:func:`inject` decorator is a part of
:py:mod:`dependency_injector.injections` module.
:py:func:`inject` decorator can be used for making *inline* dependency
injections. It *patches* decorated callable in such way that dependency
injection will be done during every call of decorated callable.
``di.inject()`` takes a various number of positional and keyword arguments
:py:func:`inject` takes a various number of positional and keyword arguments
that are used as decorated callable injections. Every time, when
``di.inject()`` is called, positional and keyword argument injections would be
passed as an callable arguments.
:py:func:`inject` is called, positional and keyword argument injections would
be passed as an callable arguments.
Such behaviour is very similar to the standard Python ``functools.partial``
object, except of one thing: all injectable values are provided
*"as is"*, except of providers (subclasses of ``di.Provider``). Providers
*"as is"*, except of providers (subclasses of
:py:class:`dependency_injector.providers.Provider`). Providers
will be called every time, when injection needs to be done. For example,
if injectable value of injection is a ``di.Factory``, it will provide new one
if injectable value of injection is a
:py:class:`dependency_injector.providers.Factory`, it will provide new one
instance (as a result of its call) every time, when injection needs to be done.
``di.inject()`` behaviour with context positional and keyword arguments is
:py:func:`inject` behaviour with context positional and keyword arguments is
very like a standard Python ``functools.partial``:
- Positional context arguments will be appended after ``di.inject()``
- Positional context arguments will be appended after :py:func:`inject`
positional injections.
- Keyword context arguments have priority on ``di.inject()`` keyword
- Keyword context arguments have priority on :py:func:`inject` keyword
injections and will be merged over them.
Example:
@ -36,7 +43,7 @@ Example:
.. literalinclude:: ../../examples/advanced_usage/inject_simple.py
:language: python
Example of usage ``@di.inject()`` decorator with Flask:
Example of usage :py:func:`inject` decorator with Flask:
.. literalinclude:: ../../examples/advanced_usage/inject_flask.py
:language: python
@ -45,11 +52,12 @@ Example of usage ``@di.inject()`` decorator with Flask:
@inject decorator with classes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
``@di.inject()`` could be applied for classes. In such case, it will look for
:py:func:`inject` could be applied for classes. In such case, it will look for
class ``__init__()`` method and pass injection to it. If decorated class has
no ``__init__()`` method, appropriate ``di.Error`` will be raised.
no ``__init__()`` method, appropriate
:py:exc:`dependency_injector.errors.Error` will be raised.
Example of usage ``@di.inject()`` with Flask class-based view:
Example of usage :py:func:`inject` with Flask class-based view:
.. literalinclude:: ../../examples/advanced_usage/inject_flask_class_based.py
:language: python