.coveragerc

@@ -0,0 +1,3 @@
+[run]
+include = dependency_injector/*
+omit = tests/*

.deepsource.toml

@@ -1,12 +0,0 @@
-version = 1
-
-test_patterns = ["tests/**/test_*.py"]
-
-exclude_patterns = ["docs/**"]
-
-[[analyzers]]
-name = "python"
-enabled = true
-
-  [analyzers.meta]
-  runtime_version = "3.x.x"

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: rmk135

.github/workflows/publishing.yml

@@ -1,113 +0,0 @@
-name: Publishing
-
-on:
-  workflow_dispatch:
-  push:
-    tags:
-      - '*'
-
-jobs:
-
-  tests:
-    name: Run tests
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.13
-      - run: pip install tox
-      - run: tox
-        env:
-          TOXENV: 3.13
-
-  linters:
-    name: Run linters
-    runs-on: ubuntu-24.04
-    strategy:
-      matrix:
-        toxenv: [flake8, pydocstyle, mypy, pylint]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.13
-      - run: pip install tox
-      - run: tox
-        env:
-          TOXENV: ${{ matrix.toxenv }}
-
-  build-sdist:
-    name: Build source tarball
-    needs: [tests, linters]
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.13
-      - run: |
-          python -m pip install --upgrade build
-          python -m build --sdist
-      - uses: actions/upload-artifact@v4
-        with:
-          name: cibw-sdist
-          path: ./dist/*
-
-  build-wheels:
-    name: Build wheels
-    needs: [tests, linters]
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-24.04, ubuntu-24.04-arm, windows-2019, macos-14]
-    env:
-      CIBW_SKIP: cp27-*
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build wheels
-        uses: pypa/cibuildwheel@v2.20.0
-      - uses: actions/upload-artifact@v4
-        with:
-          name: cibw-wheels-x86-${{ matrix.os }}-${{ strategy.job-index }}
-          path: ./wheelhouse/*.whl
-
-  publish:
-    name: Publish on PyPI
-    needs: [build-sdist, build-wheels]
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: cibw-*
-          path: dist
-          merge-multiple: true
-      - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.PYPI_API_TOKEN }}
-#           For publishing to Test PyPI, uncomment next two lines:
-#          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
-#          repository_url: https://test.pypi.org/legacy/
-
-  publish-docs:
-    name: Publish docs
-    needs: [publish]
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.13
-      - run: pip install awscli
-      - run: pip install -r requirements-doc.txt
-      - run: pip install -e .
-      - run: (cd docs && make clean html)
-      - run: |
-          aws s3 sync docs/_build/html s3://python-dependency-injector-docs --delete
-          aws cloudfront create-invalidation --distribution-id ${{ secrets.AWS_CLOUDFRONT_DISTRIBUTION_ID }} --path "/*" > /dev/null
-          echo "Cache invalidation triggered"
-        env:
-          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          AWS_DEFAULT_REGION: ${{ secrets.AWS_DEFAULT_REGION }}

.github/workflows/tests-and-linters.yml

@@ -1,82 +0,0 @@
-name: Tests and linters
-
-on: [push, pull_request, workflow_dispatch]
-
-jobs:
-
-  tests-on-legacy-versions:
-    name: Run tests on legacy versions
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        python-version: [3.7]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - run: pip install tox
-      - run: tox
-        env:
-          TOXENV: ${{ matrix.python-version }}
-
-  test-on-different-versions:
-    name: Run tests
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: [3.8, 3.9, "3.10", 3.11, 3.12, 3.13]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - run: pip install tox
-      - run: tox
-        env:
-          TOXENV: ${{ matrix.python-version }}
-
-  test-different-pydantic-versions:
-    name: Run tests with different pydantic versions
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: "3.12"
-      - run: pip install tox
-      - run: tox -e pydantic-v1,pydantic-v2
-
-  test-coverage:
-    name: Run tests with coverage
-    runs-on: ubuntu-latest
-    env:
-      DEPENDENCY_INJECTOR_DEBUG_MODE: 1
-      PIP_VERBOSE: 1
-      COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.12
-      - run: pip install tox 'cython>=3,<4'
-      - run: tox -vv
-        env:
-          TOXENV: coveralls
-
-  linters:
-    name: Run linters
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        toxenv: [flake8, pydocstyle, mypy, pylint]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.13
-      - run: pip install tox
-      - run: tox
-        env:
-          TOXENV: ${{ matrix.toxenv }}

.gitignore

@@ -2,6 +2,9 @@
 __pycache__/
 *.py[cod]
 
+# C extensions
+*.so
+
 # Distribution / packaging
 .Python
 env/
@@ -30,13 +33,12 @@ pip-log.txt
 pip-delete-this-directory.txt
 
 # Unit test / coverage reports
-reports/
+htmlcov/
 .tox/
 .coverage
 .cache
 nosetests.xml
 coverage.xml
-.hypothesis/
 
 # Translations
 *.mo
@@ -55,21 +57,13 @@ target/
 .idea/
 
 # Virtualenv
-venv*/
+venv/
 
 # SQLite
 *.db
 
+# JointJS Experiments
+jointjs/
+
 # Vim Rope
 .ropeproject/
-
-# Cython artifacts
-src/**/*.c
-src/**/*.h
-src/**/*.so
-src/**/*.html
-
-# Workspace for samples
-.workspace/
-
-.vscode/

.pylintrc

@@ -0,0 +1,49 @@
+[MASTER]
+
+# Add <file or directory> to the black list. It should be a base name, not a
+# path. You may set this option multiple times.
+ignore=utils,test
+
+[MESSAGES CONTROL]
+
+# Disable the message(s) with the given id(s).
+# disable-msg=
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=5
+
+[TYPECHECK]
+ignore-mixin-members=yes
+# ignored-classes=
+zope=no
+# generated-members=providedBy,implementedBy,rawDataReceived
+
+[DESIGN]
+# Maximum number of arguments for function / method
+max-args=10
+
+# Maximum number of locals for function / method body
+max-locals=20
+
+# Maximum number of return / yield for function / method body
+max-returns=10
+
+# Maximum number of branch for function / method body
+max-branchs=10
+
+# Maximum number of statements in function / method body
+max-statements=60
+
+# Maximum number of parents for a class (see R0901).
+max-parents=10
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=30
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=0
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=30

.travis.yml

@@ -0,0 +1,18 @@
+sudo: false
+language: python
+install: pip install tox
+script: tox
+python:
+  - 3.5
+env:
+  - TOXENV=coveralls
+  - TOXENV=pylint
+  - TOXENV=flake8
+  - TOXENV=pydocstyle
+  - TOXENV=py26
+  - TOXENV=py27
+  - TOXENV=py33
+  - TOXENV=py34
+  - TOXENV=py35
+  - TOXENV=pypy
+  - TOXENV=pypy3

CONTRIBUTORS.rst

@@ -1,24 +1,5 @@
 Dependency Injector Contributors
 ================================
 
-+ Roman Mogylatov (rmk135)
-+ Konstantin vz'One Enchant (sirkonst)
-+ Terrence Brannon (metaperl)
-+ Stanislav Lobanov (asyncee)
-+ James Lafa (jameslafa)
-+ Vlad Ghita (vlad-ghita)
-+ Jeroen Rietveld (jeroenrietveld)
-+ Dmitry Kuzmin (xotonic)
-+ supakeen (supakeen)
-+ Bruno P. Kinoshita (kinow)
-+ RobinsonMa (RobinsonMa)
-+ Rüdiger Busche (JarnoRFB)
-+ Dmitry Rassoshenko (rda-dev)
-+ Fotis Koutoupas (kootoopas)
-+ Shubhendra Singh Chauhan (withshubh)
-+ sonthonaxrk (sonthonaxrk)
-+ Ngo Thanh Loi (Leonn) (loingo95)
-+ Thiago Hiromi (thiromi)
-+ Felipe Rubio (krouw)
-+ Anton Petrov (anton-petrov)
-+ ZipFile (ZipFile)
++ Roman Mogilatov
++ Konstantin vz'One Enchant

LICENSE.rst

@@ -1,4 +1,4 @@
-Copyright (c) 2024, Roman Mogylatov
+Copyright (c) 2015, ETS Labs
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

MANIFEST.in

@@ -1,9 +1,6 @@
-recursive-include src/dependency_injector *.py* *.c
-recursive-include tests *.py
+include dependency_injector/*
 include README.rst
 include CONTRIBUTORS.rst
 include LICENSE.rst
 include requirements.txt
 include setup.py
-include tox.ini
-include py.typed

Makefile

@@ -1,65 +0,0 @@
-VERSION := $(shell python setup.py --version)
-
-export COVERAGE_RCFILE := pyproject.toml
-
-clean:
-	# Clean sources
-	find src -name '*.py[cod]' -delete
-	find src -name '__pycache__' -delete
-	find src -name '*.c' -delete
-	find src -name '*.h' -delete
-	find src -name '*.so' -delete
-	find src -name '*.html' -delete
-	# Clean tests
-	find tests -name '*.py[co]' -delete
-	find tests -name '__pycache__' -delete
-	# Clean examples
-	find examples -name '*.py[co]' -delete
-	find examples -name '__pycache__' -delete
-
-build: clean
-	# Compile C extensions
-	python setup.py build_ext --inplace
-	# Move all Cython html reports
-	mkdir -p reports/cython/
-	find src -name '*.html' -exec mv {}  reports/cython/  \;
-
-docs-live:
-	sphinx-autobuild docs docs/_build/html
-
-install: uninstall clean build
-	pip install -ve .
-
-uninstall:
-	- pip uninstall -y -q dependency-injector 2> /dev/null
-
-test:
-	# Unit tests with coverage report
-	coverage erase
-	coverage run -m pytest -c tests/.configs/pytest.ini
-	coverage report
-	coverage html
-
-check:
-	flake8 src/dependency_injector/
-	flake8 examples/
-
-	pydocstyle src/dependency_injector/
-	pydocstyle examples/
-
-	mypy tests/typing
-
-test-publish: build
-	# Create distributions
-	python -m build --sdist
-	# Upload distributions to PyPI
-	twine upload --repository testpypi dist/dependency-injector-$(VERSION)*
-
-publish:
-	# Merge release to master branch
-	git checkout master
-	git merge --no-ff release/$(VERSION) -m "Merge branch 'release/$(VERSION)' into master"
-	git push origin master
-	# Create and upload tag
-	git tag -a $(VERSION) -m 'version $(VERSION)'
-	git push --tags

README.rst

@@ -1,230 +1,266 @@
-.. figure:: https://raw.githubusercontent.com/wiki/ets-labs/python-dependency-injector/img/logo.svg
-   :target: https://github.com/ets-labs/python-dependency-injector
+====================================================================
+Dependency Injector - Dependency injection microframework for Python
+====================================================================
 
-| 
+*Dependency Injector* is a dependency injection microframework for Python. 
+It was designed to be unified, developer-friendly tool that helps to implement 
+dependency injection pattern in formal, pretty, Pythonic way.
 
-.. image:: https://img.shields.io/pypi/v/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Latest Version
-   
-.. image:: https://img.shields.io/pypi/l/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: License
+*Dependency Injector* framework key features are:
 
-.. image:: https://img.shields.io/pypi/pyversions/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Supported Python versions
-   
-.. image:: https://img.shields.io/pypi/implementation/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Supported Python implementations
++ Easy, smart, pythonic style.
++ Obvious, clear structure.
++ Extensibility and flexibility.
++ Memory efficiency.
++ Thread safety.
++ Documentation.
++ Semantic versioning.
 
-.. image:: https://pepy.tech/badge/dependency-injector
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
+Status
+------
 
-.. image:: https://pepy.tech/badge/dependency-injector/month
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *PyPi*                                | .. image:: https://img.shields.io/pypi/v/dependency_injector.svg                       |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Latest Version                                                                |
+|                                       | .. image:: https://img.shields.io/pypi/l/dependency_injector.svg                       |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: License                                                                       |
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *Python versions and implementations* | .. image:: https://img.shields.io/pypi/pyversions/dependency_injector.svg              |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Supported Python versions                                                     |
+|                                       | .. image:: https://img.shields.io/pypi/implementation/dependency_injector.svg          |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Supported Python implementations                                              |
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *Builds and tests coverage*           | .. image:: https://travis-ci.org/ets-labs/python-dependency-injector.svg?branch=master |
+|                                       |    :target: https://travis-ci.org/ets-labs/python-dependency-injector                  |
+|                                       |    :alt: Build Status                                                                  |
+|                                       | .. image:: https://coveralls.io/repos/ets-labs/python-dependency-injector/badge.svg    |
+|                                       |    :target: https://coveralls.io/r/ets-labs/python-dependency-injector                 |
+|                                       |    :alt: Coverage Status                                                               |
++---------------------------------------+----------------------------------------------------------------------------------------+
 
-.. image:: https://pepy.tech/badge/dependency-injector/week
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
+Dependency injection
+--------------------
 
-.. image:: https://img.shields.io/pypi/wheel/dependency-injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Wheel
+`Dependency injection`_ is a software design pattern that implements 
+`Inversion of control`_ for resolving dependencies. Formally, if object **A** 
+depends on object **B**, object **A** must not create or import object **B** 
+directly. Instead of this object **A** must provide a way for *injecting* 
+object **B**. The responsibilities of objects creation and dependencies 
+injection are delegated to external code - the *dependency injector*. 
 
-.. image:: https://img.shields.io/github/actions/workflow/status/ets-labs/python-dependency-injector/tests-and-linters.yml?branch=master
-   :target: https://github.com/ets-labs/python-dependency-injector/actions
-   :alt: Build Status
+Popular terminology of dependency injection pattern:
 
-.. image:: https://coveralls.io/repos/github/ets-labs/python-dependency-injector/badge.svg?branch=master
-   :target: https://coveralls.io/github/ets-labs/python-dependency-injector?branch=master
-   :alt: Coverage Status
++ Object **A**, that is dependant on object **B**, is often called - 
+  the *client*.
++ Object **B**, that is a dependency, is often called - the *service*.
++ External code that is responsible for creation of objects and injection 
+  of dependencies is often called - the *dependency injector*.
 
-What is ``Dependency Injector``?
-================================
+There are several ways of how *service* can be injected into the *client*: 
 
-``Dependency Injector`` is a dependency injection framework for Python.
++ by passing it as ``__init__`` argument (constructor / initializer injection)
++ by setting it as attribute's value (attribute injection)
++ by passing it as method's argument (method injection)
 
-It helps implement the dependency injection principle.
+Dependency injection pattern has few strict rules that should be followed:
 
-Key features of the ``Dependency Injector``:
++ The *client* delegates to the *dependency injector* the responsibility 
+  of injecting its dependencies - the *service(s)*.
++ The *client* doesn't know how to create the *service*, it knows only 
+  interface of the *service*. The *service* doesn't know that it is used by 
+  the *client*.
++ The *dependency injector* knows how to create the *client* and 
+  the *service*, it also knows that the *client* depends on the *service*, 
+  and knows how to inject the *service* into the *client*.
++ The *client* and the *service* know nothing about the *dependency injector*.
 
-- **Providers**. Provides ``Factory``, ``Singleton``, ``Callable``, ``Coroutine``, ``Object``,
-  ``List``, ``Dict``, ``Configuration``, ``Resource``, ``Dependency``, and ``Selector`` providers
-  that help assemble your objects.
-  See `Providers <https://python-dependency-injector.ets-labs.org/providers/index.html>`_.
-- **Overriding**. Can override any provider by another provider on the fly. This helps in testing
-  and configuring dev/stage environment to replace API clients with stubs etc. See
-  `Provider overriding <https://python-dependency-injector.ets-labs.org/providers/overriding.html>`_.
-- **Configuration**. Reads configuration from ``yaml``, ``ini``, and ``json`` files, ``pydantic`` settings,
-  environment variables, and dictionaries.
-  See `Configuration provider <https://python-dependency-injector.ets-labs.org/providers/configuration.html>`_.
-- **Resources**. Helps with initialization and configuring of logging, event loop, thread
-  or process pool, etc. Can be used for per-function execution scope in tandem with wiring.
-  See `Resource provider <https://python-dependency-injector.ets-labs.org/providers/resource.html>`_.
-- **Containers**. Provides declarative and dynamic containers.
-  See `Containers <https://python-dependency-injector.ets-labs.org/containers/index.html>`_.
-- **Wiring**. Injects dependencies into functions and methods. Helps integrate with
-  other frameworks: Django, Flask, Aiohttp, Sanic, FastAPI, etc.
-  See `Wiring <https://python-dependency-injector.ets-labs.org/wiring.html>`_.
-- **Asynchronous**. Supports asynchronous injections.
-  See `Asynchronous injections <https://python-dependency-injector.ets-labs.org/providers/async.html>`_.
-- **Typing**. Provides typing stubs, ``mypy``-friendly.
-  See `Typing and mypy <https://python-dependency-injector.ets-labs.org/providers/typing_mypy.html>`_.
-- **Performance**. Fast. Written in ``Cython``.
-- **Maturity**. Mature and production-ready. Well-tested, documented, and supported.
+Dependency injection pattern provides next advantages: 
+
++ Control on application structure.
++ Decreased coupling between application components.
++ Increased code reusability.
++ Increased testability.
++ Increased maintainability.
++ Reconfiguration of system without rebuilding.
+
+Example of dependency injection
+-------------------------------
+
+Brief example below demonstrates usage of *Dependency Injector* for creating 
+several IoC containers for some example application:
 
 .. code-block:: python
 
-   from dependency_injector import containers, providers
-   from dependency_injector.wiring import Provide, inject
+    """Example of dependency injection in Python."""
+
+    import logging
+    import sqlite3
+
+    import boto.s3.connection
+
+    import example.main
+    import example.services
+
+    import dependency_injector.containers as containers
+    import dependency_injector.providers as providers
 
 
-   class Container(containers.DeclarativeContainer):
+    class Platform(containers.DeclarativeContainer):
+        """IoC container of platform service providers."""
 
-       config = providers.Configuration()
+        logger = providers.Singleton(logging.Logger, name='example')
 
-       api_client = providers.Singleton(
-           ApiClient,
-           api_key=config.api_key,
-           timeout=config.timeout,
-       )
+        database = providers.Singleton(sqlite3.connect, ':memory:')
 
-       service = providers.Factory(
-           Service,
-           api_client=api_client,
-       )
+        s3 = providers.Singleton(boto.s3.connection.S3Connection,
+                                 aws_access_key_id='KEY',
+                                 aws_secret_access_key='SECRET')
 
 
-   @inject
-   def main(service: Service = Provide[Container.service]) -> None:
-       ...
+    class Services(containers.DeclarativeContainer):
+        """IoC container of business service providers."""
+
+        users = providers.Factory(example.services.Users,
+                                  logger=Platform.logger,
+                                  db=Platform.database)
+
+        auth = providers.Factory(example.services.Auth,
+                                 logger=Platform.logger,
+                                 db=Platform.database,
+                                 token_ttl=3600)
+
+        photos = providers.Factory(example.services.Photos,
+                                   logger=Platform.logger,
+                                   db=Platform.database,
+                                   s3=Platform.s3)
 
 
-   if __name__ == "__main__":
-       container = Container()
-       container.config.api_key.from_env("API_KEY", required=True)
-       container.config.timeout.from_env("TIMEOUT", as_=int, default=5)
-       container.wire(modules=[__name__])
+    class Application(containers.DeclarativeContainer):
+        """IoC container of application component providers."""
 
-       main()  # <-- dependency is injected automatically
+        main = providers.Callable(example.main.main,
+                                  users_service=Services.users,
+                                  auth_service=Services.auth,
+                                  photos_service=Services.photos)
 
-       with container.api_client.override(mock.Mock()):
-           main()  # <-- overridden dependency is injected automatically
+Next example demonstrates run of example application defined above:
 
-When you call the ``main()`` function the ``Service`` dependency is assembled and injected automatically.
+.. code-block:: python
 
-When you do testing, you call the ``container.api_client.override()`` method to replace the real API
-client with a mock. When you call ``main()``, the mock is injected.
+    """Run example application."""
 
-You can override any provider with another provider.
+    import sys
+    import logging
 
-It also helps you in a re-configuring project for different environments: replace an API client
-with a stub on the dev or stage.
+    from containers import Platform, Application
 
-With the ``Dependency Injector``, object assembling is consolidated in a container. Dependency injections are defined explicitly.
-This makes it easier to understand and change how an application works.
 
-.. figure:: https://raw.githubusercontent.com/wiki/ets-labs/python-dependency-injector/img/di-readme.svg
-   :target: https://github.com/ets-labs/python-dependency-injector
+    if __name__ == '__main__':
+        # Configure platform logger:
+        Platform.logger().addHandler(logging.StreamHandler(sys.stdout))
 
-Visit the docs to know more about the
-`Dependency injection and inversion of control in Python <https://python-dependency-injector.ets-labs.org/introduction/di_in_python.html>`_.
+        # Run application:
+        Application.main(uid=sys.argv[1],
+                         password=sys.argv[2],
+                         photo=sys.argv[3])
+
+        # Previous call is an equivalent of next operations:
+        #
+        # logger = logging.Logger(name='example')
+        # database = sqlite3.connect(':memory:')
+        # s3 = boto.s3.connection.S3Connection(aws_access_key_id='KEY',
+        #                                      aws_secret_access_key='SECRET')
+        #
+        # example.main.main(uid=sys.argv[1],
+        #                   password=sys.argv[2],
+        #                   photo=sys.argv[3],
+        #                   users_service=example.services.Users(logger=logger,
+        #                                                        db=database),
+        #                   auth_service=example.services.Auth(logger=logger,
+        #                                                      db=database,
+        #                                                      token_ttl=3600),
+        #                   photos_service=example.services.Photos(logger=logger,
+        #                                                          db=database,
+        #                                                          s3=s3))
+   
+Alternative definition styles of providers
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+*Dependecy Injector* supports few other styles of dependency injections 
+definition.
+
+IoC containers from previous example could look like these:
+
+.. code-block:: python
+
+    class Platform(containers.DeclarativeContainer):
+        """IoC container of platform service providers."""
+
+        logger = providers.Singleton(logging.Logger) \
+            .add_kwargs(name='example')
+
+        database = providers.Singleton(sqlite3.connect) \
+            .add_args(':memory:')
+
+        s3 = providers.Singleton(boto.s3.connection.S3Connection) \
+            .add_kwargs(aws_access_key_id='KEY',
+                        aws_secret_access_key='SECRET')
+
+or like this these:
+
+.. code-block:: python
+
+    class Platform(containers.DeclarativeContainer):
+        """IoC container of platform service providers."""
+
+        logger = providers.Singleton(logging.Logger)
+        logger.add_kwargs(name='example')
+
+        database = providers.Singleton(sqlite3.connect)
+        database.add_args(':memory:')
+
+        s3 = providers.Singleton(boto.s3.connection.S3Connection)
+        s3.add_kwargs(aws_access_key_id='KEY',
+                      aws_secret_access_key='SECRET')
+
+
+You can get more *Dependency Injector* examples in ``/examples`` directory on
+GitHub:
+
+    https://github.com/ets-labs/python-dependency-injector
 
 Installation
 ------------
 
-The package is available on the `PyPi`_::
+*Dependency Injector* library is available on `PyPi`_::
 
-    pip install dependency-injector
+    pip install dependency_injector
 
 Documentation
 -------------
 
-The documentation is available `here <https://python-dependency-injector.ets-labs.org/>`_.
+*Dependency Injector* documentation is hosted on ReadTheDocs:
 
-Examples
---------
+- `User's guide`_ 
+- `API docs`_
 
-Choose one of the following:
+Feedback & Support
+------------------
 
-- `Application example (single container) <https://python-dependency-injector.ets-labs.org/examples/application-single-container.html>`_
-- `Application example (multiple containers) <https://python-dependency-injector.ets-labs.org/examples/application-multiple-containers.html>`_
-- `Decoupled packages example (multiple containers) <https://python-dependency-injector.ets-labs.org/examples/decoupled-packages.html>`_
-- `Boto3 example <https://python-dependency-injector.ets-labs.org/examples/boto3.html>`_
-- `Django example <https://python-dependency-injector.ets-labs.org/examples/django.html>`_
-- `Flask example <https://python-dependency-injector.ets-labs.org/examples/flask.html>`_
-- `Aiohttp example <https://python-dependency-injector.ets-labs.org/examples/aiohttp.html>`_
-- `Sanic example <https://python-dependency-injector.ets-labs.org/examples/sanic.html>`_
-- `FastAPI example <https://python-dependency-injector.ets-labs.org/examples/fastapi.html>`_
-- `FastAPI + Redis example <https://python-dependency-injector.ets-labs.org/examples/fastapi-redis.html>`_
-- `FastAPI + SQLAlchemy example <https://python-dependency-injector.ets-labs.org/examples/fastapi-sqlalchemy.html>`_
+Feel free to post questions, bugs, feature requests, proposals etc. on
+*Dependency Injector*  GitHub Issues:
 
-Tutorials
----------
+    https://github.com/ets-labs/python-dependency-injector/issues
 
-Choose one of the following:
+Your feedback is quite important!
 
-- `Flask web application tutorial <https://python-dependency-injector.ets-labs.org/tutorials/flask.html>`_
-- `Aiohttp REST API tutorial <https://python-dependency-injector.ets-labs.org/tutorials/aiohttp.html>`_
-- `Asyncio monitoring daemon tutorial <https://python-dependency-injector.ets-labs.org/tutorials/asyncio-daemon.html>`_
-- `CLI application tutorial <https://python-dependency-injector.ets-labs.org/tutorials/cli.html>`_
 
-Concept
--------
-
-The framework stands on the `PEP20 (The Zen of Python) <https://www.python.org/dev/peps/pep-0020/>`_ principle:
-
-.. code-block:: bash
-
-   Explicit is better than implicit
-
-You need to specify how to assemble and where to inject the dependencies explicitly.
-
-The power of the framework is in its simplicity.
-``Dependency Injector`` is a simple tool for the powerful concept.
-
-Frequently asked questions
---------------------------
-
-What is dependency injection?
- - dependency injection is a principle that decreases coupling and increases cohesion
-
-Why should I do the dependency injection?
- - your code becomes more flexible, testable, and clear 😎
-
-How do I start applying the dependency injection?
- - you start writing the code following the dependency injection principle
- - you register all of your application components and their dependencies in the container
- - when you need a component, you specify where to inject it or get it from the container
-
-What price do I pay and what do I get?
- - you need to explicitly specify the dependencies
- - it will be extra work in the beginning
- - it will payoff as project grows
-
-Have a question?
- - Open a `Github Issue <https://github.com/ets-labs/python-dependency-injector/issues>`_
-
-Found a bug?
- - Open a `Github Issue <https://github.com/ets-labs/python-dependency-injector/issues>`_
-
-Want to help?
- - |star| Star the ``Dependency Injector`` on the `Github <https://github.com/ets-labs/python-dependency-injector/>`_
- - |new| Start a new project with the ``Dependency Injector``
- - |tell| Tell your friend about the ``Dependency Injector``
-
-Want to contribute?
- - |fork| Fork the project
- - |pull| Open a pull request to the ``develop`` branch
-
-.. _PyPi: https://pypi.org/project/dependency-injector/
-
-.. |star| unicode:: U+2B50 U+FE0F .. star sign1
-.. |new| unicode:: U+1F195 .. new sign
-.. |tell| unicode:: U+1F4AC .. tell sign
-.. |fork| unicode:: U+1F500 .. fork sign
-.. |pull| unicode:: U+2B05 U+FE0F .. pull sign
+.. _Dependency injection: http://en.wikipedia.org/wiki/Dependency_injection
+.. _Inversion of control: https://en.wikipedia.org/wiki/Inversion_of_control
+.. _PyPi: https://pypi.python.org/pypi/dependency_injector
+.. _User's guide: http://python-dependency-injector.ets-labs.org/en/stable/
+.. _API docs: http://python-dependency-injector.ets-labs.org/en/stable/api/

dependency_injector/__init__.py

@@ -0,0 +1,7 @@
+"""Dependency injector top-level package."""
+
+VERSION = '2.2.8'
+"""Version number that follows semantic versioning.
+
+:type: str
+"""

dependency_injector/containers.py

@@ -0,0 +1,363 @@
+"""Dependency injector IoC containers module."""
+
+import six
+
+from dependency_injector import (
+    providers,
+    utils,
+    errors,
+)
+
+
+class DynamicContainer(object):
+    """Dynamic inversion of control container.
+
+    .. code-block:: python
+
+        services = DynamicContainer()
+        services.auth = providers.Factory(AuthService)
+        services.users = providers.Factory(UsersService,
+                                           auth_service=services.auth)
+
+    .. py:attribute:: providers
+
+        Read-only dictionary of all providers.
+
+        :type: dict[str, :py:class:`dependency_injector.providers.Provider`]
+
+    .. py:attribute:: overridden
+
+        Tuple of overriding containers.
+
+        :type: tuple[:py:class:`DynamicContainer`]
+
+    .. py:attribute:: provider_type
+
+        Type of providers that could be placed in container.
+
+        :type: type
+    """
+
+    __IS_CONTAINER__ = True
+
+    def __init__(self):
+        """Initializer.
+
+        :rtype: None
+        """
+        self.provider_type = providers.Provider
+        self.providers = dict()
+        self.overridden = tuple()
+        super(DynamicContainer, self).__init__()
+
+    def __setattr__(self, name, value):
+        """Set instance attribute.
+
+        If value of attribute is provider, it will be added into providers
+        dictionary.
+
+        :param name: Attribute's name
+        :type name: str
+
+        :param value: Attribute's value
+        :type value: object
+
+        :rtype: None
+        """
+        if utils.is_provider(value):
+            _check_provider_type(self, value)
+            self.providers[name] = value
+        super(DynamicContainer, self).__setattr__(name, value)
+
+    def __delattr__(self, name):
+        """Delete instance attribute.
+
+        If value of attribute is provider, it will be deleted from providers
+        dictionary.
+
+        :param name: Attribute's name
+        :type name: str
+
+        :rtype: None
+        """
+        if name in self.providers:
+            del self.providers[name]
+        super(DynamicContainer, self).__delattr__(name)
+
+    def override(self, overriding):
+        """Override current container by overriding container.
+
+        :param overriding: Overriding container.
+        :type overriding: :py:class:`DynamicContainer`
+
+        :raise: :py:exc:`dependency_injector.errors.Error` if trying to
+                override container by itself
+
+        :rtype: None
+        """
+        if overriding is self:
+            raise errors.Error('Container {0} could not be overridden '
+                               'with itself'.format(self))
+
+        self.overridden += (overriding,)
+
+        for name, provider in six.iteritems(overriding.providers):
+            try:
+                getattr(self, name).override(provider)
+            except AttributeError:
+                pass
+
+    def reset_last_overriding(self):
+        """Reset last overriding provider for each container providers.
+
+        :rtype: None
+        """
+        if not self.overridden:
+            raise errors.Error('Container {0} is not overridden'.format(self))
+
+        self.overridden = self.overridden[:-1]
+
+        for provider in six.itervalues(self.providers):
+            provider.reset_last_overriding()
+
+    def reset_override(self):
+        """Reset all overridings for each container providers.
+
+        :rtype: None
+        """
+        self.overridden = tuple()
+
+        for provider in six.itervalues(self.providers):
+            provider.reset_override()
+
+
+class DeclarativeContainerMetaClass(type):
+    """Declarative inversion of control container meta class."""
+
+    def __new__(mcs, class_name, bases, attributes):
+        """Declarative container class factory."""
+        cls_providers = tuple((name, provider)
+                              for name, provider in six.iteritems(attributes)
+                              if utils.is_provider(provider))
+
+        inherited_providers = tuple((name, provider)
+                                    for base in bases if utils.is_container(
+                                        base) and base is not DynamicContainer
+                                    for name, provider in six.iteritems(
+                                        base.cls_providers))
+
+        attributes['cls_providers'] = dict(cls_providers)
+        attributes['inherited_providers'] = dict(inherited_providers)
+        attributes['providers'] = dict(cls_providers + inherited_providers)
+
+        cls = type.__new__(mcs, class_name, bases, attributes)
+
+        for provider in six.itervalues(cls.providers):
+            _check_provider_type(cls, provider)
+
+        return cls
+
+    def __setattr__(cls, name, value):
+        """Set class attribute.
+
+        If value of attribute is provider, it will be added into providers
+        dictionary.
+
+        :param name: Attribute's name
+        :type name: str
+
+        :param value: Attribute's value
+        :type value: object
+
+        :rtype: None
+        """
+        if utils.is_provider(value):
+            _check_provider_type(cls, value)
+            cls.providers[name] = value
+            cls.cls_providers[name] = value
+        super(DeclarativeContainerMetaClass, cls).__setattr__(name, value)
+
+    def __delattr__(cls, name):
+        """Delete class attribute.
+
+        If value of attribute is provider, it will be deleted from providers
+        dictionary.
+
+        :param name: Attribute's name
+        :type name: str
+
+        :rtype: None
+        """
+        if name in cls.providers and name in cls.cls_providers:
+            del cls.providers[name]
+            del cls.cls_providers[name]
+        super(DeclarativeContainerMetaClass, cls).__delattr__(name)
+
+
+@six.add_metaclass(DeclarativeContainerMetaClass)
+class DeclarativeContainer(object):
+    """Declarative inversion of control container.
+
+    .. code-block:: python
+
+        class Services(DeclarativeContainer):
+            auth = providers.Factory(AuthService)
+            users = providers.Factory(UsersService,
+                                      auth_service=auth)
+    """
+
+    __IS_CONTAINER__ = True
+
+    provider_type = providers.Provider
+    """Type of providers that could be placed in container.
+
+    :type: type
+    """
+
+    instance_type = DynamicContainer
+    """Type of container that is returned on instantiating declarative
+    container.
+
+    :type: type
+    """
+
+    providers = dict()
+    """Read-only dictionary of all providers.
+
+    :type: dict[str, :py:class:`dependency_injector.providers.Provider`]
+    """
+
+    cls_providers = dict()
+    """Read-only dictionary of current container providers.
+
+    :type: dict[str, :py:class:`dependency_injector.providers.Provider`]
+    """
+
+    inherited_providers = dict()
+    """Read-only dictionary of inherited providers.
+
+    :type: dict[str, :py:class:`dependency_injector.providers.Provider`]
+    """
+
+    overridden = tuple()
+    """Tuple of overriding containers.
+
+    :type: tuple[:py:class:`DeclarativeContainer`]
+    """
+
+    def __new__(cls, *args, **kwargs):
+        """Constructor.
+
+        :return: Dynamic container with copy of all providers.
+        :rtype: :py:class:`DynamicContainer`
+        """
+        container = cls.instance_type(*args, **kwargs)
+        container.provider_type = cls.provider_type
+
+        for name, provider in six.iteritems(utils.deepcopy(cls.providers)):
+            setattr(container, name, provider)
+
+        return container
+
+    @classmethod
+    def override(cls, overriding):
+        """Override current container by overriding container.
+
+        :param overriding: Overriding container.
+        :type overriding: :py:class:`DeclarativeContainer`
+
+        :raise: :py:exc:`dependency_injector.errors.Error` if trying to
+                override container by itself or its subclasses
+
+        :rtype: None
+        """
+        if issubclass(cls, overriding):
+            raise errors.Error('Container {0} could not be overridden '
+                               'with itself or its subclasses'.format(cls))
+
+        cls.overridden += (overriding,)
+
+        for name, provider in six.iteritems(overriding.cls_providers):
+            try:
+                getattr(cls, name).override(provider)
+            except AttributeError:
+                pass
+
+    @classmethod
+    def reset_last_overriding(cls):
+        """Reset last overriding provider for each container providers.
+
+        :rtype: None
+        """
+        if not cls.overridden:
+            raise errors.Error('Container {0} is not overridden'.format(cls))
+
+        cls.overridden = cls.overridden[:-1]
+
+        for provider in six.itervalues(cls.providers):
+            provider.reset_last_overriding()
+
+    @classmethod
+    def reset_override(cls):
+        """Reset all overridings for each container providers.
+
+        :rtype: None
+        """
+        cls.overridden = tuple()
+
+        for provider in six.itervalues(cls.providers):
+            provider.reset_override()
+
+
+def override(container):
+    """:py:class:`DeclarativeContainer` overriding decorator.
+
+    :param container: Container that should be overridden by decorated
+                      container.
+    :type container: :py:class:`DeclarativeContainer`
+
+    :return: Declarative container's overriding decorator.
+    :rtype: callable(:py:class:`DeclarativeContainer`)
+    """
+    def _decorator(overriding_container):
+        """Overriding decorator."""
+        container.override(overriding_container)
+        return overriding_container
+    return _decorator
+
+
+def copy(container):
+    """:py:class:`DeclarativeContainer` copying decorator.
+
+    This decorator copy all providers from provided container to decorated one.
+    If one of the decorated container providers matches to source container
+    providers by name, it would be replaced by reference.
+
+    :param container: Container that should be copied by decorated container.
+    :type container: :py:class:`DeclarativeContainer`
+
+    :return: Declarative container's copying decorator.
+    :rtype: callable(:py:class:`DeclarativeContainer`)
+    """
+    def _decorator(copied_container):
+        memo = dict()
+        for name, provider in six.iteritems(copied_container.cls_providers):
+            try:
+                source_provider = getattr(container, name)
+            except AttributeError:
+                pass
+            else:
+                memo[id(source_provider)] = provider
+
+        providers_copy = utils.deepcopy(container.providers, memo)
+        for name, provider in six.iteritems(providers_copy):
+            setattr(copied_container, name, provider)
+
+        return copied_container
+    return _decorator
+
+
+def _check_provider_type(cls, provider):
+    if not isinstance(provider, cls.provider_type):
+        raise errors.Error('{0} can contain only {1} '
+                           'instances'.format(cls, cls.provider_type))

dependency_injector/errors.py

@@ -0,0 +1,8 @@
+"""Dependency injector errors module."""
+
+
+class Error(Exception):
+    """Base error.
+
+    All dependency injector errors extend this error class.
+    """

dependency_injector/injections.py

@@ -0,0 +1,113 @@
+"""Dependency injector injections module."""
+
+import warnings
+
+import six
+
+from dependency_injector.providers.base import (
+    _parse_positional_injections,
+    _parse_keyword_injections,
+)
+from dependency_injector import utils
+from dependency_injector import errors
+
+
+def inject(*args, **kwargs):
+    """Dependency injection decorator.
+
+    .. warning::
+
+        :py:func:`inject` decorator has been deprecated since version 2.2.0.
+
+        Usage of :py:func:`inject` decorator can lead to bad design and could
+        be considered as anti-pattern.
+
+    :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.
+
+    :py:func:`inject` decorator supports different syntaxes of passing
+    injections:
+
+    .. code-block:: python
+
+        # Positional arguments injections:
+        @inject(1, 2)
+        def some_function(arg1, arg2):
+            pass
+
+        # Keyword arguments injections:
+        @inject(arg1=1)
+        @inject(arg2=2)
+        def some_function(arg1, arg2):
+            pass
+
+        # Keyword arguments injections into class init:
+        @inject(arg1=1)
+        @inject(arg2=2)
+        class SomeClass(object):
+
+            def __init__(self, arg1, arg2):
+                pass
+
+    .. deprecated:: 2.2.0
+        Usage of :py:func:`inject` decorator can lead to bad design and could
+        be considered as anti-pattern.
+
+    :param args: Tuple of context positional arguments.
+    :type args: tuple[object]
+
+    :param kwargs: Dictionary of context keyword arguments.
+    :type kwargs: dict[str, object]
+
+    :return: Class / callable decorator
+    :rtype: (callable) -> (type | callable)
+    """
+    warnings.warn(message='Call to a deprecated decorator - @{0}.{1}'
+                          .format(inject.__module__, inject.__name__),
+                  category=DeprecationWarning,
+                  stacklevel=2)
+
+    arg_injections = _parse_positional_injections(args)
+    kwarg_injections = _parse_keyword_injections(kwargs)
+
+    def decorator(callback_or_cls):
+        """Dependency injection decorator."""
+        if isinstance(callback_or_cls, six.class_types):
+            cls = callback_or_cls
+            cls_init = utils.fetch_cls_init(cls)
+            if not cls_init:
+                raise errors.Error(
+                    'Class {0}.{1} has no __init__() '.format(cls.__module__,
+                                                              cls.__name__) +
+                    'method and could not be decorated with @inject decorator')
+            cls.__init__ = decorator(cls_init)
+            return cls
+
+        callback = callback_or_cls
+
+        if hasattr(callback, '__INJECT_DECORATED__'):
+            callback.args += arg_injections
+            callback.kwargs.update(kwarg_injections)
+            return callback
+
+        @six.wraps(callback)
+        def decorated(*args, **kwargs):
+            """Decorated with dependency injection callback."""
+            if decorated.args:
+                args = tuple(arg.provide_injection()
+                             for arg in decorated.args) + args
+
+            for name, arg in six.iteritems(decorated.kwargs):
+                if name not in kwargs:
+                    kwargs[name] = arg.provide_injection()
+
+            return callback(*args, **kwargs)
+
+        decorated.__INJECT_DECORATED__ = True
+        decorated.origin = callback
+        decorated.args = arg_injections
+        decorated.kwargs = kwarg_injections
+
+        return decorated
+    return decorator

dependency_injector/providers/__init__.py

@@ -0,0 +1,45 @@
+"""Dependency injector providers package."""
+
+from dependency_injector.providers.base import (
+    Provider,
+    Delegate,
+    Object,
+    ExternalDependency,
+    OverridingContext,
+    override,
+)
+from dependency_injector.providers.callable import (
+    Callable,
+    DelegatedCallable,
+)
+from dependency_injector.providers.creational import (
+    Factory,
+    DelegatedFactory,
+    Singleton,
+    DelegatedSingleton,
+    ThreadLocalSingleton,
+    DelegatedThreadLocalSingleton
+)
+
+
+__all__ = (
+    'Provider',
+    'Delegate',
+    'Object',
+    'ExternalDependency',
+
+    'OverridingContext',
+    'override',
+
+    'Callable',
+    'DelegatedCallable',
+
+    'Factory',
+    'DelegatedFactory',
+
+    'Singleton',
+    'DelegatedSingleton',
+
+    'ThreadLocalSingleton',
+    'DelegatedThreadLocalSingleton',
+)

dependency_injector/providers/base.py

@@ -0,0 +1,416 @@
+"""Dependency injector base providers."""
+
+import six
+
+from dependency_injector.errors import Error
+from dependency_injector.utils import (
+    is_provider,
+    ensure_is_provider,
+    represent_provider,
+)
+
+
+@six.python_2_unicode_compatible
+class Provider(object):
+    """Base provider class.
+
+    :py:class:`Provider` is callable (implements ``__call__`` method). Every
+    call to provider object returns provided result, according to the providing
+    strategy of particular provider. This ``callable`` functionality is a
+    regular part of providers API and it should be the same for all provider's
+    subclasses.
+
+    Implementation of particular providing strategy should be done in
+    :py:meth:`Provider._provide` of :py:class:`Provider` subclass. Current
+    method is called every time when not overridden provider is called.
+
+    :py:class:`Provider` implements provider overriding logic that should be
+    also common for all providers:
+
+    .. code-block:: python
+
+        provider1 = Factory(SomeClass)
+        provider2 = Factory(ChildSomeClass)
+
+        provider1.override(provider2)
+
+        some_instance = provider1()
+        assert isinstance(some_instance, ChildSomeClass)
+
+    Also :py:class:`Provider` implements helper function for creating its
+    delegates:
+
+    .. code-block:: python
+
+        provider = Factory(object)
+        delegate = provider.delegate()
+
+        delegated = delegate()
+
+        assert provider is delegated
+
+    All providers should extend this class.
+
+    .. py:attribute:: overridden
+
+        Tuple of overriding providers, if any.
+
+        :type: tuple[:py:class:`Provider`] | None
+    """
+
+    __IS_PROVIDER__ = True
+    __OPTIMIZED_CALLS__ = True
+    __slots__ = ('overridden', 'provide', '__call__')
+
+    def __init__(self):
+        """Initializer."""
+        self.overridden = tuple()
+        super(Provider, self).__init__()
+        # Enable __call__() / _provide() optimization
+        if self.__class__.__OPTIMIZED_CALLS__:
+            self.__call__ = self.provide = self._provide
+
+    def _provide(self, *args, **kwargs):
+        """Providing strategy implementation.
+
+        Abstract protected method that implements providing strategy of
+        particular provider. Current method is called every time when not
+        overridden provider is called. Need to be overridden in subclasses.
+        """
+        raise NotImplementedError()
+
+    def _call_last_overriding(self, *args, **kwargs):
+        """Call last overriding provider and return result."""
+        return (self.overridden[-1](*args, **kwargs)
+                if self.overridden
+                else None)
+
+    def provide_injection(self):
+        """Injection strategy implementation.
+
+        :rtype: object
+        """
+        return self.provide()
+
+    def override(self, provider):
+        """Override provider with another provider.
+
+        :param provider: Overriding provider.
+        :type provider: :py:class:`Provider`
+
+        :raise: :py:exc:`dependency_injector.errors.Error`
+
+        :return: Overriding provider.
+        :rtype: :py:class:`Provider`
+        """
+        if provider is self:
+            raise Error('Provider {0} could not be overridden '
+                        'with itself'.format(self))
+
+        if not is_provider(provider):
+            provider = Object(provider)
+
+        self.overridden += (ensure_is_provider(provider),)
+
+        # Disable __call__() / _provide() optimization
+        if self.__class__.__OPTIMIZED_CALLS__:
+            self.__call__ = self.provide = self._call_last_overriding
+
+        return OverridingContext(self, provider)
+
+    def reset_last_overriding(self):
+        """Reset last overriding provider.
+
+        :raise: :py:exc:`dependency_injector.errors.Error` if provider is not
+                overridden.
+
+        :rtype: None
+        """
+        if not self.overridden:
+            raise Error('Provider {0} is not overridden'.format(str(self)))
+
+        self.overridden = self.overridden[:-1]
+
+        if not self.overridden:
+            # Enable __call__() / _provide() optimization
+            if self.__class__.__OPTIMIZED_CALLS__:
+                self.__call__ = self.provide = self._provide
+
+    def reset_override(self):
+        """Reset all overriding providers.
+
+        :rtype: None
+        """
+        self.overridden = tuple()
+
+        # Enable __call__() / _provide() optimization
+        if self.__class__.__OPTIMIZED_CALLS__:
+            self.__call__ = self.provide = self._provide
+
+    def delegate(self):
+        """Return provider's delegate.
+
+        :rtype: :py:class:`Delegate`
+        """
+        return Delegate(self)
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+        return represent_provider(provider=self, provides=None)
+
+    __repr__ = __str__
+
+
+@six.python_2_unicode_compatible
+class Delegate(Provider):
+    """:py:class:`Delegate` provider delegates another provider.
+
+    .. code-block:: python
+
+        provider = Factory(object)
+        delegate = Delegate(provider)
+
+        delegated = delegate()
+
+        assert provider is delegated
+
+    .. py:attribute:: delegated
+
+        Delegated provider.
+
+        :type: :py:class:`Provider`
+    """
+
+    __slots__ = ('delegated',)
+
+    def __init__(self, delegated):
+        """Initializer.
+
+        :provider delegated: Delegated provider.
+        :type delegated: :py:class:`Provider`
+        """
+        self.delegated = ensure_is_provider(delegated)
+        super(Delegate, self).__init__()
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        return self.delegated
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+        return represent_provider(provider=self, provides=self.delegated)
+
+    __repr__ = __str__
+
+
+@six.python_2_unicode_compatible
+class Object(Provider):
+    """:py:class:`Object` provider returns provided instance "as is".
+
+    .. py:attribute:: provides
+
+        Value that have to be provided.
+
+        :type: object
+    """
+
+    __slots__ = ('provides',)
+
+    def __init__(self, provides):
+        """Initializer.
+
+        :param provides: Value that have to be provided.
+        :type provides: object
+        """
+        self.provides = provides
+        super(Object, self).__init__()
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        return self.provides
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+        return represent_provider(provider=self, provides=self.provides)
+
+    __repr__ = __str__
+
+
+@six.python_2_unicode_compatible
+class ExternalDependency(Provider):
+    """:py:class:`ExternalDependency` provider describes dependency interface.
+
+    This provider is used for description of dependency interface. That might
+    be useful when dependency could be provided in the client's code only,
+    but it's interface is known. Such situations could happen when required
+    dependency has non-determenistic list of dependencies itself.
+
+    .. code-block:: python
+
+        database_provider = ExternalDependency(sqlite3.dbapi2.Connection)
+        database_provider.override(Factory(sqlite3.connect, ':memory:'))
+
+        database = database_provider()
+
+    .. py:attribute:: instance_of
+
+        Class of required dependency.
+
+        :type: type
+    """
+
+    __OPTIMIZED_CALLS__ = False
+    __slots__ = ('instance_of',)
+
+    def __init__(self, instance_of):
+        """Initializer."""
+        if not isinstance(instance_of, six.class_types):
+            raise Error('ExternalDependency provider expects to get class, ' +
+                        'got {0} instead'.format(str(instance_of)))
+        self.instance_of = instance_of
+        self.provide = self.__call__
+        super(ExternalDependency, self).__init__()
+
+    def __call__(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :raise: :py:exc:`dependency_injector.errors.Error`
+
+        :rtype: object
+        """
+        if not self.overridden:
+            raise Error('Dependency is not defined')
+
+        instance = self._call_last_overriding(*args, **kwargs)
+
+        if not isinstance(instance, self.instance_of):
+            raise Error('{0} is not an '.format(instance) +
+                        'instance of {0}'.format(self.instance_of))
+
+        return instance
+
+    def provided_by(self, provider):
+        """Set external dependency provider.
+
+        :param provider: Provider that provides required dependency.
+        :type provider: :py:class:`Provider`
+
+        :rtype: None
+        """
+        return self.override(provider)
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+        return represent_provider(provider=self, provides=self.instance_of)
+
+    __repr__ = __str__
+
+
+class OverridingContext(object):
+    """Provider overriding context.
+
+    :py:class:`OverridingContext` is used by :py:meth:`Provider.override` for
+    implemeting ``with`` contexts. When :py:class:`OverridingContext` is
+    closed, overriding that was created in this context is dropped also.
+
+    .. code-block:: python
+
+        with provider.override(another_provider):
+            assert provider.overridden
+        assert not provider.overridden
+    """
+
+    def __init__(self, overridden, overriding):
+        """Initializer.
+
+        :param overridden: Overridden provider.
+        :type overridden: :py:class:`Provider`
+
+        :param overriding: Overriding provider.
+        :type overriding: :py:class:`Provider`
+        """
+        self.overridden = overridden
+        self.overriding = overriding
+
+    def __enter__(self):
+        """Do nothing."""
+        return self.overriding
+
+    def __exit__(self, *_):
+        """Exit overriding context."""
+        self.overridden.reset_last_overriding()
+
+
+def override(overridden):
+    """Decorator for overriding providers.
+
+    This decorator overrides ``overridden`` provider by decorated one.
+
+    .. code-block:: python
+
+        @Factory
+        class SomeClass(object):
+            pass
+
+
+        @override(SomeClass)
+        @Factory
+        class ExtendedSomeClass(SomeClass.cls):
+            pass
+
+    :param overridden: Provider that should be overridden.
+    :type overridden: :py:class:`Provider`
+
+    :return: Overriding provider.
+    :rtype: :py:class:`Provider`
+    """
+    def decorator(overriding):
+        overridden.override(overriding)
+        return overriding
+    return decorator
+
+
+def _parse_positional_injections(args):
+    return tuple(arg if is_provider(arg) else Object(arg)
+                 for arg in args)
+
+
+def _parse_keyword_injections(kwargs):
+    return dict((name, arg if is_provider(arg) else Object(arg))
+                for name, arg in six.iteritems(kwargs))

dependency_injector/providers/callable.py

@@ -0,0 +1,127 @@
+"""Dependency injector callable providers."""
+
+import six
+
+from dependency_injector.providers.base import (
+    Provider,
+    _parse_positional_injections,
+    _parse_keyword_injections,
+)
+from dependency_injector.utils import represent_provider
+from dependency_injector.errors import Error
+
+
+@six.python_2_unicode_compatible
+class Callable(Provider):
+    r""":py:class:`Callable` provider calls wrapped callable on every call.
+
+    :py:class:`Callable` supports positional and keyword argument injections:
+
+    .. code-block:: python
+
+        some_function = Callable(some_function,
+                                 'positional_arg1', 'positional_arg2',
+                                 keyword_argument1=3, keyword_argument=4)
+
+        # or
+
+        some_function = Callable(some_function) \
+            .add_args('positional_arg1', 'positional_arg2') \
+            .add_kwargs(keyword_argument1=3, keyword_argument=4)
+
+        # or
+
+        some_function = Callable(some_function)
+        some_function.add_args('positional_arg1', 'positional_arg2')
+        some_function.add_kwargs(keyword_argument1=3, keyword_argument=4)
+    """
+
+    __slots__ = ('provides', 'args', 'kwargs')
+
+    def __init__(self, provides, *args, **kwargs):
+        """Initializer.
+
+        :param provides: Wrapped callable.
+        :type provides: callable
+        """
+        if not callable(provides):
+            raise Error('Provider {0} expected to get callable, '
+                        'got {0}'.format('.'.join((self.__class__.__module__,
+                                                   self.__class__.__name__)),
+                                         provides))
+
+        self.provides = provides
+
+        self.args = tuple()
+        self.kwargs = dict()
+
+        self.add_args(*args)
+        self.add_kwargs(**kwargs)
+
+        super(Callable, self).__init__()
+
+    def add_args(self, *args):
+        """Add postional argument injections.
+
+        :param args: Tuple of injections.
+        :type args: tuple
+
+        :return: Reference ``self``
+        """
+        self.args += _parse_positional_injections(args)
+        return self
+
+    def add_kwargs(self, **kwargs):
+        """Add keyword argument injections.
+
+        :param kwargs: Dictionary of injections.
+        :type kwargs: dict
+
+        :return: Reference ``self``
+        """
+        self.kwargs.update(_parse_keyword_injections(kwargs))
+        return self
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        if self.args:
+            args = tuple(arg.provide_injection() for arg in self.args) + args
+
+        for name, arg in six.iteritems(self.kwargs):
+            if name not in kwargs:
+                kwargs[name] = arg.provide_injection()
+
+        return self.provides(*args, **kwargs)
+
+    def __str__(self):
+        """Return string representation of provider.
+
+        :rtype: str
+        """
+        return represent_provider(provider=self, provides=self.provides)
+
+    __repr__ = __str__
+
+
+class DelegatedCallable(Callable):
+    """:py:class:`DelegatedCallable` is a delegated :py:class:`Callable`.
+
+    :py:class:`DelegatedCallable` is a :py:class:`Callable`, that is injected
+    "as is".
+    """
+
+    def provide_injection(self):
+        """Injection strategy implementation.
+
+        :rtype: object
+        """
+        return self

dependency_injector/providers/creational.py

@@ -0,0 +1,342 @@
+"""Dependency injector creational providers."""
+
+import threading
+
+import six
+
+from dependency_injector.providers.callable import Callable
+from dependency_injector.providers.base import _parse_keyword_injections
+from dependency_injector.utils import GLOBAL_LOCK
+from dependency_injector.errors import Error
+
+
+class Factory(Callable):
+    r""":py:class:`Factory` provider creates new instance on every call.
+
+    :py:class:`Factory` supports positional & keyword argument injections,
+    as well as attribute injections.
+
+    Positional and keyword argument injections could be defined like this:
+
+    .. code-block:: python
+
+        factory = Factory(SomeClass,
+                          'positional_arg1', 'positional_arg2',
+                          keyword_argument1=3, keyword_argument=4)
+
+        # or
+
+        factory = Factory(SomeClass) \
+            .add_args('positional_arg1', 'positional_arg2') \
+            .add_kwargs(keyword_argument1=3, keyword_argument=4)
+
+        # or
+
+        factory = Factory(SomeClass)
+        factory.add_args('positional_arg1', 'positional_arg2')
+        factory.add_kwargs(keyword_argument1=3, keyword_argument=4)
+
+
+    Attribute injections are defined by using :py:meth:`Factory.attributes`:
+
+    .. code-block:: python
+
+        factory = Factory(SomeClass) \
+            .add_attributes(attribute1=1, attribute2=2)
+
+    Retrieving of provided instance can be performed via calling
+    :py:class:`Factory` object:
+
+    .. code-block:: python
+
+        factory = Factory(SomeClass)
+        some_object = factory()
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    provided_type = None
+
+    __slots__ = ('cls', 'attributes')
+
+    def __init__(self, provides, *args, **kwargs):
+        """Initializer.
+
+        :param provides: Class or other callable that provides object
+            for creation.
+        :type provides: type | callable
+        """
+        if (self.__class__.provided_type and
+                not issubclass(provides, self.__class__.provided_type)):
+            raise Error('{0} can provide only {1} instances'.format(
+                self.__class__, self.__class__.provided_type))
+
+        self.attributes = dict()
+
+        super(Factory, self).__init__(provides, *args, **kwargs)
+
+        self.cls = self.provides
+
+    def add_attributes(self, **kwargs):
+        """Add attribute injections.
+
+        :param kwargs: Dictionary of injections.
+        :type kwargs: dict
+
+        :return: Reference ``self``
+        """
+        self.attributes.update(_parse_keyword_injections(kwargs))
+        return self
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        instance = super(Factory, self)._provide(*args, **kwargs)
+
+        for name, arg in six.iteritems(self.attributes):
+            setattr(instance, name, arg.provide_injection())
+
+        return instance
+
+
+class DelegatedFactory(Factory):
+    """:py:class:`Factory` that is injected "as is".
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    def provide_injection(self):
+        """Injection strategy implementation.
+
+        :rtype: object
+        """
+        return self
+
+
+class Singleton(Factory):
+    """:py:class:`Singleton` provider returns same instance on every call.
+
+    :py:class:`Singleton` provider creates instance once and returns it on
+    every call. :py:class:`Singleton` extends :py:class:`Factory`, so, please
+    follow :py:class:`Factory` documentation for getting familiar with
+    injections syntax.
+
+    :py:class:`Singleton` is thread-safe and could be used in multithreading
+    environment without any negative impact.
+
+    Retrieving of provided instance can be performed via calling
+    :py:class:`Singleton` object:
+
+    .. code-block:: python
+
+        singleton = Singleton(SomeClass)
+        some_object = singleton()
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    __slots__ = ('instance',)
+
+    def __init__(self, provides, *args, **kwargs):
+        """Initializer.
+
+        :param provides: Class or other callable that provides object
+            for creation.
+        :type provides: type | callable
+        """
+        self.instance = None
+        super(Singleton, self).__init__(provides, *args, **kwargs)
+
+    def reset(self):
+        """Reset cached instance, if any.
+
+        :rtype: None
+        """
+        self.instance = None
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        with GLOBAL_LOCK:
+            if self.instance is None:
+                self.instance = super(Singleton, self)._provide(*args,
+                                                                **kwargs)
+        return self.instance
+
+
+class DelegatedSingleton(Singleton):
+    """:py:class:`Singleton` that is injected "as is".
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    def provide_injection(self):
+        """Injection strategy implementation.
+
+        :rtype: object
+        """
+        return self
+
+
+class ThreadLocalSingleton(Factory):
+    """:py:class:`ThreadLocalSingleton` is singleton based on thread locals.
+
+    :py:class:`ThreadLocalSingleton` provider creates instance once for each
+    thread and returns it on every call. :py:class:`ThreadLocalSingleton`
+    extends :py:class:`Factory`, so, please follow :py:class:`Factory`
+    documentation for getting familiar with injections syntax.
+
+    :py:class:`ThreadLocalSingleton` is thread-safe and could be used in
+    multithreading environment without any negative impact.
+
+    Retrieving of provided instance can be performed via calling
+    :py:class:`ThreadLocalSingleton` object:
+
+    .. code-block:: python
+
+        singleton = ThreadLocalSingleton(SomeClass)
+        some_object = singleton()
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    __slots__ = ('local_storage',)
+
+    def __init__(self, provides, *args, **kwargs):
+        """Initializer.
+
+        :param provides: Class or other callable that provides object
+            for creation.
+        :type provides: type | callable
+        """
+        self.local_storage = threading.local()
+        super(ThreadLocalSingleton, self).__init__(provides, *args, **kwargs)
+
+    def reset(self):
+        """Reset cached instance, if any.
+
+        :rtype: None
+        """
+        self.local_storage.instance = None
+
+    def _provide(self, *args, **kwargs):
+        """Return provided instance.
+
+        :param args: Tuple of context positional arguments.
+        :type args: tuple[object]
+
+        :param kwargs: Dictionary of context keyword arguments.
+        :type kwargs: dict[str, object]
+
+        :rtype: object
+        """
+        try:
+            instance = self.local_storage.instance
+        except AttributeError:
+            instance = super(ThreadLocalSingleton, self)._provide(*args,
+                                                                  **kwargs)
+            self.local_storage.instance = instance
+        finally:
+            return instance
+
+
+class DelegatedThreadLocalSingleton(ThreadLocalSingleton):
+    """:py:class:`ThreadLocalSingleton` that is injected "as is".
+
+    .. py:attribute:: provided_type
+
+        If provided type is defined, provider checks that providing class is
+        its subclass.
+
+        :type: type | None
+
+    .. py:attribute:: cls
+
+        Class that provides object.
+        Alias for :py:attr:`provides`.
+
+        :type: type
+    """
+
+    def provide_injection(self):
+        """Injection strategy implementation.
+
+        :rtype: object
+        """
+        return self

dependency_injector/utils.py

@@ -0,0 +1,113 @@
+"""Dependency injector utils module."""
+
+import sys
+import copy as _copy
+import types
+import threading
+
+import six
+
+from dependency_injector import errors
+
+
+GLOBAL_LOCK = threading.RLock()
+"""Dependency injector global reentrant lock.
+
+:type: :py:class:`threading.RLock`
+"""
+
+_IS_PYPY = '__pypy__' in sys.builtin_module_names
+if _IS_PYPY or six.PY3:  # pragma: no cover
+    _OBJECT_INIT = six.get_unbound_function(object.__init__)
+else:  # pragma: no cover
+    _OBJECT_INIT = None
+
+if six.PY2:  # pragma: no cover
+    _copy._deepcopy_dispatch[types.MethodType] = \
+        lambda obj, memo: type(obj)(obj.im_func,
+                                    _copy.deepcopy(obj.im_self, memo),
+                                    obj.im_class)
+
+
+def is_provider(instance):
+    """Check if instance is provider instance.
+
+    :param instance: Instance to be checked.
+    :type instance: object
+
+    :rtype: bool
+    """
+    return (not isinstance(instance, six.class_types) and
+            hasattr(instance, '__IS_PROVIDER__') and
+            getattr(instance, '__IS_PROVIDER__') is True)
+
+
+def ensure_is_provider(instance):
+    """Check if instance is provider instance and return it.
+
+    :param instance: Instance to be checked.
+    :type instance: object
+
+    :raise: :py:exc:`dependency_injector.errors.Error` if provided instance is
+            not provider.
+
+    :rtype: :py:class:`dependency_injector.providers.Provider`
+    """
+    if not is_provider(instance):
+        raise errors.Error('Expected provider instance, '
+                           'got {0}'.format(str(instance)))
+    return instance
+
+
+def is_container(instance):
+    """Check if instance is container instance.
+
+    :param instance: Instance to be checked.
+    :type instance: object
+
+    :rtype: bool
+    """
+    return (hasattr(instance, '__IS_CONTAINER__') and
+            getattr(instance, '__IS_CONTAINER__', False) is True)
+
+
+def represent_provider(provider, provides):
+    """Return string representation of provider.
+
+    :param provider: Provider object
+    :type provider: :py:class:`dependency_injector.providers.Provider`
+
+    :param provides: Object that provider provides
+    :type provider: object
+
+    :return: String representation of provider
+    :rtype: str
+    """
+    return '<{provider}({provides}) at {address}>'.format(
+        provider='.'.join((provider.__class__.__module__,
+                           provider.__class__.__name__)),
+        provides=repr(provides) if provides is not None else '',
+        address=hex(id(provider)))
+
+
+def fetch_cls_init(cls):
+    """Return reference to the class.__init__() method if it is defined.
+
+    :param cls: Class instance
+    :type cls: type
+
+    :return: Reference to the class.__init__() if any, or None otherwise.
+    :rtype: unbound method | None
+    """
+    try:
+        cls_init = six.get_unbound_function(cls.__init__)
+        assert cls_init is not _OBJECT_INIT
+    except (AttributeError, AssertionError):
+        return None
+    else:
+        return cls_init
+
+
+def deepcopy(instance, memo=None):
+    """Make full copy of instance."""
+    return _copy.deepcopy(instance, memo)

docs/_static/custom.css

@@ -1,9 +0,0 @@
-.no-border {
-    border: 0 !important;
-    box-shadow: none !important;
-    -webkit-box-shadow: none !important;
-}
-.no-border td {
-    border: 0px !important;
-    padding: 0px 10px 0px 0px !important;
-}

docs/_static/sponsor.html

@@ -1 +0,0 @@
-<iframe src="https://github.com/sponsors/rmk135/button" title="Sponsor Dependency Injector" height="32" width="114" style="border: 0; border-radius: 6px;"></iframe>

docs/advanced_usage/index.rst

@@ -0,0 +1,70 @@
+Advanced usage
+==============
+
+Current section of documentation describes advanced usage of 
+*Dependency Injector*.
+
+@inject decorator
+-----------------
+
+.. currentmodule:: dependency_injector.injections
+
+.. warning::
+
+    :py:func:`inject` decorator has been deprecated since version 2.2.0.
+
+: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.
+
+:py:func:`inject` takes a various number of positional and keyword arguments 
+that are used as decorated callable injections. Every time, when 
+: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 
+: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 
+: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.
+
+: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 :py:func:`inject` 
+  positional injections.
+- Keyword context arguments have priority on :py:func:`inject` keyword 
+  injections and will be merged over them.
+
+Example:
+
+.. literalinclude:: ../../examples/advanced_usage/inject_simple.py
+   :language: python
+   :linenos:
+
+Example of usage :py:func:`inject` decorator with Flask:
+
+.. literalinclude:: ../../examples/advanced_usage/inject_flask.py
+   :language: python
+   :linenos:
+
+
+@inject decorator with classes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+: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 
+:py:exc:`dependency_injector.errors.Error` will be raised.
+
+Example of usage :py:func:`inject` with Flask class-based view:
+
+.. literalinclude:: ../../examples/advanced_usage/inject_flask_class_based.py
+   :language: python
+   :linenos:

docs/api/containers.rst

@@ -1,9 +1,6 @@
-dependency_injector.containers
-==============================
+``dependency_injector.containers``
+--------------------------------
 
 .. automodule:: dependency_injector.containers
    :members:
-   :inherited-members:
-   :show-inheritance:
-
-.. disqus::
+   :special-members:

docs/api/errors.rst

@@ -1,8 +1,5 @@
-dependency_injector.errors
-==========================
+``dependency_injector.errors``
+------------------------------
 
 .. automodule:: dependency_injector.errors
    :members:
-
-
-.. disqus::

docs/api/index.rst

@@ -4,8 +4,8 @@ API Documentation
 ..  toctree::
     :maxdepth: 2
 
-   top-level
-   providers
-   containers
-   wiring
-   errors
+    top_level
+    providers
+    containers
+    utils
+    errors

docs/api/injections.rst

@@ -0,0 +1,7 @@
+``dependency_injector.injections``
+----------------------------------
+
+.. automodule:: dependency_injector.injections
+   :members:
+   :inherited-members:
+   :show-inheritance:

docs/api/providers.rst

@@ -1,10 +1,11 @@
-dependency_injector.providers
-=============================
+``dependency_injector.providers``
+---------------------------------
+
+.. image:: /images/providers/providers_class_diagram.png
+    :width: 100%
+    :align: center
 
 .. automodule:: dependency_injector.providers
    :members:
    :inherited-members:
    :show-inheritance:
-
-
-.. disqus::

docs/api/top-level.rst

@@ -1,8 +0,0 @@
-dependency_injector
-===================
-
-.. automodule:: dependency_injector
-   :members: __version__
-
-
-.. disqus::

docs/api/top_level.rst

@@ -0,0 +1,5 @@
+``dependency_injector``
+-----------------------
+
+.. automodule:: dependency_injector
+   :members: VERSION

docs/api/utils.rst

@@ -0,0 +1,5 @@
+``dependency_injector.utils``
+-----------------------------
+
+.. automodule:: dependency_injector.utils
+   :members:

docs/api/wiring.rst

@@ -1,7 +0,0 @@
-dependency_injector.wiring
-=============================
-
-.. automodule:: dependency_injector.wiring
-   :members:
-
-.. disqus::

docs/conf.py

@@ -15,54 +15,49 @@
 import os
 import re
 import sys
-import alabaster
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.insert(0, os.path.abspath(".."))
+sys.path.insert(0, os.path.abspath('..'))
 
 # -- General configuration ------------------------------------------------
 
 # If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = "1.0"
+#needs_sphinx = '1.0'
 
 # Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named "sphinx.ext.*") or your custom
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = [
-    "alabaster",
-    "sphinx.ext.autodoc",
-    "sphinx_disqus.disqus",
-]
+extensions = ['sphinx.ext.autodoc']
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ["_templates"]
+templates_path = ['_templates']
 
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
-# source_suffix = [".rst", ".md"]
-source_suffix = ".rst"
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
 
 # The encoding of source files.
-#source_encoding = "utf-8-sig"
+#source_encoding = 'utf-8-sig'
 
 # The master toctree document.
-master_doc = "index"
+master_doc = 'index'
 
 # General information about the project.
-project = "Dependency Injector"
-copyright = "2024, Roman Mogylatov"
-author = "Roman Mogylatov"
+project = u'Dependency Injector'
+copyright = u'2016, ETS Labs'
+author = u'ETS Labs'
 
-# The version info for the project you"re documenting, acts as replacement for
+# The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
 # Getting version:
-with open("../src/dependency_injector/__init__.py") as init_file:
-    version = re.search("__version__ = \"(.*?)\"", init_file.read()).group(1)
+with open('../dependency_injector/__init__.py') as init_file:
+    version = re.search('VERSION = \'(.*?)\'', init_file.read()).group(1)
 
 # The full version, including alpha/beta/rc tags.
 release = version
@@ -76,19 +71,19 @@ language = None
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:
-#today = ""
+#today = ''
 # Else, today_fmt is used as the format for a strftime call.
-#today_fmt = "%B %d, %Y"
+#today_fmt = '%B %d, %Y'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ["_build"]
+exclude_patterns = ['_build']
 
 # The reST default role (used for this markup: `text`) to use for all
 # documents.
 #default_role = None
 
-# If true, "()" will be appended to :func: etc. cross-reference text.
+# If true, '()' will be appended to :func: etc. cross-reference text.
 #add_function_parentheses = True
 
 # If true, the current module name will be prepended to all description
@@ -100,7 +95,7 @@ exclude_patterns = ["_build"]
 #show_authors = False
 
 # The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
+pygments_style = 'sphinx'
 
 # A list of ignored prefixes for module index sorting.
 #modindex_common_prefix = []
@@ -116,16 +111,15 @@ todo_include_todos = False
 
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
-# html_theme = "sphinx_rtd_theme"
-html_theme = "alabaster"
+html_theme = 'default'
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-# html_context = {}
+#html_theme_options = {}
 
 # Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = [alabaster.get_path()]
+#html_theme_path = []
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
@@ -141,24 +135,21 @@ html_theme_path = [alabaster.get_path()]
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
 # pixels large.
-html_favicon = "favicon.ico"
+#html_favicon = None
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
-html_css_files = [
-    "custom.css",
-]
+html_static_path = []
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
 # directly to the root of the documentation.
 #html_extra_path = []
 
-# If not "", a "Last updated on:" timestamp is inserted at every page bottom,
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.
-#html_last_updated_fmt = "%b %d, %Y"
+#html_last_updated_fmt = '%b %d, %Y'
 
 # If true, SmartyPants will be used to convert quotes and dashes to
 # typographically correct entities.
@@ -192,50 +183,61 @@ html_css_files = [
 # If true, an OpenSearch description file will be output, and all pages will
 # contain a <link> tag referring to it.  The value of this option must be the
 # base URL from which the finished HTML is served.
-#html_use_opensearch = ""
+#html_use_opensearch = ''
 
 # This is the file name suffix for HTML files (e.g. ".xhtml").
 #html_file_suffix = None
 
 # Language to be used for generating the HTML full-text search index.
 # Sphinx supports the following languages:
-#   "da", "de", "en", "es", "fi", "fr", "hu", "it", "ja"
-#   "nl", "no", "pt", "ro", "ru", "sv", "tr"
-#html_search_language = "en"
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
+#html_search_language = 'en'
 
 # A dictionary with options for the search language support, empty by default.
-# Now only "ja" uses this config value
-#html_search_options = {"type": "default"}
+# Now only 'ja' uses this config value
+#html_search_options = {'type': 'default'}
 
 # The name of a javascript file (relative to the configuration directory) that
 # implements a search results scorer. If empty, the default will be used.
-#html_search_scorer = "scorer.js"
+#html_search_scorer = 'scorer.js'
 
 # Output file base name for HTML help builder.
-htmlhelp_basename = "dependency_injectordoc"
+htmlhelp_basename = 'dependency_injectordoc'
+
+# on_rtd is whether we are on readthedocs.org, this line of code grabbed from
+# docs.readthedocs.org
+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
+
+if not on_rtd:  # only import and set the theme if we're building docs locally
+    import sphinx_rtd_theme
+    html_theme = 'sphinx_rtd_theme'
+    html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+# otherwise, readthedocs.org uses their theme by default, so no need to
+# specify it
 
 # -- Options for LaTeX output ---------------------------------------------
 
 latex_elements = {
-# The paper size ("letterpaper" or "a4paper").
-#"papersize": "letterpaper",
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
 
-# The font size ("10pt", "11pt" or "12pt").
-#"pointsize": "10pt",
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
 
 # Additional stuff for the LaTeX preamble.
-#"preamble": "",
+#'preamble': '',
 
 # Latex figure (float) alignment
-#"figure_align": "htbp",
+#'figure_align': 'htbp',
 }
 
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
 latex_documents = [
-  (master_doc, "dependency_injector.tex", u"Dependency Injector Documentation",
-   u"Roman Mogylatov", "manual"),
+  (master_doc, 'dependency_injector.tex', u'Dependency Injector Documentation',
+   u'ETS Labs', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -264,7 +266,7 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    (master_doc, "Dependency Injector", u"Dependency Injector Documentation",
+    (master_doc, 'Dependency Injector', u'Dependency Injector Documentation',
      [author], 1)
 ]
 
@@ -278,9 +280,9 @@ man_pages = [
 # (source start file, target name, title, author,
 #  dir menu entry, description, category)
 texinfo_documents = [
-  (master_doc, "Dependency Injector", u"Dependency Injector Documentation",
-   author, "Dependency Injector", "Dependency injection microframework for Python",
-   "Miscellaneous"),
+  (master_doc, 'Dependency Injector', u'Dependency Injector Documentation',
+   author, 'Dependency Injector', 'Python dependency injection framework',
+   'Miscellaneous'),
 ]
 
 # Documents to append as an appendix to all manuals.
@@ -289,25 +291,10 @@ texinfo_documents = [
 # If false, no module index is generated.
 #texinfo_domain_indices = True
 
-# How to display URL addresses: "footnote", "no", or "inline".
-#texinfo_show_urls = "footnote"
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
 
-# If true, do not generate a @detailmenu in the "Top" node"s menu.
+# If true, do not generate a @detailmenu in the "Top" node's menu.
 #texinfo_no_detailmenu = False
 
-autodoc_member_order = "bysource"
-
-disqus_shortname = "python-dependency-injector"
-
-html_theme_options = {
-    "github_user": "ets-labs",
-    "github_repo": "python-dependency-injector",
-    "github_type": "star",
-    "github_button": True,
-    "github_banner": True,
-    "logo": "logo.svg",
-    "description": "Dependency injection framework for Python by Roman Mogylatov",
-    "code_font_size": "10pt",
-    "analytics_id": "UA-67012059-1",
-    "donate_url": "https://github.com/sponsors/rmk135",
-}
+autodoc_member_order = 'bysource'

docs/containers/check_dependencies.rst

@@ -1,18 +0,0 @@
-.. _check-container-dependencies:
-
-Check container dependencies
-----------------------------
-
-To check container dependencies use method ``.check_dependencies()``.
-
-.. literalinclude:: ../../examples/containers/check_dependencies.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 12
-
-Method ``.check_dependencies()`` raises an error if container has any undefined dependencies.
-If all dependencies are provided or have defaults, no error is raised.
-
-See also: :ref:`dependency-provider`.
-
-.. disqus::

docs/containers/copying.rst

@@ -1,23 +0,0 @@
-Container copying
------------------
-
-You can create declarative container copies using ``@containers.copy()`` decorator.
-
-.. literalinclude:: ../../examples/containers/declarative_copy_decorator1.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 18-22
-
-Decorator ``@containers.copy()`` copies providers from source container to destination container.
-Destination container provider will replace source provider, if names match.
-
-Decorator ``@containers.copy()`` helps you when you create derived declarative containers
-from the base one. Base container often keeps default dependencies while derived containers define
-overriding providers. Without ``@containers.copy()`` decorator, overridden providers are available
-in the derived container, but base class dependencies continue to be bound to the base class providers.
-
-.. literalinclude:: ../../examples/containers/declarative_copy_decorator2.py
-   :language: python
-   :lines: 11-
-
-.. disqus::

docs/containers/declarative.rst

@@ -1,72 +1,55 @@
-Declarative container
----------------------
+Declarative containers
+----------------------
 
 .. currentmodule:: dependency_injector.containers
 
-:py:class:`DeclarativeContainer` is a class-based style of the providers definition.
+:py:class:`DeclarativeContainer` is inversion of control container that 
+could be defined in declarative manner. It should cover most of the cases 
+when list of providers that would be included in container is deterministic 
+(container will not change its structure in runtime).
 
-You create the declarative container subclass, put the providers as attributes and create the
-container instance.
+Declarative containers have to extend base declarative container class - 
+:py:class:`dependency_injector.containers.DeclarativeContainer`.
+
+Declarative container's providers have to be defined like container's class 
+attributes. Every provider in container has name. This name should follow 
+``some_provider`` convention, that is standard naming convention for 
+attribute names in Python.
+
+.. note::
+
+    Declarative containers have several features that could be useful 
+    for some kind of operations on container's providers, please visit API 
+    documentation for getting full list of features - 
+    :py:class:`dependency_injector.containers.DeclarativeContainer`.
+
+Here is an simple example of defining declarative container with several 
+factories:
+
+.. image:: /images/containers/declarative.png
+    :width: 85%
+    :align: center
 
 .. literalinclude:: ../../examples/containers/declarative.py
    :language: python
-   :lines: 3-
+   :linenos:
 
-The declarative container providers should only be used when you have the container instance.
-Working with the providers of the container on the class level will influence all further
-instances.
+Example of declarative containers inheritance:
 
-The declarative container can not have any methods or any other attributes then providers.
-
-The container class provides next attributes:
-
-- ``providers`` - the dictionary of all the container providers
-- ``cls_providers`` - the dictionary of the container providers of the current container
-- ``inherited_providers`` - the dictionary of all the inherited container providers
+.. image:: /images/containers/declarative_inheritance.png
+    :width: 100%
+    :align: center
 
 .. literalinclude:: ../../examples/containers/declarative_inheritance.py
    :language: python
-   :lines: 3-
+   :linenos:
 
-Injections in the declarative container are done the usual way:
+Example of declarative containers's provider injections:
+
+.. image:: /images/containers/declarative_injections.png
+    :width: 100%
+    :align: center
 
 .. literalinclude:: ../../examples/containers/declarative_injections.py
    :language: python
-   :lines: 3-
-
-You can override container providers while creating a container instance:
-
-.. literalinclude:: ../../examples/containers/declarative_override_providers.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 13
-
-Alternatively, you can call ``container.override_providers()`` method when the container instance
-already exists:
-
-.. code-block:: python
-   :emphasize-lines: 3
-
-   container = Container()
-
-   container.override_providers(foo=mock.Mock(Foo), bar=mock.Mock(Bar))
-
-   assert isinstance(container.foo(), mock.Mock)
-   assert isinstance(container.bar(), mock.Mock)
-
-You can also use ``container.override_providers()`` with a context manager to reset
-provided overriding after the context is closed:
-
-.. code-block:: python
-   :emphasize-lines: 3
-
-   container = Container()
-
-   with container.override_providers(foo=mock.Mock(Foo), bar=mock.Mock(Bar)):
-       assert isinstance(container.foo(), mock.Mock)
-       assert isinstance(container.bar(), mock.Mock)
-
-   assert isinstance(container.foo(), Foo)
-   assert isinstance(container.bar(), Bar)
-
-.. disqus::
+   :linenos:

docs/containers/dynamic.rst

@@ -1,25 +1,27 @@
-Dynamic container
------------------
+Dynamic containers
+------------------
 
 .. currentmodule:: dependency_injector.containers
 
-:py:class:`DynamicContainer` is a collection of the providers defined in the runtime.
+:py:class:`DynamicContainer` is an inversion of control container with dynamic 
+structure. It should cover most of the cases when list of providers that 
+would be included in container is non-deterministic and depends on 
+application's flow or its configuration (container's structure could be 
+determined just after application will be started and will do some initial 
+work, like parsing list of container's providers from the configuration).
 
-You create the dynamic container instance and put the providers as attributes.
+While :py:class:`DeclarativeContainer` acts on class-level, 
+:py:class:`DynamicContainer` does the same on instance-level.
+
+Here is an simple example of defining dynamic container with several factories:
 
 .. literalinclude:: ../../examples/containers/dynamic.py
    :language: python
-   :lines: 3-
+   :linenos:
 
-The dynamic container is good for the case when your application structure depends on the
-configuration file or some other source that you can reach only after application is already
-running (database, api, etc).
-
-In this example we use the configuration to fill in the dynamic container with the providers:
+Next example demonstrates creation of dynamic container based on some 
+configuration:
 
 .. literalinclude:: ../../examples/containers/dynamic_runtime_creation.py
    :language: python
-   :lines: 3-
-
-.. disqus::
-
+   :linenos:

docs/containers/index.rst

@@ -1,18 +1,21 @@
-.. _containers:
+IoC Containers
+==============
 
-Containers
-==========
+Containers are collections of providers. Main purpose of containers is to group
+providers. 
 
-Containers are collections of the providers.
+There are, actually, several popular cases of containers usage:
 
-There are several use cases how you can use containers:
-
-+ Keeping all the providers in a single container (most common).
-+ Grouping of the providers from the same architectural layer (for example,
++ Keeping all providers in a single container.
++ Grouping of providers from the same architectural layer (for example, 
   ``Services``, ``Models`` and ``Forms`` containers).
 + Grouping of providers from the same functional groups (for example,
-  container ``Users``, that contains all functional parts of the ``users``
-  package).
+  container ``Users``, that contains all functional parts of ``Users``
+  component).
+
+Also, for both of these and some other cases, it might be useful to attach 
+some init / shutdown functionality or something else, that deals with group 
+of providers.
 
 Containers module API docs - :py:mod:`dependency_injector.containers`.
 
@@ -23,7 +26,3 @@ Containers module API docs - :py:mod:`dependency_injector.containers`.
     dynamic
     specialization
     overriding
-    copying
-    reset_singletons
-    check_dependencies
-    traversal

docs/containers/overriding.rst

@@ -1,40 +1,40 @@
-Container overriding
---------------------
+Overriding of containers
+------------------------
 
 .. currentmodule:: dependency_injector.containers
 
-The container can be overridden by the other container. All of the providers from the overriding
-container will override the providers with the same names in the overridden container.
+Containers can be overridden by other containers. This, actually, means that 
+all of the providers from overriding container will override providers with 
+the same names in overridden container.
 
-.. literalinclude:: ../../examples/containers/override.py
+There are two ways to override :py:class:`DeclarativeContainer` with another 
+container:
+
+- Use :py:meth:`DeclarativeContainer.override` method.
+- Use :py:func:`override` class decorator.
+
+Example of overriding container using :py:meth:`DeclarativeContainer.override` 
+method:
+
+.. literalinclude:: ../../examples/containers/override_declarative.py
    :language: python
-   :lines: 3-
+   :linenos:
 
-It helps in a testing. Also you can use it for configuring project for the different
-environments: replace an API client with a stub on the dev or stage.
+Example of overriding container using :py:func:`override` decorator:
 
-The container also has:
-
-- ``container.overridden`` - tuple of all overriding containers.
-- ``container.reset_last_overriding()`` - reset last overriding for each provider in the container.
-- ``container.reset_override()`` - reset all overriding in the container.
-
-:py:class:`DynamicContainer` has the same functionality.
-
-Another possible way to override container providers on declarative level is
-``@containers.override()`` decorator:
-
-.. literalinclude:: ../../examples/containers/declarative_override_decorator.py
+.. literalinclude:: ../../examples/containers/override_declarative_decorator.py
    :language: python
-   :lines: 3-
-   :emphasize-lines: 12-16
+   :linenos:
 
-Decorator ``@containers.override()`` takes a container for overriding as an argument.
-This container providers will be overridden by the providers with the same names from
-the decorated container.
+Also there are several useful :py:class:`DeclarativeContainer` methods and 
+properties that help to work with container overridings:
 
-It helps to change the behaviour of application by importing extension modules but not a code change.
-Imported module can override providers in main container. While the code uses main container as
-before, the overridden providers provide components defined in the extension module.
+- :py:attr:`DeclarativeContainer.overridden` - tuple of all overriding 
+  containers.
+- :py:meth:`DeclarativeContainer.reset_last_overriding()` - reset last 
+  overriding provider for each container providers.
+- :py:meth:`DeclarativeContainer.reset_override()` - reset all overridings 
+  for each container providers. 
 
-.. disqus::
+:py:class:`DynamicContainer` has exactly the same functionality, except of 
+:py:func:`override` decorator.

docs/containers/reset_singletons.rst

@@ -1,31 +0,0 @@
-.. _reset-container-singletons:
-
-Reset container singletons
---------------------------
-
-To reset all container singletons use method ``.reset_singletons()``.
-
-.. literalinclude:: ../../examples/containers/reset_singletons.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 16
-
-Method ``.reset_singletons()`` also resets singletons in sub-containers: ``providers.Container`` and
-``providers.DependenciesContainer.``
-
-.. literalinclude:: ../../examples/containers/reset_singletons_subcontainers.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 21
-
-You can use ``.reset_singletons()`` method with a context manager. Singletons will be reset on
-both entering and exiting a context.
-
-.. literalinclude:: ../../examples/containers/reset_singletons_with.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 14-15
-
-See also: :ref:`singleton-provider`.
-
-.. disqus::

docs/containers/specialization.rst

@@ -1,25 +1,24 @@
-Specialization of the container provider type
----------------------------------------------
+Specialization of containers
+----------------------------
 
 .. currentmodule:: dependency_injector.containers
 
-You can make a restriction of the :py:class:`DeclarativeContainer` provider type:
+:py:class:`DeclarativeContainer` could be specialized for any kind of needs 
+via declaring its subclasses. 
+
+One of such `builtin` features is a limitation for providers type.
+
+Next example shows usage of this feature with :py:class:`DeclarativeContainer` 
+in couple with feature of :py:class:`dependency_injector.providers.Factory` 
+for limitation of its provided type:
 
 .. literalinclude:: ../../examples/containers/declarative_provider_type.py
    :language: python
-   :lines: 3-
-   :emphasize-lines: 29-31
+   :linenos:
 
-The emphasized lines will cause an error because ``other_provider`` is not a subtype of the
-``ServiceProvider``. This helps to control the content of the container.
-
-The same works for the :py:class:`DynamicContainer`:
+Limitation for providers type could be used with :py:class:`DynamicContainer` 
+as well:
 
 .. literalinclude:: ../../examples/containers/dynamic_provider_type.py
    :language: python
-   :lines: 3-
-   :emphasize-lines: 23
-
-The emphasized line will also cause an error.
-
-.. disqus::
+   :linenos:

docs/containers/traversal.rst

@@ -1,33 +0,0 @@
-Container providers traversal
------------------------------
-
-To traverse container providers use method ``.traverse()``.
-
-.. literalinclude:: ../../examples/containers/traverse.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 38
-
-Method ``.traverse()`` returns a generator. Traversal generator visits all container providers.
-This includes nested providers even if they are not present on the root level of the container.
-
-Traversal generator guarantees that each container provider will be visited only once.
-It can traverse cyclic provider graphs.
-
-Traversal generator does not guarantee traversal order.
-
-You can use ``types=[...]`` argument to filter providers. Traversal generator will only return
-providers matching specified types.
-
-.. code-block:: python
-   :emphasize-lines: 3
-
-   container = Container()
-
-   for provider in container.traverse(types=[providers.Resource]):
-       print(provider)
-
-    # <dependency_injector.providers.Resource(<function init_database at 0x10bd2cb80>) at 0x10d346b40>
-    # <dependency_injector.providers.Resource(<function init_cache at 0x10be373a0>) at 0x10d346bc0>
-
-.. disqus::

docs/examples-other/chained-factories.rst

@@ -1,68 +0,0 @@
-Chained Factories pattern
-=========================
-
-This example demonstrates "Chained Factories" pattern.
-
-The idea of the pattern is in wrapping ``Factory`` into another ``Factory`` that adds
-additional arguments.
-
-.. code-block:: python
-
-   base_factory = providers.Factory(
-       SomeClass,
-       base_argument=1,
-   )
-
-   concrete_factory = providers.Factory(
-       base_factory,
-       extra_argument=2,
-   )
-
-
-   if __name__ == "__main__":
-       instance = concrete_factory()
-       # Same as: # instance = SomeClass(base_argument=1, extra_argument=2)
-
-Sample code
------------
-
-Listing of the pattern example:
-
-.. literalinclude:: ../../examples/miniapps/factory-patterns/chained_factories.py
-   :language: python
-
-Arguments priority
-------------------
-
-Passing of the arguments works the same way like for any other :ref:`factory-provider`.
-
-.. code-block:: python
-
-   # 1. Keyword arguments of upper level factory are added to lower level factory
-   chained_dict_factory = providers.Factory(
-       providers.Factory(dict, arg1=1),
-       arg2=2,
-   )
-   print(chained_dict_factory())  # prints: {"arg1": 1, "arg2": 2}
-
-   # 2. Keyword arguments of upper level factory have priority
-   chained_dict_factory = providers.Factory(
-       providers.Factory(dict, arg1=1),
-       arg1=2,
-   )
-   print(chained_dict_factory())  # prints: {"arg1": 2}
-
-   # 3. Keyword arguments provided from context have the most priority
-   chained_dict_factory = providers.Factory(
-       providers.Factory(dict, arg1=1),
-       arg1=2,
-   )
-   print(chained_dict_factory(arg1=3))  # prints: {"arg1": 3}
-
-
-Credits
--------
-
-The "Chained Factories" pattern was suggested by the ``Dependency Injector`` users.
-
-.. disqus::

docs/examples-other/factory-of-factories.rst

@@ -1,74 +0,0 @@
-Factory of Factories pattern
-============================
-
-This example demonstrates "Factory of Factories" pattern.
-
-The idea of the pattern is in creating a ``Factory`` that creates another ``Factory`` and adds
-additional arguments.
-
-.. code-block:: python
-
-   base_factory = providers.Factory(
-       providers.Factory
-       SomeClass,
-       base_argument=1,
-   )
-
-   concrete_factory = providers.Factory(
-       OtherClass,
-       instance=base_factory(extra_argument=1),
-   )
-
-
-   if __name__ == "__main__":
-       instance = concrete_factory()
-       # Same as: # instance = SomeClass(base_argument=1, extra_argument=2)
-
-Sample code
------------
-
-Listing of the pattern example:
-
-.. literalinclude:: ../../examples/miniapps/factory-patterns/factory_of_factories.py
-   :language: python
-
-Arguments priority
-------------------
-
-Passing of the arguments works the same way like for any other :ref:`factory-provider`.
-
-.. code-block:: python
-
-   # 1. Keyword arguments of upper level factory are added to lower level factory
-   factory_of_dict_factories = providers.Factory(
-       providers.Factory,
-       dict,
-       arg1=1,
-   )
-   dict_factory = factory_of_dict_factories(arg2=2)
-   print(dict_factory())  # prints: {"arg1": 1, "arg2": 2}
-
-   # 2. Keyword arguments of upper level factory have priority
-   factory_of_dict_factories = providers.Factory(
-       providers.Factory,
-       dict,
-       arg1=1,
-   )
-   dict_factory = factory_of_dict_factories(arg1=2)
-   print(dict_factory())  # prints: {"arg1": 2}
-
-   # 3. Keyword arguments provided from context have the most priority
-   factory_of_dict_factories = providers.Factory(
-       providers.Factory,
-       dict,
-       arg1=1,
-   )
-   dict_factory = factory_of_dict_factories(arg1=2)
-   print(dict_factory(arg1=3))  # prints: {"arg1": 3}
-
-Credits
--------
-
-The "Factory of Factories" pattern was suggested by the ``Dependency Injector`` users.
-
-.. disqus::

docs/examples-other/index.rst

@@ -1,17 +0,0 @@
-Other examples
-==============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework
-   :description: This sections contains assorted Dependency Injector examples.
-
-This sections contains assorted ``Dependency Injector`` examples.
-
-..  toctree::
-    :maxdepth: 2
-
-    use-cases
-    password-hashing
-    chained-factories
-    factory-of-factories

docs/examples-other/password-hashing.rst

@@ -1,30 +0,0 @@
-Password hashing example
-========================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework,Callable
-   :description: This example demonstrates a usage of the Callable provider.
-
-This example demonstrates an injection of the ``Callable`` provider.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/password-hashing>`_.
-
-Sample code
------------
-
-Listing of the pattern example:
-
-.. literalinclude:: ../../examples/miniapps/password-hashing/example.py
-   :language: python
-
-Run the example
----------------
-
-Instructions for running:
-
-.. code-block:: bash
-
-    python example.py
-
-.. disqus::

docs/examples-other/use-cases.rst

@@ -1,74 +0,0 @@
-Use cases example
-=================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework,DependenciesContainer
-   :description: This example demonstrates a usage of the DependenciesContainer provider.
-
-This example demonstrates a usage of the ``DependenciesContainer`` provider.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/decoupled-packages>`_.
-
-Application structure
----------------------
-
-Example application has next structure:
-
-.. code-block:: bash
-
-
-   ./
-   └── example/
-       ├── __init__.py
-       ├── __main__.py
-       ├── adapters.py
-       ├── containers.py
-       └── usecases.py
-
-Containers
-----------
-
-Listing of the ``example/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/use-cases/example/containers.py
-   :language: python
-
-Main module
------------
-
-Listing of the ``example/__main__.py``:
-
-.. literalinclude:: ../../examples/miniapps/use-cases/example/__main__.py
-   :language: python
-
-
-Run the application
--------------------
-
-Instructions for running in the "test" mode:
-
-.. code-block:: bash
-
-    python run.py test example@example.com
-
-Instructions for running in the "prod" mode:
-
-.. code-block:: bash
-
-    python run.py prod example@example.com
-
-Adapters and use cases
-----------------------
-
-Listing of the ``example/adapters.py``:
-
-.. literalinclude:: ../../examples/miniapps/use-cases/example/adapters.py
-   :language: python
-
-Listing of the ``example/usecases.py``:
-
-.. literalinclude:: ../../examples/miniapps/use-cases/example/usecases.py
-   :language: python
-
-.. disqus::

docs/examples/aiohttp.rst

@@ -1,83 +0,0 @@
-.. _aiohttp-example:
-
-Aiohttp example
-===============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Aiohttp,Example
-   :description: This example demonstrates a usage of the Aiohttp and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Aiohttp <https://docs.aiohttp.org/>`_.
-
-The example application is a REST API that searches for funny GIFs on the `Giphy <https://giphy.com/>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/aiohttp>`_.
-
-:ref:`aiohttp-tutorial` demonstrates how to build this application step-by-step.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── giphynavigator/
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── giphy.py
-   │   ├── handlers.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── config.yml
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``giphynavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/aiohttp/giphynavigator/containers.py
-   :language: python
-
-Handlers
---------
-
-Handler has dependencies on search service and some config options. The dependencies are injected
-using :ref:`wiring` feature.
-
-Listing of ``giphynavigator/handlers.py``:
-
-.. literalinclude:: ../../examples/miniapps/aiohttp/giphynavigator/handlers.py
-   :language: python
-
-Application factory
--------------------
-Application factory creates container, wires it with the ``handlers`` module, creates
-``Aiohttp`` app and setup routes.
-
-Listing of ``giphynavigator/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/aiohttp/giphynavigator/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace giphy client with a mock ``giphynavigator/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/aiohttp/giphynavigator/tests.py
-   :language: python
-   :emphasize-lines: 32,59,73
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/aiohttp>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/application-multiple-containers.rst

@@ -1,89 +0,0 @@
-.. _application-multiple-containers:
-
-Application example (multiple containers)
-=========================================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework,AWS,boto3,client
-   :description: This example shows how you can create an application using multiple declarative
-                 containers. We build an example Python micro application following the dependency
-                 injection principle. It consists from several services with a domain logic that
-                 have dependencies on database & AWS S3.
-
-This example shows how you can create an application using multiple declarative containers. Using
-multiple declarative containers is a good choice for a large application. For
-building a moderate or a small size application refer to :ref:`application-single-container`.
-
-We build an example micro application following the dependency injection principle. It consists
-of several services with a domain logic. The services have dependencies on database & AWS S3.
-
-.. image:: images/application.png
-    :width: 100%
-    :align: center
-
-Start from the scratch or jump to the section:
-
-.. contents::
-   :local:
-   :backlinks: none
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/application-multiple-containers>`_.
-
-Application structure
----------------------
-
-Application consists of an ``example`` package, a configuration file and a ``requirements.txt``
-file.
-
-.. code-block:: bash
-
-   ./
-   ├── example/
-   │   ├── __init__.py
-   │   ├── __main__.py
-   │   ├── containers.py
-   │   └── services.py
-   ├── config.yml
-   └── requirements.txt
-
-Containers
-----------
-
-Listing of the ``example/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-multiple-containers/example/containers.py
-   :language: python
-
-Main module
------------
-
-Listing of the ``example/__main__.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-multiple-containers/example/__main__.py
-   :language: python
-
-Services
---------
-
-Listing of the ``example/services.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-multiple-containers/example/services.py
-   :language: python
-
-Configuration
--------------
-
-Listing of the ``config.yml``:
-
-.. literalinclude:: ../../examples/miniapps/application-multiple-containers/config.yml
-   :language: yaml
-
-Run the application
--------------------
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/application-multiple-containers>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/application-single-container.rst

@@ -1,95 +0,0 @@
-.. _application-single-container:
-
-Application example (single container)
-======================================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework,AWS,boto3,client
-   :description: This example shows how you can create an application using a single declarative
-                 container. We build an example Python micro application following the dependency
-                 injection principle. It consists from several services with a domain logic that
-                 have dependencies on database & AWS S3.
-
-This example shows how you can create an application using a single declarative container. Using
-a single declarative container is a good choice for small or moderate size application. For
-building a large application refer to :ref:`application-multiple-containers`.
-
-We build an example micro application following the dependency injection principle. It consists
-of several services with a domain logic. The services have dependencies on database & AWS S3.
-
-.. image:: images/application.png
-    :width: 100%
-    :align: center
-
-Start from the scratch or jump to the section:
-
-.. contents::
-   :local:
-   :backlinks: none
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/application-single-container>`_.
-
-Application structure
----------------------
-
-Application consists of an ``example`` package, several configuration files and a
-``requirements.txt`` file.
-
-.. code-block:: bash
-
-   ./
-   ├── example/
-   │   ├── __init__.py
-   │   ├── __main__.py
-   │   ├── containers.py
-   │   └── services.py
-   ├── config.ini
-   ├── logging.ini
-   └── requirements.txt
-
-Container
----------
-
-Listing of the ``example/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-single-container/example/containers.py
-   :language: python
-
-Main module
------------
-
-Listing of the ``example/__main__.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-single-container/example/__main__.py
-   :language: python
-
-Services
---------
-
-Listing of the ``example/services.py``:
-
-.. literalinclude:: ../../examples/miniapps/application-single-container/example/services.py
-   :language: python
-
-Configuration
--------------
-
-Listing of the ``config.ini``:
-
-.. literalinclude:: ../../examples/miniapps/application-single-container/config.ini
-   :language: ini
-
-Listing of the ``logging.ini``:
-
-.. literalinclude:: ../../examples/miniapps/application-single-container/logging.ini
-   :language: ini
-
-Run the application
--------------------
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/application-single-container>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/boto3.rst

@@ -1,22 +0,0 @@
-.. _boto3-example:
-
-Boto3 example
-=============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Boto3,AWS,Amazon Web Services,S3,SQS,Rout53,EC2,Lambda,Example
-   :description: This example demonstrates a usage of Boto3 AWS client and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Boto3 <https://github.com/boto/boto3>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/boto3-session>`_.
-
-Listing of ``boto3_session_example.py``:
-
-.. literalinclude:: ../../examples/miniapps/boto3-session/boto3_session_example.py
-   :language: python
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/decoupled-packages.rst

@@ -1,134 +0,0 @@
-.. _decoupled-packages:
-
-Decoupled packages example (multiple containers)
-================================================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Inversion of Control,Container,Example,Application,
-              Framework,AWS,boto3,client
-   :description: This example shows how to use Dependency Injector to create Python decoupled packages.
-                 To achieve a decoupling each package has a container with the components. When
-                 a component needs a dependency from the outside of the package scope we use the
-                 Dependency provider. The package container has no knowledge on where the
-                 dependencies come from. It states a need that the dependencies must be provided.
-                 This helps to decouple a package from the 3rd party dependencies and other
-                 packages.
-
-This example shows how to use ``Dependency Injector`` to create decoupled packages.
-
-To achieve a decoupling each package has a container with the components. When a component needs a
-dependency from the outside of the package scope we use the ``Dependency`` provider. The package
-container has no knowledge on where the dependencies come from. It states a need that the
-dependencies must be provided. This helps to decouple a package from the 3rd party dependencies
-and other packages.
-
-To wire the packages we use an application container. Application container has all 3rd party
-dependencies and package containers. It wires the packages and dependencies to create a
-complete application.
-
-We build an example micro application that consists of 3 packages:
-
-- ``user`` - a package with user domain logic, depends on a database
-- ``photo`` - a package with photo domain logic, depends on a database and AWS S3
-- ``analytics`` - a package with analytics domain logic, depends on the  ``user`` and ``photo``
-  package components
-
-.. image:: images/decoupled-packages.png
-    :width: 100%
-    :align: center
-
-Start from the scratch or jump to the section:
-
-.. contents::
-   :local:
-   :backlinks: none
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/decoupled-packages>`_.
-
-Application structure
----------------------
-
-Application consists of an ``example`` package, a configuration file and a ``requirements.txt``
-file.
-
-.. code-block:: bash
-
-   ./
-   ├── example/
-   │   ├── analytics/
-   │   │   ├── __init__.py
-   │   │   ├── containers.py
-   │   │   └── services.py
-   │   ├── photo/
-   │   │   ├── __init__.py
-   │   │   ├── containers.py
-   │   │   ├── entities.py
-   │   │   └── repositories.py
-   │   ├── user/
-   │   │   ├── __init__.py
-   │   │   ├── containers.py
-   │   │   ├── entities.py
-   │   │   └── repositories.py
-   │   ├── __init__.py
-   │   ├── __main__.py
-   │   └── containers.py
-   ├── config.ini
-   └── requirements.txt
-
-Package containers
-------------------
-
-Listing of the ``example/user/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/example/user/containers.py
-   :language: python
-
-Listing of the ``example/photo/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/example/photo/containers.py
-   :language: python
-
-Listing of the ``example/analytics/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/example/analytics/containers.py
-   :language: python
-
-Application container
----------------------
-
-Application container consists of all packages and 3rd party dependencies. Its role is to wire
-everything together in a complete application.
-
-Listing of the ``example/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/example/containers.py
-   :language: python
-
-.. note::
-   Package ``analytics`` has dependencies on the repositories from the ``user`` and
-   ``photo`` packages. This is an example of how you can pass the dependencies from one package
-   to another.
-
-Main module
------------
-Listing of the ``example/__main__.py``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/example/__main__.py
-   :language: python
-
-Configuration
--------------
-
-Listing of the ``config.ini``:
-
-.. literalinclude:: ../../examples/miniapps/decoupled-packages/config.ini
-   :language: ini
-
-Run the application
--------------------
-
-You can find the source code and instructions for running on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/decoupled-packages>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/django.rst

@@ -1,99 +0,0 @@
-.. _django-example:
-
-Django example
-==============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Django,Example
-   :description: This example demonstrates a usage of the Django and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Django <https://www.djangoproject.com/>`_.
-
-The example application helps to search for repositories on the Github.
-
-.. image:: images/django.png
-    :width: 100%
-    :align: center
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/django>`_.
-
-Application structure
----------------------
-
-Application has standard Django project structure. It consists of ``githubnavigator`` project package and
-``web`` application package:
-
-.. code-block:: bash
-
-   ./
-   ├── githubnavigator/
-   │   ├── __init__.py
-   │   ├── asgi.py
-   │   ├── containers.py
-   │   ├── services.py
-   │   ├── settings.py
-   │   ├── urls.py
-   │   └── wsgi.py
-   ├── web/
-   │   ├── templates/
-   │   │   ├── base.html
-   │   │   └── index.html
-   │   ├── __init__.py
-   │   ├── apps.py
-   │   ├── tests.py
-   │   ├── urls.py
-   │   └── views.py
-   ├── manage.py
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``githubnavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/django/githubnavigator/containers.py
-   :language: python
-
-Container instance is created in ``githubnavigator/__init__.py``:
-
-.. literalinclude:: ../../examples/miniapps/django/githubnavigator/__init__.py
-   :language: python
-
-Views
------
-
-View has dependencies on search service and some config options. The dependencies are injected
-using :ref:`wiring` feature.
-
-Listing of ``web/views.py``:
-
-.. literalinclude:: ../../examples/miniapps/django/web/views.py
-   :language: python
-
-App config
-----------
-
-Container is wired to the ``views`` module in the app config ``web/apps.py``:
-
-.. literalinclude:: ../../examples/miniapps/django/web/apps.py
-   :language: python
-   :emphasize-lines: 13
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace github client with a mock ``web/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/django/web/tests.py
-   :language: python
-   :emphasize-lines: 39,60
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/django>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/fastapi-redis.rst

@@ -1,100 +0,0 @@
-.. _fastapi-redis-example:
-
-FastAPI + Redis example
-=======================
-
-.. meta::
-   :keywords: Python,Dependency Injection,FastAPI,Redis,Example
-   :description: This example demonstrates a usage of the FastAPI, Redis, and Dependency Injector.
-
-This example shows how to use ``Dependency Injector`` with `FastAPI <https://fastapi.tiangolo.com/>`_ and
-`Redis <https://redis.io/>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi-redis>`_.
-
-See also:
-
-- Provider :ref:`async-injections`
-- Resource provider :ref:`resource-async-initializers`
-- Wiring :ref:`async-injections-wiring`
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── fastapiredis/
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── redis.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── docker-compose.yml
-   ├── Dockerfile
-   └── requirements.txt
-
-Redis
------
-
-Module ``redis`` defines Redis connection pool initialization and shutdown. See ``fastapiredis/redis.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-redis/fastapiredis/redis.py
-   :language: python
-
-Service
--------
-
-Module ``services`` contains example service. Service has a dependency on Redis connection pool.
-It uses it for getting and setting a key asynchronously. Real life service will do something more meaningful.
-See ``fastapiredis/services.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-redis/fastapiredis/services.py
-   :language: python
-
-Container
----------
-
-Declarative container wires example service with Redis connection pool. See ``fastapiredis/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-redis/fastapiredis/containers.py
-   :language: python
-
-Application
------------
-
-Module ``application`` creates ``FastAPI`` app, setup endpoint, and init container.
-
-Endpoint ``index`` has a dependency on example service. The dependency is injected using :ref:`wiring` feature.
-
-Listing of ``fastapiredis/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-redis/fastapiredis/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace example service with a mock. See ``fastapiredis/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-redis/fastapiredis/tests.py
-   :language: python
-   :emphasize-lines: 24
-
-Sources
--------
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi-redis>`_.
-
-See also:
-
-- Provider :ref:`async-injections`
-- Resource provider :ref:`resource-async-initializers`
-- Wiring :ref:`async-injections-wiring`
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/fastapi-sqlalchemy.rst

@@ -1,121 +0,0 @@
-.. _fastapi-sqlalchemy-example:
-
-FastAPI + SQLAlchemy example
-============================
-
-.. meta::
-   :keywords: Python,Dependency Injection,FastAPI,SQLAlchemy,Example
-   :description: This example demonstrates a usage of the FastAPI, SQLAlchemy, and Dependency Injector.
-
-This example shows how to use ``Dependency Injector`` with `FastAPI <https://fastapi.tiangolo.com/>`_ and
-`SQLAlchemy <https://www.sqlalchemy.org/>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi-sqlalchemy>`_.
-
-Thanks to `@ShvetsovYura <https://github.com/ShvetsovYura>`_ for providing initial example:
-`FastAPI_DI_SqlAlchemy <https://github.com/ShvetsovYura/FastAPI_DI_SqlAlchemy>`_.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── webapp/
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── database.py
-   │   ├── endpoints.py
-   │   ├── models.py
-   │   ├── repositories.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── config.yml
-   ├── docker-compose.yml
-   ├── Dockerfile
-   └── requirements.txt
-
-Application factory
--------------------
-
-Application factory creates container, wires it with the ``endpoints`` module, creates
-``FastAPI`` app, and setup routes.
-
-Application factory also creates database if it does not exist.
-
-Listing of ``webapp/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/application.py
-   :language: python
-
-Endpoints
----------
-
-Module ``endpoints`` contains example endpoints. Endpoints have a dependency on user service.
-User service is injected using :ref:`wiring` feature. See ``webapp/endpoints.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/endpoints.py
-   :language: python
-
-Container
----------
-
-Declarative container wires example user service, user repository, and utility database class.
-See ``webapp/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/containers.py
-   :language: python
-
-Services
---------
-
-Module ``services`` contains example user service. See ``webapp/services.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/services.py
-   :language: python
-
-Repositories
-------------
-
-Module ``repositories`` contains example user repository. See ``webapp/repositories.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/repositories.py
-   :language: python
-
-Models
-------
-
-Module ``models`` contains example SQLAlchemy user model. See ``webapp/models.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/models.py
-   :language: python
-
-Database
---------
-
-Module ``database`` defines declarative base and utility class with engine and session factory.
-See ``webapp/database.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/database.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace repository with a mock. See ``webapp/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi-sqlalchemy/webapp/tests.py
-   :language: python
-   :emphasize-lines: 25, 45, 58, 74, 86, 97
-
-Sources
--------
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi-sqlalchemy>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/fastapi.rst

@@ -1,81 +0,0 @@
-.. _fastapi-example:
-
-FastAPI example
-===============
-
-.. meta::
-   :keywords: Python,Dependency Injection,FastAPI,Example
-   :description: This example demonstrates a usage of the FastAPI and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `FastAPI <https://fastapi.tiangolo.com/>`_.
-
-The example application is a REST API that searches for funny GIFs on the `Giphy <https://giphy.com/>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi>`_.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── giphynavigator/
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── endpoints.py
-   │   ├── giphy.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── config.yml
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``giphynavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi/giphynavigator/containers.py
-   :language: python
-
-Endpoints
----------
-
-Endpoint has a dependency on search service. There are also some config options that are used as default values.
-The dependencies are injected using :ref:`wiring` feature.
-
-Listing of ``giphynavigator/endpoints.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi/giphynavigator/endpoints.py
-   :language: python
-
-Application factory
--------------------
-Application factory creates container, wires it with the ``endpoints`` module, creates
-``FastAPI`` app, and setup routes.
-
-Listing of ``giphynavigator/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi/giphynavigator/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace giphy client with a mock ``giphynavigator/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/fastapi/giphynavigator/tests.py
-   :language: python
-   :emphasize-lines: 29,57,72
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/fastapi>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/flask-blueprints.rst

@@ -1,91 +0,0 @@
-.. _flask-blueprints-example:
-
-Flask blueprints example
-========================
-
-.. meta::
-   :keywords: Python,Dependency Injection,Flask,Blueprints,Example
-   :description: This example demonstrates a usage of the Flask Blueprints and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Flask <https://flask.palletsprojects.com/en/1.1.x/>`_
-blueprints.
-
-The example application helps to search for repositories on the Github.
-
-.. image:: images/flask.png
-    :width: 100%
-    :align: center
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/flask-blueprints>`_.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── githubnavigator/
-   │   ├── blueprints
-   │   │   ├── __init__.py
-   │   │   └── example.py
-   │   ├── templates
-   │   │   ├── base.html
-   │   │   └── index.py
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── config.yml
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``githubnavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask-blueprints/githubnavigator/containers.py
-   :language: python
-
-Blueprints
-----------
-
-Blueprint's view has dependencies on search service and some config options. The dependencies are injected
-using :ref:`wiring` feature.
-
-Listing of ``githubnavigator/blueprints/example.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask-blueprints/githubnavigator/blueprints/example.py
-   :language: python
-
-Application factory
--------------------
-
-Application factory creates container, wires it with the blueprints, creates
-``Flask`` app, and setup routes.
-
-Listing of ``githubnavigator/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask-blueprints/githubnavigator/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace github client with a mock ``githubnavigator/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask-blueprints/githubnavigator/tests.py
-   :language: python
-   :emphasize-lines: 44,67
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/flask-blueprints>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/flask.rst

@@ -1,89 +0,0 @@
-.. _flask-example:
-
-Flask example
-=============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Flask,Example
-   :description: This example demonstrates a usage of the Flask and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Flask <https://flask.palletsprojects.com/en/1.1.x/>`_.
-
-The example application helps to search for repositories on the Github.
-
-.. image:: images/flask.png
-    :width: 100%
-    :align: center
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/flask>`_.
-
-:ref:`flask-tutorial` demonstrates how to build this application step-by-step.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── githubnavigator/
-   │   ├── templates
-   │   │   ├── base.html
-   │   │   └── index.py
-   │   ├── __init__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── services.py
-   │   ├── tests.py
-   │   └── views.py
-   ├── config.yml
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``githubnavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask/githubnavigator/containers.py
-   :language: python
-
-Views
------
-
-View has dependencies on search service and some config options. The dependencies are injected
-using :ref:`wiring` feature.
-
-Listing of ``githubnavigator/views.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask/githubnavigator/views.py
-   :language: python
-
-Application factory
--------------------
-Application factory creates container, wires it with the ``views`` module, creates
-``Flask`` app and setup routes.
-
-Listing of ``githubnavigator/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask/githubnavigator/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace github client with a mock ``githubnavigator/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/flask/githubnavigator/tests.py
-   :language: python
-   :emphasize-lines: 44,67
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/flask>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/examples/index.rst

@@ -2,25 +2,17 @@ Examples
 ========
 
 .. meta::
-   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control,Example
-   :description: Python dependency injection examples.
+   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
+   :description: Current section of documentation is designed to provide 
+                 several example mini applications that are built on the top 
+                 of inversion of control principle and powered by 
+                 "Dependency Injector" framework.
 
-Explore the examples to see the ``Dependency Injector`` in action.
+Current section of documentation is designed to provide several example mini 
+applications that are built according to the inversion of control principle 
+and powered by *Dependency Injector* framework.
 
 ..  toctree::
     :maxdepth: 2
 
-    application-single-container
-    application-multiple-containers
-    decoupled-packages
-    boto3
-    django
-    flask
-    flask-blueprints
-    aiohttp
-    sanic
-    fastapi
-    fastapi-redis
-    fastapi-sqlalchemy
-
-.. disqus::
+    movie_lister

docs/examples/movie_lister.rst

@@ -0,0 +1,126 @@
+Movie lister naive example
+--------------------------
+
+.. meta::
+   :description: Movie lister - is a naive example of dependency injection and 
+                 inversion of control containers on Python. Original example 
+                 was taken from Martin Fowler's article about dependency 
+                 injection and inversion of control.
+
+This naive example was taken from Martin Fowler's article about dependency 
+injection and inversion of control: http://www.martinfowler.com/articles/injection.html
+
+Like Martin says:
+
+.. pull-quote::
+
+    *Like all of my examples it's one of those super-simple examples; 
+    small enough to be unreal, but hopefully enough for you to visualize 
+    what's going on without falling into the bog of a real example.*
+
+While original Martin's MovieLister example was a bit modified here, it 
+makes sense to provide some description. So, the idea of this example is to 
+create ``movies`` library that can be configured to work with different 
+movie databases (csv, sqlite, etc...) and provide 2 main features:
+
+1. List all movies that were directed by certain person.
+2. List all movies that were released in certain year.
+
+Also this example contains 3 mini applications that are based on ``movies`` 
+library:
+
+1. ``app_csv.py`` - list movies by certain criteria from csv file database.
+2. ``app_db.py`` - list movies by certain criteria from sqlite database.
+3. ``app_db_csv.py`` - list movies by certain criteria from csv file and 
+   sqlite databases.
+
+Instructions for running:
+
+.. code-block:: bash
+
+    python app_csv.py
+    python app_db.py
+    python app_db_csv.py
+
+
+Full code of example could be found on GitHub_. 
+
+Movies library
+~~~~~~~~~~~~~~
+
+Classes diagram:
+
+.. image:: /images/miniapps/movie_lister/classes.png
+    :width: 100%
+    :align: center
+
+
+Movies library structure:
+
+.. code-block:: bash
+
+    /movies
+        /__init__.py
+        /finders.py
+        /listers.py
+        /models.py
+
+
+Listing of ``movies/__init__.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/movies/__init__.py
+   :language: python
+   :linenos:
+
+Example application
+~~~~~~~~~~~~~~~~~~~
+
+Example application structure:
+
+.. code-block:: bash
+
+    /example
+        /__init__.py
+        /db.py
+        /main.py
+
+Listing of ``examples/main.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/example/main.py
+   :language: python
+   :linenos:
+
+Listing of ``examples/db.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/example/db.py
+   :language: python
+   :linenos:
+
+Csv application
+~~~~~~~~~~~~~~~
+
+Listing of ``app_csv.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/app_csv.py
+   :language: python
+   :linenos:
+
+Database application
+~~~~~~~~~~~~~~~~~~~~
+
+Listing of ``app_db.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/app_db.py
+   :language: python
+   :linenos:
+
+Csv and database application
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Listing of ``app_db_csv.py``:
+
+.. literalinclude:: ../../examples/miniapps/movie_lister/app_db_csv.py
+   :language: python
+   :linenos:
+
+.. _GitHub: https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/movie_lister

docs/examples/sanic.rst

@@ -1,82 +0,0 @@
-.. _sanic-example:
-
-Sanic example
-==============
-
-.. meta::
-   :keywords: Python,Dependency Injection,Sanic,Example
-   :description: This example demonstrates a usage of the Sanic and Dependency Injector.
-
-
-This example shows how to use ``Dependency Injector`` with `Sanic <https://sanic.readthedocs.io/en/latest/>`_.
-
-The example application is a REST API that searches for funny GIFs on the `Giphy <https://giphy.com/>`_.
-
-The source code is available on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/sanic>`_.
-
-Application structure
----------------------
-
-Application has next structure:
-
-.. code-block:: bash
-
-   ./
-   ├── giphynavigator/
-   │   ├── __init__.py
-   │   ├── __main__.py
-   │   ├── application.py
-   │   ├── containers.py
-   │   ├── giphy.py
-   │   ├── handlers.py
-   │   ├── services.py
-   │   └── tests.py
-   ├── config.yml
-   └── requirements.txt
-
-Container
----------
-
-Declarative container is defined in ``giphynavigator/containers.py``:
-
-.. literalinclude:: ../../examples/miniapps/sanic/giphynavigator/containers.py
-   :language: python
-
-Handlers
---------
-
-Handler has dependencies on search service and some config options. The dependencies are injected
-using :ref:`wiring` feature.
-
-Listing of ``giphynavigator/handlers.py``:
-
-.. literalinclude:: ../../examples/miniapps/sanic/giphynavigator/handlers.py
-   :language: python
-
-Application factory
--------------------
-Application factory creates container, wires it with the ``handlers`` module, creates
-``Sanic`` app and setup routes.
-
-Listing of ``giphynavigator/application.py``:
-
-.. literalinclude:: ../../examples/miniapps/sanic/giphynavigator/application.py
-   :language: python
-
-Tests
------
-
-Tests use :ref:`provider-overriding` feature to replace giphy client with a mock ``giphynavigator/tests.py``:
-
-.. literalinclude:: ../../examples/miniapps/sanic/giphynavigator/tests.py
-   :language: python
-   :emphasize-lines: 34,61,75
-
-Sources
--------
-
-Explore the sources on the `Github <https://github.com/ets-labs/python-dependency-injector/tree/master/examples/miniapps/sanic>`_.
-
-.. include:: ../sponsor.rst
-
-.. disqus::

docs/index.rst

@@ -1,150 +1,66 @@
-=================================================================
-Dependency Injector --- Dependency injection framework for Python
-=================================================================
+======================================================================
+Dependency Injector --- Dependency injection microframework for Python
+======================================================================
 
 .. meta::
-   :google-site-verification: V1hlKfpgL3AARAElwFcqP4qW1Smsx5bKSRU8O86i20Y
-   :keywords: Python,Dependency injection,DI,Inversion of Control,IoC,
-              IoC Container,Factory, Singleton, Design Patterns
-   :description: Dependency Injector is a dependency injection framework
-                 for Python. It helps to maintain you application structure.
-                 It was designed to be unified, developer-friendly
-                 tool that helps to implement dependency injection design
-                 pattern in formal, pretty, Pythonic way. Dependency Injector
-                 provides implementations of such popular design patterns
-                 like IoC container, Factory and Singleton. Dependency
-                 Injector providers are implemented as C extension types
-                 using Cython.
+   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
+   :google-site-verification: 6it89zX0_wccKEhAqbAiYQooS95f0BA8YfesHk6bsNA
+   :description: Dependency Injector is a dependency injection microframework 
+                 for Python. It was designed to be unified, developer-friendly 
+                 tool that helps to implement dependency injection pattern in 
+                 formal, pretty, Pythonic way.
 
-.. _index:
+*Dependency Injector* is a dependency injection microframework for Python. 
+It was designed to be unified, developer-friendly tool that helps to implement 
+dependency injection pattern in formal, pretty, Pythonic way.
 
-.. image:: https://img.shields.io/pypi/v/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Latest Version
+*Dependency Injector* framework key features are:
 
-.. image:: https://img.shields.io/pypi/l/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: License
++ Easy, smart, pythonic style.
++ Obvious, clear structure.
++ Extensibility and flexibility.
++ Memory efficiency.
++ Thread safety.
++ Documentation.
++ Semantic versioning.
 
-.. image:: https://img.shields.io/pypi/pyversions/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Supported Python versions
+Status
+------
 
-.. image:: https://img.shields.io/pypi/implementation/dependency_injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Supported Python implementations
-
-.. image:: https://static.pepy.tech/badge/dependency-injector
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
-
-.. image:: https://static.pepy.tech/badge/dependency-injector/month
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
-
-.. image:: https://static.pepy.tech/badge/dependency-injector/week
-   :target: https://pepy.tech/project/dependency-injector
-   :alt: Downloads
-
-.. image:: https://img.shields.io/pypi/wheel/dependency-injector.svg
-   :target: https://pypi.org/project/dependency-injector/
-   :alt: Wheel
-
-.. image:: https://img.shields.io/github/actions/workflow/status/ets-labs/python-dependency-injector/tests-and-linters.yml?branch=master
-   :target: https://github.com/ets-labs/python-dependency-injector/actions
-   :alt: Build Status
-
-.. image:: https://coveralls.io/repos/github/ets-labs/python-dependency-injector/badge.svg?branch=master
-   :target: https://coveralls.io/github/ets-labs/python-dependency-injector?branch=master
-   :alt: Coverage Status
-
-``Dependency Injector`` is a dependency injection framework for Python.
-
-It helps implementing the dependency injection principle.
-
-Key features of the ``Dependency Injector``:
-
-- **Providers**. Provides ``Factory``, ``Singleton``, ``Callable``, ``Coroutine``, ``Object``,
-  ``List``, ``Dict``, ``Configuration``, ``Resource``, ``Dependency``, and ``Selector`` providers
-  that help assemble your objects. See :ref:`providers`.
-- **Overriding**. Can override any provider by another provider on the fly. This helps in testing
-  and configuring dev/stage environment to replace API clients with stubs etc. See
-  :ref:`provider-overriding`.
-- **Configuration**. Reads configuration from ``yaml``, ``ini``, and ``json`` files, ``pydantic`` settings,
-  environment variables, and dictionaries. See :ref:`configuration-provider`.
-- **Resources**. Helps with initialization and configuring of logging, event loop, thread
-  or process pool, etc. Can be used for per-function execution scope in tandem with wiring.
-  See :ref:`resource-provider`.
-- **Containers**. Provides declarative and dynamic containers. See :ref:`containers`.
-- **Wiring**. Injects dependencies into functions and methods. Helps integrate with
-  other frameworks: Django, Flask, Aiohttp, Sanic, FastAPI, etc. See :ref:`wiring`.
-- **Asynchronous**. Supports asynchronous injections. See :ref:`async-injections`.
-- **Typing**. Provides typing stubs, ``mypy``-friendly. See :ref:`provider-typing`.
-- **Performance**. Fast. Written in ``Cython``.
-- **Maturity**. Mature and production-ready. Well-tested, documented, and supported.
-
-.. code-block:: python
-
-   from dependency_injector import containers, providers
-   from dependency_injector.wiring import Provide, inject
-
-
-   class Container(containers.DeclarativeContainer):
-
-       config = providers.Configuration()
-
-       api_client = providers.Singleton(
-           ApiClient,
-           api_key=config.api_key,
-           timeout=config.timeout,
-       )
-
-       service = providers.Factory(
-           Service,
-           api_client=api_client,
-       )
-
-
-   @inject
-   def main(service: Service = Provide[Container.service]) -> None:
-       ...
-
-
-   if __name__ == "__main__":
-       container = Container()
-       container.config.api_key.from_env("API_KEY", required=True)
-       container.config.timeout.from_env("TIMEOUT", as_=int, default=5)
-       container.wire(modules=[__name__])
-
-       main()  # <-- dependency is injected automatically
-
-       with container.api_client.override(mock.Mock()):
-           main()  # <-- overridden dependency is injected automatically
-
-With the ``Dependency Injector``, object assembling is consolidated in the container.
-Dependency injections are defined explicitly.
-This makes it easier to understand and change how the application works.
-
-.. figure:: https://raw.githubusercontent.com/wiki/ets-labs/python-dependency-injector/img/di-readme.svg
-   :target: https://github.com/ets-labs/python-dependency-injector
-
-Explore the documentation to know more about the ``Dependency Injector``.
-
-.. _contents:
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *PyPi*                                | .. image:: https://img.shields.io/pypi/v/dependency_injector.svg                       |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Latest Version                                                                |
+|                                       | .. image:: https://img.shields.io/pypi/l/dependency_injector.svg                       |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: License                                                                       |
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *Python versions and implementations* | .. image:: https://img.shields.io/pypi/pyversions/dependency_injector.svg              |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Supported Python versions                                                     |
+|                                       | .. image:: https://img.shields.io/pypi/implementation/dependency_injector.svg          |
+|                                       |    :target: https://pypi.python.org/pypi/dependency_injector/                          |
+|                                       |    :alt: Supported Python implementations                                              |
++---------------------------------------+----------------------------------------------------------------------------------------+
+| *Builds and tests coverage*           | .. image:: https://travis-ci.org/ets-labs/python-dependency-injector.svg?branch=master |
+|                                       |    :target: https://travis-ci.org/ets-labs/python-dependency-injector                  |
+|                                       |    :alt: Build Status                                                                  |
+|                                       | .. image:: https://coveralls.io/repos/ets-labs/python-dependency-injector/badge.svg    |
+|                                       |    :target: https://coveralls.io/r/ets-labs/python-dependency-injector                 |
+|                                       |    :alt: Coverage Status                                                               |
++---------------------------------------+----------------------------------------------------------------------------------------+
 
 Contents
 --------
 
-.. toctree::
-   :maxdepth: 2
+..  toctree::
+    :maxdepth: 2
 
-   introduction/index
-   examples/index
-   tutorials/index
-   providers/index
-   containers/index
-   wiring
-   examples-other/index
-   api/index
-   main/feedback
-   main/changelog
+    introduction/index
+    main/installation
+    providers/index
+    containers/index
+    examples/index
+    api/index
+    main/feedback
+    main/changelog

docs/introduction/di_in_python.rst

@@ -1,315 +1,127 @@
 Dependency injection and inversion of control in Python
-=======================================================
+-------------------------------------------------------
 
 .. meta::
-   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control,Example
-   :description: This page describes a usage of the dependency injection and inversion of control
-                 in Python. It contains Python examples that show how to implement dependency
-                 injection. It demonstrates a usage of the dependency injection framework
-                 Dependency Injector, its container, Factory, Singleton and Configuration
-                 providers. The example show how to use Dependency Injector providers overriding
-                 feature for testing or configuring project in different environments and explains
-                 why it's better than monkey-patching.
+   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
+   :description: This article describes benefits of dependency injection and 
+                 inversion of control for Python applications. Also it 
+                 contains some Python examples that show how dependency 
+                 injection and inversion could be implemented.
+
+History
+~~~~~~~
+
+Originally, dependency injection pattern got popular in languages with static 
+typing, like Java. Dependency injection framework can 
+significantly improve flexibility of the language with static typing. Also,
+implementation of dependency injection framework for language with static 
+typing is not something that one can do shortly, it could be quite complex 
+thing to be done well.
+
+While Python is very flexible interpreted language with dynamic typing, there 
+is a meaning that dependency injection doesn't work for it as well, as it does 
+for Java. Also there is a meaning that dependency injection framework is 
+something that Python developer would not ever need, cause dependency injection
+could be implemented easily using language fundamentals.
+
+Discussion
+~~~~~~~~~~
+
+It is true. 
+
+Partly.
+
+Dependency injection, as a software design pattern, has number of 
+advantages that are common for each language (including Python):
+
++ Dependency Injection decreases coupling between a class and its dependency.
++ Because dependency injection doesn't require any change in code behavior it 
+  can be applied to legacy code as a refactoring. The result is clients that 
+  are more independent and that are easier to unit test in isolation using 
+  stubs or mock objects that simulate other objects not under test. This ease 
+  of testing is often the first benefit noticed when using dependency 
+  injection.
++ Dependency injection can be used to externalize a system's configuration 
+  details into configuration files allowing the system to be reconfigured 
+  without recompilation (rebuilding). Separate configurations can be written 
+  for different situations that require different implementations of 
+  components. This includes, but is not limited to, testing.
++ Reduction of boilerplate code in the application objects since all work to 
+  initialize or set up dependencies is handled by a provider component.
++ Dependency injection allows a client to remove all knowledge of a concrete 
+  implementation that it needs to use. This helps isolate the client from the 
+  impact of design changes and defects. It promotes reusability, testability 
+  and maintainability.
++ Dependency injection allows a client the flexibility of being configurable. 
+  Only the client's behavior is fixed. The client may act on anything that 
+  supports the intrinsic interface the client expects.
+
+.. note::
+
+    While improved testability is one the first benefits of using dependency 
+    injection, it could be easily overwhelmed by monkey-patching technique, 
+    that works absolutely great in Python (you can monkey-patch anything, 
+    anytime).  At the same time, monkey-patching has nothing similar with 
+    other advantages defined above. Also monkey-patching technique is 
+    something that could be considered like too dirty to be used in production.
+
+The complexity of dependency injection pattern implementation in Python is 
+definitely quite lower than in other languages (even with dynamic typing). 
+
+.. note:: 
+
+    Low complexity of dependency injection pattern implementation in Python 
+    still means that some code should be written, reviewed, tested and 
+    supported.
+
+Talking about inversion of control, it is a software design principle that 
+also works for each programming language, not dependending on its typing type.
+
+Inversion of control is used to increase modularity of the program and make 
+it extensible.
+
+Main design purposes of using inversion of control are:
+
++ To decouple the execution of a task from implementation.
++ To focus a module on the task it is designed for.
++ To free modules from assumptions about how other systems do what they do and 
+  instead rely on contracts.
++ To prevent side effects when replacing a module.
+
+Example
+~~~~~~~
+
+Let's go through next example:
+
+.. literalinclude:: ../../examples/ioc_di_demos/car_engine.py
+   :language: python
+   :linenos:
+
+``Car`` **creates** an ``Engine`` during its creation. Really? Does it make 
+more sense than creating an ``Engine`` separately and then 
+**inject (put) it into** ``Car`` when ``Car`` is being created?
+
+.. literalinclude:: ../../examples/ioc_di_demos/car_engine_ioc.py
+   :language: python
+   :linenos:
+
+Previous example may look more obvious and gives a chance to start getting 
+other benefits of dependency injection and inversion of control, but creation 
+of ``Car`` instances became a bit harder cause now ``Engine`` injections 
+should be done manually every time when ``Car`` instances are being created.
+
+Let's automate ``Engine`` into ``Car`` injections using *Dependency Injector*:
+
+
+.. literalinclude:: ../../examples/ioc_di_demos/car_engine_ioc_container.py
+   :language: python
+   :linenos:
 
-Originally dependency injection pattern got popular in languages with static typing like Java.
-Dependency injection is a principle that helps to achieve an inversion of control. A
-dependency injection framework can significantly improve the flexibility of a language
-with static typing. Implementation of a dependency injection framework for a language
-with static typing is not something that one can do quickly. It will be a quite complex thing
-to be done well. And will take time.
+.. note::
 
-Python is an interpreted language with dynamic typing. There is an opinion that dependency
-injection doesn't work for it as well as it does for Java. A lot of the flexibility is already
-built-in. Also, there is an opinion that a dependency injection framework is something that
-Python developer rarely needs. Python developers say that dependency injection can be implemented
-easily using language fundamentals.
+    ``Container`` from previous example is an inversion of control container. 
+    It contains a collection of component providers that could be injected 
+    into each other. 
 
-This page describes the advantages of applying dependency injection in Python. It
-contains Python examples that show how to implement dependency injection. It demonstrates the usage
-of the ``Dependency Injector`` framework, its container, ``Factory``, ``Singleton``,
-and ``Configuration`` providers. The example shows how to use providers' overriding feature
-of ``Dependency Injector`` for testing or re-configuring a project in different environments and
-explains why it's better than monkey-patching.
-
-What is dependency injection?
------------------------------
-
-Let's see what the dependency injection is.
-
-Dependency injection is a principle that helps to decrease coupling and increase cohesion.
-
-.. image:: images/coupling-cohesion.png
-
-What is coupling and cohesion?
-
-Coupling and cohesion are about how tough the components are tied.
-
-- **High coupling**. If the coupling is high it's like using superglue or welding. No easy way
-  to disassemble.
-- **High cohesion**. High cohesion is like using screws. Quite easy to disassemble and
-  re-assemble in a different way. It is an opposite to high coupling.
-
-Cohesion often correlates with coupling. Higher cohesion usually leads to lower coupling and vice versa.
-
-Low coupling brings flexibility. Your code becomes easier to change and test.
-
-How to implement the dependency injection?
-
-Objects do not create each other anymore. They provide a way to inject the dependencies instead.
-
-Before:
-
-.. code-block:: python
-
-   import os
-
-
-   class ApiClient:
-
-       def __init__(self) -> None:
-           self.api_key = os.getenv("API_KEY")  # <-- dependency
-           self.timeout = int(os.getenv("TIMEOUT"))  # <-- dependency
-
-
-   class Service:
-
-       def __init__(self) -> None:
-           self.api_client = ApiClient()  # <-- dependency
-
-
-   def main() -> None:
-       service = Service()  # <-- dependency
-       ...
-
-
-   if __name__ == "__main__":
-       main()
-
-After:
-
-.. code-block:: python
-
-   import os
-
-
-   class ApiClient:
-
-       def __init__(self, api_key: str, timeout: int) -> None:
-           self.api_key = api_key  # <-- dependency is injected
-           self.timeout = timeout  # <-- dependency is injected
-
-
-   class Service:
-
-       def __init__(self, api_client: ApiClient) -> None:
-           self.api_client = api_client  # <-- dependency is injected
-
-
-   def main(service: Service) -> None:  # <-- dependency is injected
-       ...
-
-
-   if __name__ == "__main__":
-       main(
-           service=Service(
-               api_client=ApiClient(
-                   api_key=os.getenv("API_KEY"),
-                   timeout=int(os.getenv("TIMEOUT")),
-               ),
-           ),
-       )
-
-``ApiClient`` is decoupled from knowing where the options come from. You can read a key and a
-timeout from a configuration file or even get them from a database.
-
-``Service`` is decoupled from the ``ApiClient``. It does not create it anymore. You can provide a
-stub or other compatible object.
-
-Function ``main()`` is decoupled from ``Service``. It receives it as an argument.
-
-Flexibility comes with a price.
-
-Now you need to assemble and inject the objects like this:
-
-.. code-block:: python
-
-   main(
-       service=Service(
-           api_client=ApiClient(
-               api_key=os.getenv("API_KEY"),
-               timeout=int(os.getenv("TIMEOUT")),
-           ),
-       ),
-   )
-
-The assembly code might get duplicated and it'll become harder to change the application structure.
-
-Here comes the ``Dependency Injector``.
-
-What does the Dependency Injector do?
--------------------------------------
-
-With the dependency injection pattern, objects lose the responsibility of assembling
-the dependencies. The ``Dependency Injector`` absorbs that responsibility.
-
-``Dependency Injector`` helps to assemble and inject the dependencies.
-
-It provides a container and providers that help you with the objects assembly.
-When you need an object you place a ``Provide`` marker as a default value of a
-function argument. When you call this function, framework assembles and injects
-the dependency.
-
-.. code-block:: python
-
-   from dependency_injector import containers, providers
-   from dependency_injector.wiring import Provide, inject
-
-
-   class Container(containers.DeclarativeContainer):
-
-       config = providers.Configuration()
-
-       api_client = providers.Singleton(
-           ApiClient,
-           api_key=config.api_key,
-           timeout=config.timeout,
-       )
-
-       service = providers.Factory(
-           Service,
-           api_client=api_client,
-       )
-
-
-   @inject
-   def main(service: Service = Provide[Container.service]) -> None:
-       ...
-
-
-   if __name__ == "__main__":
-       container = Container()
-       container.config.api_key.from_env("API_KEY", required=True)
-       container.config.timeout.from_env("TIMEOUT", as_=int, default=5)
-       container.wire(modules=[__name__])
-
-       main()  # <-- dependency is injected automatically
-
-       with container.api_client.override(mock.Mock()):
-           main()  # <-- overridden dependency is injected automatically
-
-When you call the ``main()`` function the ``Service`` dependency is assembled and injected automatically.
-
-When you do testing, you call the ``container.api_client.override()`` method to replace the real API
-client with a mock. When you call ``main()``, the mock is injected.
-
-You can override any provider with another provider.
-
-It also helps you in a re-configuring project for different environments: replace an API client
-with a stub on the dev or stage.
-
-Objects assembling is consolidated in a container. Dependency injections are defined explicitly.
-This makes it easier to understand and change how an application works.
-
-Testing, Monkey-patching and dependency injection
--------------------------------------------------
-
-The testability benefit is opposed to monkey-patching.
-
-In Python, you can monkey-patch anything, anytime. The problem with monkey-patching is
-that it's too fragile. The cause of it is that when you monkey-patch you do something that
-wasn't intended to be done. You monkey-patch the implementation details. When implementation
-changes the monkey-patching is broken.
-
-With dependency injection, you patch the interface, not an implementation. This is a way more
-stable approach.
-
-Also, monkey-patching is way too dirty to be used outside of the testing code for
-re-configuring the project for the different environments.
-
-Conclusion
-----------
-
-Dependency injection provides you with three advantages:
-
-- **Flexibility**. The components are loosely coupled. You can easily extend or change the
-  functionality of a system by combining the components in a different way. You even can do it on
-  the fly.
-- **Testability**. Testing is easier because you can easily inject mocks instead of real objects
-  that use API or database, etc.
-- **Clearness and maintainability**. Dependency injection helps you reveal the dependencies.
-  Implicit becomes explicit. And "Explicit is better than implicit" (PEP 20 - The Zen of Python).
-  You have all the components and dependencies defined explicitly in a container. This
-  provides an overview and control of the application structure. It is easier to understand and
-  change it.
-
-Is it worth applying dependency injection in Python?
-
-It depends on what you build. The advantages above are not too important if you use Python as a
-scripting language. The picture is different when you use Python to create an application. The
-larger the application the more significant the benefits.
-
-Is it worth using a framework for applying dependency injection?
-
-The complexity of the dependency injection pattern implementation in Python is
-lower than in other languages but it's still in place. It doesn't mean you have to use a
-framework but using a framework is beneficial because the framework is:
-
-- Already implemented
-- Tested on all platforms and versions of Python
-- Documented
-- Supported
-- Other engineers are familiar with it
-
-An advice at last:
-
-- **Give it a try**. Dependency injection is counter-intuitive. Our nature is that
-  when we need something the first thought that comes to our mind is to go and get it. Dependency
-  injection is just like "Wait, I need to state a need instead of getting something right away".
-  It's like a little investment that will pay-off later. The advice is to just give it a try for
-  two weeks. This time will be enough for getting your own impression. If you don't like it you
-  won't lose too much.
-- **Common sense first**. Use common sense when applying dependency injection. It is a good
-  principle, but not a silver bullet. If you do it too much you will reveal too many of the
-  implementation details. Experience comes with practice and time.
-
-What's next?
-------------
-
-Choose one of the following as a next step:
-
-- Look at the application examples:
-    - :ref:`application-single-container`
-    - :ref:`application-multiple-containers`
-    - :ref:`decoupled-packages`
-    - :ref:`boto3-example`
-    - :ref:`django-example`
-    - :ref:`flask-example`
-    - :ref:`flask-blueprints-example`
-    - :ref:`aiohttp-example`
-    - :ref:`sanic-example`
-    - :ref:`fastapi-example`
-    - :ref:`fastapi-redis-example`
-    - :ref:`fastapi-sqlalchemy-example`
-- Pass the tutorials:
-    - :ref:`flask-tutorial`
-    - :ref:`aiohttp-tutorial`
-    - :ref:`asyncio-daemon-tutorial`
-    - :ref:`cli-tutorial`
-- Know more about the ``Dependency Injector`` :ref:`key-features`
-- Know more about the :ref:`providers`
-- Know more about the :ref:`wiring`
-- Go to the :ref:`contents`
-
-Useful links
-------------
-
-A few useful links related to a dependency injection design pattern for further reading:
-
-+ https://en.wikipedia.org/wiki/Dependency_injection
-+ https://martinfowler.com/articles/injection.html
-+ https://github.com/ets-labs/python-dependency-injector
-+ https://pypi.org/project/dependency-injector/
-
-.. include:: ../sponsor.rst
-
-.. disqus::
+    Assuming this, ``Container`` could be one and the only place, where 
+    application's structure is being managed on the high level.

docs/introduction/index.rst

@@ -3,16 +3,18 @@ Introduction
 
 .. meta::
    :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
-   :description: Current section of the documentation is provides an
-                 overview of the dependency injection, inversion of
-                 control and Dependency Injector framework.
+   :description: Current section of documentation is designed to give some 
+                 overview about dependency injection pattern, inversion of 
+                 control principle and "Dependency Injector" framework.
 
-The current section of the documentation provides an overview of the
-dependency injection, inversion of control, and the ``Dependency Injector`` framework.
+Current section of documentation is designed to give some overview about 
+dependency injection pattern, inversion of control principle and 
+*Dependency Injector* framework.
 
 ..  toctree::
     :maxdepth: 2
 
+    what_is_di
     di_in_python
     key_features
-    installation
+    structure

docs/introduction/installation.rst

@@ -1,42 +0,0 @@
-Installation
-============
-
-``Dependency Injector`` is available on `PyPI <https://pypi.org/project/dependency-injector/>`_.
-To install the latest version you can use ``pip``:
-
-.. code-block:: bash
-
-    pip install dependency-injector
-
-Some modules of the ``Dependency Injector`` are implemented as C extensions.
-``Dependency Injector`` is distributed as a pre-compiled wheels. Wheels are
-available for all supported Python versions on Linux, Windows, and MacOS.
-Linux distribution uses `manylinux <https://github.com/pypa/manylinux>`_.
-
-If there is no appropriate wheel for your environment (Python version and OS)
-installer will compile the package from sources on your machine. You'll need
-a C compiler and Python header files.
-
-To verify the installed version:
-
-.. code-block:: bash
-
-    >>> import dependency_injector
-    >>> dependency_injector.__version__
-    '4.39.0'
-
-.. note::
-   When adding ``Dependency Injector`` to ``pyproject.toml`` or ``requirements.txt``
-   don't forget to pin the version to the current major:
-
-   .. code-block:: bash
-
-       dependency-injector>=4.0,<5.0
-
-   *The next major version can be incompatible.*
-
-All releases are available on the `PyPI release history page <https://pypi.org/project/dependency-injector/#history>`_.
-Each release has an appropriate tag. The tags are available on the
-`GitHub releases page <https://github.com/ets-labs/python-dependency-injector/releases>`_.
-
-.. disqus::

docs/introduction/key_features.rst

@@ -1,43 +1,45 @@
-.. _key-features:
-
-Key features
-------------
+Key features of Dependency Injector
+-----------------------------------
 
 .. meta::
    :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
-   :description: This article describes key features of the Dependency Injector
-                 framework.
+   :description: This article describes key features of "Dependency Injector" 
+                 framework. It also provides some cases and recommendations 
+                 about usage of "Dependency Injector" framework.
 
-Key features of the ``Dependency Injector``:
+*Dependency Injector* is a dependency injection framework for Python projects. 
+It was designed to be unified, developer-friendly tool for managing any kind
+of Python objects and their dependencies in formal, pretty way.
 
-- **Providers**. Provides ``Factory``, ``Singleton``, ``Callable``, ``Coroutine``, ``Object``,
-  ``List``, ``Dict``, ``Configuration``, ``Resource``, ``Dependency``, and ``Selector`` providers
-  that help assemble your objects. See :ref:`providers`.
-- **Overriding**. Can override any provider by another provider on the fly. This helps in testing
-  and configuring dev/stage environment to replace API clients with stubs etc. See
-  :ref:`provider-overriding`.
-- **Configuration**. Reads configuration from ``yaml``, ``ini``, and ``json`` files, ``pydantic`` settings,
-  environment variables, and dictionaries. See :ref:`configuration-provider`.
-- **Resources**. Helps with initialization and configuring of logging, event loop, thread
-  or process pool, etc. Can be used for per-function execution scope in tandem with wiring.
-  See :ref:`resource-provider`.
-- **Containers**. Provides declarative and dynamic containers. See :ref:`containers`.
-- **Wiring**. Injects dependencies into functions and methods. Helps integrate with
-  other frameworks: Django, Flask, Aiohttp, Sanic, FastAPI, etc. See :ref:`wiring`.
-- **Asynchronous**. Supports asynchronous injections. See :ref:`async-injections`.
-- **Typing**. Provides typing stubs, ``mypy``-friendly. See :ref:`provider-typing`.
-- **Performance**. Fast. Written in ``Cython``.
-- **Maturity**. Mature and production-ready. Well-tested, documented, and supported.
+*Dependency Injector* framework key features are:
 
-The framework stands on the `PEP20 (The Zen of Python) <https://www.python.org/dev/peps/pep-0020/>`_ principle:
++ Easy, smart, pythonic style.
++ Obvious, clear structure.
++ Extensibility and flexibility.
++ Memory efficiency.
++ Thread safety.
++ Documentation.
++ Semantic versioning.
 
-.. code-block:: plain
+*Dependency Injector* framework could be used in different application types:
 
-   Explicit is better than implicit
++ Web applications based on Flask, Django or any other web framework.
++ Asynchronous applications based on asyncio, Tornado and Twisted.
++ Standalone frameworks and libraries.
++ GUI applications.
 
-You need to specify how to assemble and where to inject the dependencies explicitly.
+*Dependency Injector* framework could be integrated on different project 
+stages:
 
-The power of the framework is in its simplicity.
-``Dependency Injector`` is a simple tool for the powerful concept.
++ It could be used in the beginning of development of new applications.
++ It could be integrated into applications that are in active development 
+  stage.
++ It could be used for refactoring of legacy applications.
 
-.. disqus::
+Components of *Dependency Injector* framework could be used:
+
++ In composition with each other.
++ Separately between each other.
+
+Main idea of *Dependency Injector* framework is to be useful tool for the 
+right thing.

docs/introduction/structure.rst

@@ -0,0 +1,47 @@
+Structure of Dependency Injector
+--------------------------------
+
+.. meta::
+   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
+   :description: This article describes "Dependency Injector" framework 
+                 components and their interaction between each other. 
+                 Providers and containers are the former components of 
+                 the framework.
+
+Current section describes *Dependency Injector* main entities and their 
+interaction between each other.
+
+.. image:: /images/internals.png
+    :width: 100%
+    :align: center
+
+There are 2 main entities: providers & containers.
+
+Providers
+~~~~~~~~~
+
+Providers are strategies of accessing objects. For example, 
+:py:class:`dependency_injector.providers.Factory` creates new instance 
+of provided class every time it is called. 
+:py:class:`dependency_injector.providers.Singleton` creates provided 
+instance once and returns it on every next call. Base class is - 
+:py:class:`dependency_injector.providers.Provider`.
+
+Providers could be:
+
++ Injected into each other.
++ Overridden by each other.
++ Extended.
+
+Containers 
+~~~~~~~~~~
+
+Containers are collections of providers. They are used for grouping 
+of providers by some principles. Base class is - 
+:py:class:`dependency_injector.containers.DeclarativeContainer`.
+
+Containers could be:
+
++ Overridden by each other.
++ Copied from each other.
++ Extended.

docs/introduction/what_is_di.rst

@@ -0,0 +1,125 @@
+What is dependency injection and inversion of control?
+------------------------------------------------------
+
+.. meta::
+   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control
+   :description: This article provides definition of dependency injection, 
+                 inversion of control and dependency inversion. It contains 
+                 example code in Python that is refactored to be following 
+                 inversion of control principle.
+
+Definition
+~~~~~~~~~~
+
+Wikipedia provides quite good definitions of dependency injection pattern
+and related principles:
+
+.. glossary::
+
+    `Dependency injection`_
+        In software engineering, dependency injection is a software design 
+        pattern that implements inversion of control for resolving 
+        dependencies. A dependency is an object that can be used (a service). 
+        An injection is the passing of a dependency to a dependent object (a 
+        client) that would use it. The service is made part of the client's 
+        state. Passing the service to the client, rather than allowing a 
+        client to build or find the service, is the fundamental requirement of 
+        the pattern.
+
+        Dependency injection allows a program design to follow the dependency 
+        inversion principle. The client delegates to external code (the 
+        injector) the responsibility of providing its dependencies. The client 
+        is not allowed to call the injector code. It is the injecting code 
+        that constructs the services and calls the client to inject them. This 
+        means the client code does not need to know about the injecting code. 
+        The client does not need to know how to construct the services. The 
+        client does not need to know which actual services it is using. The 
+        client only needs to know about the intrinsic interfaces of the 
+        services because these define how the client may use the services. 
+        This separates the responsibilities of use and construction.
+
+    `Inversion of control`_
+        In software engineering, inversion of control (IoC) describes a design 
+        in which custom-written portions of a computer program receive the 
+        flow of control from a generic, reusable library. A software 
+        architecture with this design inverts control as compared to 
+        traditional procedural programming: in traditional programming, the 
+        custom code that expresses the purpose of the program calls into 
+        reusable libraries to take care of generic tasks, but with inversion 
+        of control, it is the reusable code that calls into the custom, or 
+        task-specific, code.
+
+        Inversion of control is used to increase modularity of the program and 
+        make it extensible, and has applications in object-oriented 
+        programming and other programming paradigms. The term was popularized 
+        by Robert C. Martin and Martin Fowler.
+
+        The term is related to, but different from, the dependency inversion 
+        principle, which concerns itself with decoupling dependencies between 
+        high-level and low-level layers through shared abstractions.
+
+    `Dependency inversion`_
+        In object-oriented programming, the dependency inversion principle 
+        refers to a specific form of decoupling software modules. When 
+        following this principle, the conventional dependency relationships 
+        established from high-level, policy-setting modules to low-level, 
+        dependency modules are reversed, thus rendering high-level modules 
+        independent of the low-level module implementation details. The 
+        principle states:
+
+            + High-level modules should not depend on low-level modules. 
+              Both should depend on abstractions.
+            + Abstractions should not depend on details. 
+              Details should depend on abstractions.
+
+        The principle inverts the way some people may think about 
+        object-oriented design, dictating that both high- and low-level 
+        objects must depend on the same abstraction. 
+
+Example
+~~~~~~~
+
+Let's go through the code of ``example.py``:
+
+.. literalinclude:: ../../examples/ioc_di_demos/example.py
+   :language: python
+   :linenos:
+
+At some point, things defined above mean, that the code from ``example.py``, 
+could look different, like in ``example_ioc.py``:
+
+.. literalinclude:: ../../examples/ioc_di_demos/example_ioc.py
+   :language: python
+   :linenos:
+
+Best explanation, ever
+~~~~~~~~~~~~~~~~~~~~~~
+
+Some times ago `user198313`_ posted awesome `question`_ about dependency 
+injection on `StackOverflow`_:
+
+.. note:: 
+
+    How to explain dependency injection to a 5-year-old?
+
+And `John Munsch`_ provided absolutely Great answer:
+
+.. note:: 
+
+    When you go and get things out of the refrigerator for yourself, you can 
+    cause problems. You might leave the door open, you might get something 
+    Mommy or Daddy doesn't want you to have. You might even be looking for 
+    something we don't even have or which has expired.
+
+    What you should be doing is stating a need, "I need something to drink 
+    with lunch," and then we will make sure you have something when you sit 
+    down to eat.
+
+
+.. _Dependency injection: http://en.wikipedia.org/wiki/Dependency_injection
+.. _Inversion of control: https://en.wikipedia.org/wiki/Inversion_of_control
+.. _Dependency inversion: https://en.wikipedia.org/wiki/Dependency_inversion_principle
+.. _StackOverflow: http://stackoverflow.com/
+.. _question: http://stackoverflow.com/questions/1638919/how-to-explain-dependency-injection-to-a-5-year-old/1639186
+.. _user198313: http://stackoverflow.com/users/198313/user198313
+.. _John Munsch: http://stackoverflow.com/users/31899/john-munsch

docs/main/feedback.rst

@@ -1,8 +1,9 @@
 Feedback
 ========
 
-To post a question, bug report, a feature proposal or get some help open a
-`Github Issue <https://github.com/ets-labs/python-dependency-injector/issues>`_ or leave a comment
-below.
+Feel free to post questions, bugs, feature requests, proposals etc. on
+*Dependency Injector*  GitHub Issues:
 
-.. disqus::
+    https://github.com/ets-labs/python-dependency-injector/issues
+
+Your feedback is quite important!

docs/main/installation.rst

@@ -0,0 +1,37 @@
+Installation
+============
+
+*Dependency Injector* framework is distributed by PyPi_.
+
+Latest stable version (and all previous versions) of *Dependency Injector* 
+framework can be installed from PyPi_:
+
+.. code-block:: bash
+
+    # Installing latest version:
+    pip install dependency_injector
+
+    # Installing particular version:
+    pip install dependency_injector==2.0.0
+    
+Sources can be cloned from GitHub_:
+
+.. code-block:: bash
+
+    git clone https://github.com/ets-labs/python-dependency-injector.git
+
+Also all *Dependency Injector* releases can be downloaded from 
+`GitHub releases page`_.
+
+Verification of currently installed version could be done using 
+:py:obj:`dependency_injector.VERSION` constant:
+
+.. code-block:: bash
+
+    >>> from dependency_injector import VERSION
+    >>> VERSION
+    '2.0.0'
+
+.. _PyPi: https://pypi.python.org/pypi/dependency_injector
+.. _GitHub: https://github.com/ets-labs/python-dependency-injector
+.. _GitHub releases page: https://github.com/ets-labs/python-dependency-injector/releases

docs/providers/aggregate.rst

@@ -1,72 +0,0 @@
-.. _aggregate-provider:
-
-Aggregate provider
-==================
-
-.. meta::
-   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control,Configuration,Injection,
-              Aggregate,Polymorphism,Environment Variable,Flexibility
-   :description: Aggregate provider aggregates other providers.
-                 This page demonstrates how to implement the polymorphism and increase the
-                 flexibility of your application using the Aggregate provider.
-
-:py:class:`Aggregate` provider aggregates a group of other providers.
-
-.. currentmodule:: dependency_injector.providers
-
-.. literalinclude:: ../../examples/providers/aggregate.py
-   :language: python
-   :lines: 3-
-   :emphasize-lines: 24-27
-
-Each provider in the ``Aggregate`` is associated with a key. You can call aggregated providers by providing
-their key as a first argument. All positional and keyword arguments following the key will be forwarded to
-the called provider:
-
-.. code-block:: python
-
-   yaml_reader = container.config_readers("yaml", "./config.yml", foo=...)
-
-You can also retrieve an aggregated provider by providing its key as an attribute name:
-
-.. code-block:: python
-
-   yaml_reader = container.config_readers.yaml("./config.yml", foo=...)
-
-To retrieve a dictionary of aggregated providers, use ``.providers`` attribute:
-
-.. code-block:: python
-
-   container.config_readers.providers == {
-       "yaml": <YAML provider>,
-       "json": <JSON provider>,
-   }
-
-.. note::
-   You can not override the ``Aggregate`` provider.
-
-.. note::
-   When you inject the ``Aggregate`` provider, it is passed "as is".
-
-To use non-string keys or string keys with ``.`` and ``-``, provide a dictionary as a positional argument:
-
-.. code-block:: python
-
-   aggregate = providers.Aggregate({
-       SomeClass: providers.Factory(...),
-       "key.with.periods": providers.Factory(...),
-       "key-with-dashes": providers.Factory(...),
-   })
-
-.. seealso::
-   :ref:`selector-provider` to make injections based on a configuration value, environment variable, or a result of a callable.
-
-   ``Aggregate`` provider is different from the :ref:`selector-provider`. ``Aggregate`` provider doesn't select which provider
-   to inject and doesn't have a selector. It is a group of providers and is always injected "as is". The rest of the interface
-   of both providers is similar.
-
-.. note::
-   ``Aggregate`` provider is a successor of :ref:`factory-aggregate-provider` provider. ``Aggregate`` provider doesn't have
-   a restriction on the provider type, while ``FactoryAggregate`` aggregates only ``Factory`` providers.
-
-.. disqus::

docs/providers/async.rst

@@ -1,110 +0,0 @@
-.. _async-injections:
-
-Asynchronous injections
-=======================
-
-.. meta::
-   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control,Providers,Async,Injections,Asynchronous,Await,
-              Asyncio
-   :description: Dependency Injector providers support asynchronous injections. This page
-                 demonstrates how make asynchronous dependency injections in Python.
-
-Providers support asynchronous injections.
-
-.. literalinclude:: ../../examples/providers/async.py
-   :language: python
-   :emphasize-lines: 26-29
-   :lines: 3-
-
-If provider has any awaitable injections it switches into async mode. In async mode provider always returns awaitable.
-This causes a cascade effect:
-
-.. code-block:: bash
-
-   provider1()              <── Async mode enabled <──┐
-   │                                                  │
-   ├──> provider2()                                   │
-   │                                                  │
-   ├──> provider3()         <── Async mode enabled <──┤
-   │    │                                             │
-   │    └──> provider4()    <── Async provider ───────┘
-   │
-   └──> provider5()
-        │
-        └──> provider6()
-
-In async mode provider prepares injections asynchronously.
-
-If provider has multiple awaitable dependencies, it will run them concurrently. Provider will wait until all
-dependencies are ready and inject them afterwards.
-
-.. code-block:: bash
-
-   provider1()
-   │
-   ├──> provider2()         <── Async mode enabled
-   │
-   ├──> provider3()         <── Async mode enabled
-   │
-   └──> provider4()         <── Async mode enabled
-
-Here is what provider will do for the previous example:
-
-.. code-block:: python
-
-   injections = await asyncio.gather(
-       provider2(),
-       provider3(),
-       provider4(),
-   )
-   await provider1(*injections)
-
-Overriding behaviour
---------------------
-
-In async mode provider always returns awaitable. It applies to the overriding too. If provider in async mode is
-overridden by a provider that doesn't return awaitable result, the result will be wrapped into awaitable.
-
-.. literalinclude:: ../../examples/providers/async_overriding.py
-   :language: python
-   :emphasize-lines: 19-24
-   :lines: 3-
-
-Async mode mechanics and API
-----------------------------
-
-By default provider's async mode is undefined.
-
-When provider async mode is undefined, provider will automatically select the mode during the next call.
-If the result is awaitable, provider will enable async mode, if not - disable it.
-
-If provider async mode is enabled, provider always returns awaitable. If the result is not awaitable,
-provider wraps it into awaitable explicitly. You can safely ``await`` provider in async mode.
-
-If provider async mode is disabled, provider behaves the regular way. It doesn't do async injections
-preparation or non-awaitables to awaitables conversion.
-
-Once provider async mode is enabled or disabled, provider will stay in this state. No automatic switching
-will be done.
-
-.. image:: images/async_mode.png
-
-You can also use following methods to change provider's async mode manually:
-
-- ``Provider.enable_async_mode()``
-- ``Provider.disable_async_mode()``
-- ``Provider.reset_async_mode()``
-
-To check the state of provider's async mode use:
-
-- ``Provider.is_async_mode_enabled()``
-- ``Provider.is_async_mode_disabled()``
-- ``Provider.is_async_mode_undefined()``
-
-See also:
-
-- Wiring :ref:`async-injections-wiring`
-- Resource provider :ref:`resource-async-initializers`
-- :ref:`fastapi-redis-example`
-
-.. disqus::

docs/providers/callable.rst

@@ -1,20 +1,58 @@
-Callable provider
-=================
-
-.. meta::
-   :keywords: Python,DI,Dependency injection,IoC,Inversion of Control,Function,Method,Example
-   :description: Callable provider helps to make dependencies injection into functions. This page
-                 demonstrates how to use a Callable provider.
+Callable providers
+------------------
 
 .. currentmodule:: dependency_injector.providers
 
-:py:class:`Callable` provider calls a function, a method or another callable.
+:py:class:`Callable` provider calls wrapped callable on every call.
 
-.. literalinclude:: ../../examples/providers/callable.py
+Callable providers and injections
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+:py:class:`Callable` provider takes a various number of positional and keyword 
+arguments that are used as wrapped callable injections. Every time, when 
+:py:class:`Callable` provider is called, positional and keyword argument 
+injections would be passed as an callable arguments.
+
+Injections are done according to the next rules:
+
++ All providers (instances of :py:class:`Provider`) are called every time 
+  when injection needs to be done.
++ Providers could be injected "as is" (delegated), if it is defined obviously.
+  Check out :ref:`callable_providers_delegation`.
++ All other injectable values are provided *"as is"*.
++ Positional context arguments will be appended after :py:class:`Callable` 
+  positional injections.
++ Keyword context arguments have priority on :py:class:`Callable` keyword 
+  injections and will be merged over them.
+
+Example that shows usage of :py:class:`Callable` with positional argument 
+injections:
+
+.. literalinclude:: ../../examples/providers/callable_args.py
    :language: python
-   :lines: 3-
+   :linenos:
 
-``Callable`` provider handles an injection of the dependencies the same way like a
-:ref:`factory-provider`.
+Next one example shows usage of :py:class:`Callable` with keyword argument 
+injections:
 
-.. disqus::
+.. image:: /images/providers/callable.png
+    :width: 100%
+    :align: center
+
+.. literalinclude:: ../../examples/providers/callable_kwargs.py
+   :language: python
+   :linenos:
+
+.. _callable_providers_delegation:
+
+Callable providers delegation
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+:py:class:`Callable` provider could be delegated to any other provider via 
+any kind of injection. 
+
+Delegation of :py:class:`Callable` providers is the same as 
+:py:class:`Factory` providers delegation, please follow 
+:ref:`factory_providers_delegation` section for examples (with exception 
+about using :py:class:`DelegatedCallable` instead of 
+:py:class:`DelegatedFactory`).