From 3a61457be75551f26b5caf559cb323cc9c418b76 Mon Sep 17 00:00:00 2001 From: Roman Mogylatov Date: Sat, 8 Aug 2020 14:48:05 -0400 Subject: [PATCH] Asyncio daemon tutorial (#278) * Fix a typo in the docblock of the Configuration provider * Update the changelog * Add tutorial sections * Switch to use https for httpbin.org requests * Add what we are going to build section * Fix ``Makefile`` to run ``aiohttp`` integration tests on Python 3.5+ * Add prerequisities and prepare the env sections * Add logging, config and the dispacher sections * Change logging * Fix multiple typos in the ``flask`` and ``aiohttp`` tutorials * Add the initial and dirty version * Fix multiple typos in the ``flask`` and ``aiohttp`` tutorials * Fix the 3.27.0 changelog * Finish all the parts before the dispatcher * Finish dispatcher section * Update http monitor logging format * Finish the tutorial * Fix docblock in the dispatcher module * Update changelog * Add meta keywords and description --- Makefile | 2 +- docs/index.rst | 3 +- docs/introduction/di_in_python.rst | 6 +- docs/main/changelog.rst | 9 + docs/tutorials/aiohttp.rst | 16 +- docs/tutorials/asyncio-daemon.rst | 1085 +++++ docs/tutorials/asyncio.rst | 6 - docs/tutorials/asyncio_images/class_1.png | Bin 0 -> 23574 bytes docs/tutorials/asyncio_images/class_2.png | Bin 0 -> 31136 bytes docs/tutorials/asyncio_images/diagram.png | Bin 0 -> 66589 bytes docs/tutorials/flask.rst | 14 +- docs/tutorials/index.rst | 2 +- .../monitoring-daemon-asyncio/README.rst | 36 +- .../monitoring-daemon-asyncio/config.yml | 2 +- .../monitoringdaemon/dispatcher.py | 17 +- .../monitoringdaemon/monitors.py | 18 +- .../monitoringdaemon/tests.py | 4 +- src/dependency_injector/providers.c | 3806 ++++++++--------- src/dependency_injector/providers.pyx | 1 + 19 files changed, 3073 insertions(+), 1954 deletions(-) create mode 100644 docs/tutorials/asyncio-daemon.rst delete mode 100644 docs/tutorials/asyncio.rst create mode 100644 docs/tutorials/asyncio_images/class_1.png create mode 100644 docs/tutorials/asyncio_images/class_2.png create mode 100644 docs/tutorials/asyncio_images/diagram.png diff --git a/Makefile b/Makefile index 6c514be9..c309d62c 100644 --- a/Makefile +++ b/Makefile @@ -55,7 +55,7 @@ test-py2: build test-py3: build # Unit tests with coverage report coverage erase - coverage run --rcfile=./.coveragerc -m unittest2 discover -s tests/unit/ -p test_*py3.py + coverage run --rcfile=./.coveragerc -m unittest2 discover -s tests/unit/ -p test_*py3*.py coverage report --rcfile=./.coveragerc coverage html --rcfile=./.coveragerc diff --git a/docs/index.rst b/docs/index.rst index 0413384d..8ce60902 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -7,7 +7,8 @@ Dependency Injector --- Dependency injection framework for Python :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 was designed to be unified, developer-friendly + 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 diff --git a/docs/introduction/di_in_python.rst b/docs/introduction/di_in_python.rst index 3efa6600..ad1dc7a9 100644 --- a/docs/introduction/di_in_python.rst +++ b/docs/introduction/di_in_python.rst @@ -131,8 +131,10 @@ What's next? Choose one of the following as a next step: -+ Pass the dependency injection :ref:`flask-tutorial`. -+ Look at the other dependency injection :ref:`tutorials`. ++ Pass one of the dependency injection tutorials: + + :ref:`flask-tutorial` + + :ref:`aiohttp-tutorial` + + :ref:`asyncio-daemon-tutorial` + Know more about the :ref:`providers`. + Go to the :ref:`contents`. diff --git a/docs/main/changelog.rst b/docs/main/changelog.rst index a3c760aa..2d8cc15c 100644 --- a/docs/main/changelog.rst +++ b/docs/main/changelog.rst @@ -7,9 +7,18 @@ that were made in every particular version. From version 0.7.6 *Dependency Injector* framework strictly follows `Semantic versioning`_ +Development version +------------------- +- Add ``asyncio`` + ``Dependency Injector`` example ``monitoring-daemon-asyncio``. +- Add ``asyncio`` + ``Dependency Injector`` monitoring daemon tutorial. +- Fix a typo in the docblock of the ``Configuration`` provider. +- Fix multiple typos in the ``flask`` and ``aiohttp`` tutorials. +- Fix ``Makefile`` to run ``aiohttp`` integration tests on Python 3.5+. + 3.27.0 ------ - Add deep init injections overriding for ``Factory`` provider. +- Add ``asyncio`` monitoring daemon example. 3.26.0 ------ diff --git a/docs/tutorials/aiohttp.rst b/docs/tutorials/aiohttp.rst index 2e0df986..3c90e6e8 100644 --- a/docs/tutorials/aiohttp.rst +++ b/docs/tutorials/aiohttp.rst @@ -1,9 +1,17 @@ +.. _aiohttp-tutorial: + Aiohttp tutorial ================ -.. _aiohttp-tutorial: +.. meta:: + :keywords: Python,Aiohttp,Tutorial,Education,Web,API,REST API,Example,DI,Dependency injection, + IoC,Inversion of control,Refactoring,Tests,Unit tests,Pytest,py.test,Bootstrap, + HTML,CSS + :description: This tutorial shows how to build an aiohttp application following the dependency + injection principle. You will create the REST API application, connect to the + Giphy API, cover it with the unit test and make some refactoring. -This tutorials shows how to build an ``aiohttp`` REST API application following the dependency +This tutorial shows how to build an ``aiohttp`` REST API application following the dependency injection principle. Start from the scratch or jump to the section: @@ -908,9 +916,9 @@ You should see: Conclusion ---------- -In this tutorial we've build an ``aiohttp`` REST API application following the dependency +In this tutorial we've built an ``aiohttp`` REST API application following the dependency injection principle. -We've used ``Dependency Injector`` as a dependency injection framework. +We've used the ``Dependency Injector`` as a dependency injection framework. The benefit you get with the ``Dependency Injector`` is the container. It starts to payoff when you need to understand or change your application structure. It's easy with the container, diff --git a/docs/tutorials/asyncio-daemon.rst b/docs/tutorials/asyncio-daemon.rst new file mode 100644 index 00000000..77a4d5ea --- /dev/null +++ b/docs/tutorials/asyncio-daemon.rst @@ -0,0 +1,1085 @@ +.. _asyncio-daemon-tutorial: + +Asyncio daemon tutorial +======================= + +.. meta:: + :keywords: Python,asyncio,Daemon,Monitoring,Tutorial,Education,Web,API,REST API,Example,DI, + Dependency injection,IoC,Inversion of control,Refactoring,Tests,Unit tests,Pytest, + py.test,docker,docker-compose,backend + :description: This tutorial shows how to build an asyncio application following the dependency + injection principle. You will create the monitoring daemon, use docker & + docker-compose, cover the daemon with the unit test and make some refactoring. + +This tutorial shows how to build an ``asyncio`` daemon following the dependency injection +principle. + +In this tutorial we will use: + +- Python 3 +- Docker +- Docker-compose + +Start from the scratch or jump to the section: + +.. contents:: + :local: + :backlinks: none + +You can find complete project on the +`Github `_. + +What are we going to build? +--------------------------- + +We will build a monitoring daemon that monitors web services availability. + +The daemon will send the requests to the `example.com `_ and +`httpbin.org `_ every couple of seconds. For each successfully completed +response it will log: + +- The response code +- The amount of bytes in the response +- The time took to complete the response + +.. image:: asyncio_images/diagram.png + +Prerequisites +------------- + +We will use `Docker `_ and +`docker-compose `_ in this tutorial. Let's check the versions: + +.. code-block:: bash + + docker --version + docker-compose --version + +The output should look something like: + +.. code-block:: bash + + Docker version 19.03.12, build 48a66213fe + docker-compose version 1.26.2, build eefe0d31 + +.. note:: + + If you don't have ``Docker`` or ``docker-compose`` you need to install them before proceeding. + Follow these installation guides: + + - `Install Docker `_ + - `Install docker-compose `_ + +The prerequisites are satisfied. Let's get started with the project layout. + +Project layout +-------------- + +Create the project root folder and set it as a working directory: + +.. code-block:: bash + + mkdir monitoring-daemon-tutorial + cd monitoring-daemon-tutorial + +Now we need to create the initial project structure. Create the files and folders following next +layout. All files should be empty for now. We will fill them later. + +Initial project layout: + +.. code-block:: bash + + ./ + ├── monitoringdaemon/ + │ ├── __init__.py + │ ├── __main__.py + │ └── containers.py + ├── config.yml + ├── docker-compose.yml + ├── Dockerfile + └── requirements.txt + +Initial project layout is ready. We will extend it in the next sections. + +Let's proceed to the environment preparation. + +Prepare the environment +----------------------- + +In this section we are going to prepare the environment for running our daemon. + +First we need to specify the project requirements. We will use next packages: + +- ``dependency-injector`` - the dependency injection framework +- ``aiohttp`` - the web framework (we need only http client) +- ``pyyaml`` - the YAML files parsing library, used for the reading of the configuration files +- ``pytest`` - the test framework +- ``pytest-asyncio`` - the helper library for the testing of the ``asyncio`` application +- ``pytest-cov`` - the helper library for measuring the test coverage + +Put next lines into the ``requirements.txt`` file: + +.. code-block:: bash + + dependency-injector + aiohttp + pyyaml + pytest + pytest-asyncio + pytest-cov + +Second, we need to create the ``Dockerfile``. It will describe the daemon's build process and +specify how to run it. We will use ``python:3.8-buster`` as a base image. + +Put next lines into the ``Dockerfile`` file: + +.. code-block:: bash + + FROM python:3.8-buster + + ENV PYTHONUNBUFFERED=1 + + WORKDIR /code + COPY . /code/ + + RUN apt-get install openssl \ + && pip install --upgrade pip \ + && pip install -r requirements.txt \ + && rm -rf ~/.cache + + CMD ["python", "-m", "monitoringdaemon"] + +Third, we need to define the container in the docker-compose configuration. + +Put next lines into the ``docker-compose.yml`` file: + +.. code-block:: yaml + + version: "3.7" + + services: + + monitor: + build: ./ + image: monitoring-daemon + volumes: + - "./:/code" + +All is ready. Let's check that the environment is setup properly. + +Run in the terminal: + +.. code-block:: bash + + docker-compose build + +The build process may take a couple of minutes. You should see something like this in the end: + +.. code-block:: bash + + Successfully built 5b4ee5e76e35 + Successfully tagged monitoring-daemon:latest + +After the build is done run the container: + +.. code-block:: bash + + docker-compose up + +The output should look like: + +.. code-block:: bash + + Creating network "monitoring-daemon-tutorial_default" with the default driver + Creating monitoring-daemon-tutorial_monitor_1 ... done + Attaching to monitoring-daemon-tutorial_monitor_1 + monitoring-daemon-tutorial_monitor_1 exited with code 0 + +The environment is ready. The application does not do any work and just exits with a code ``0``. + +Next step is to configure the logging and configuration file parsing. + +Logging and configuration +------------------------- + +In this section we will configure the logging and configuration file parsing. + +Let's start with the the main part of our application - the container. Container will keep all of +the application components and their dependencies. + +First two components that we're going to add are the config object and the provider for +configuring the logging. + +Put next lines into the ``containers.py`` file: + +.. code-block:: python + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + +.. note:: + + We have used the configuration value before it was defined. That's the principle how the + ``Configuration`` provider works. + + Use first, define later. + +The configuration file will keep the logging settings. + +Put next lines into the ``config.yml`` file: + +.. code-block:: yaml + + log: + level: "INFO" + format: "[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s" + +Now let's create the function that will run our daemon. It's traditionally called +``main()``. The ``main()`` function will create the container. Then it will use the container +to parse the ``config.yml`` file and call the logging configuration provider. + +Put next lines into the ``__main__.py`` file: + +.. code-block:: python + + """Main module.""" + + from .containers import ApplicationContainer + + + def main() -> None: + """Run the application.""" + container = ApplicationContainer() + + container.config.from_yaml('config.yml') + container.configure_logging() + + + if __name__ == '__main__': + main() + +.. note:: + + Container is the first object in the application. + + The container is used to create all other objects. + +Logging and configuration parsing part is done. In the next section we will create the monitoring +checks dispatcher. + +Dispatcher +---------- + +Now let's add the monitoring checks dispatcher. + +The dispatcher will control a list of the monitoring tasks. It will execute each task according +to the configured schedule. The ``Monitor`` class is the base class for all the monitors. You can +create different monitors by subclassing it and implementing the ``check()`` method. + +.. image:: asyncio_images/class_1.png + +Let's create dispatcher and the monitor base classes. + +Create ``dispatcher.py`` and ``monitors.py`` in the ``monitoringdaemon`` package: + +.. code-block:: bash + :emphasize-lines: 6-7 + + ./ + ├── monitoringdaemon/ + │ ├── __init__.py + │ ├── __main__.py + │ ├── containers.py + │ ├── dispatcher.py + │ └── monitors.py + ├── config.yml + ├── docker-compose.yml + ├── Dockerfile + └── requirements.txt + +Put next into the ``monitors.py``: + +.. code-block:: python + + """Monitors module.""" + + import logging + + + class Monitor: + + def __init__(self, check_every: int) -> None: + self.check_every = check_every + self.logger = logging.getLogger(self.__class__.__name__) + + async def check(self) -> None: + raise NotImplementedError() + +and next into the ``dispatcher.py``: + +.. code-block:: python + + """"Dispatcher module.""" + + import asyncio + import logging + import signal + import time + from typing import List + + from .monitors import Monitor + + + class Dispatcher: + + def __init__(self, monitors: List[Monitor]) -> None: + self._monitors = monitors + self._monitor_tasks: List[asyncio.Task] = [] + self._logger = logging.getLogger(self.__class__.__name__) + self._stopping = False + + def run(self) -> None: + asyncio.run(self.start()) + + async def start(self) -> None: + self._logger.info('Starting up') + + for monitor in self._monitors: + self._monitor_tasks.append( + asyncio.create_task(self._run_monitor(monitor)), + ) + + asyncio.get_event_loop().add_signal_handler(signal.SIGTERM, self.stop) + asyncio.get_event_loop().add_signal_handler(signal.SIGINT, self.stop) + + await asyncio.gather(*self._monitor_tasks, return_exceptions=True) + + self.stop() + + def stop(self) -> None: + if self._stopping: + return + + self._stopping = True + + self._logger.info('Shutting down') + for task, monitor in zip(self._monitor_tasks, self._monitors): + task.cancel() + self._logger.info('Shutdown finished successfully') + + @staticmethod + async def _run_monitor(monitor: Monitor) -> None: + def _until_next(last: float) -> float: + time_took = time.time() - last + return monitor.check_every - time_took + + while True: + time_start = time.time() + + try: + await monitor.check() + except asyncio.CancelledError: + break + except Exception: + monitor.logger.exception('Error executing monitor check') + + await asyncio.sleep(_until_next(last=time_start)) + +Now we need to add the dispatcher to the container. + +Edit ``containers.py``: + +.. code-block:: python + :emphasize-lines: 8,23-28 + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + from . import dispatcher + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + + dispatcher = providers.Factory( + dispatcher.Dispatcher, + monitors=providers.List( + # TODO: add monitors + ), + ) + +.. note:: + + Every component should be added to the container. + +At the last we will add the dispatcher in the ``main()`` function. We will retrieve the +dispatcher instance from the container and call the ``run()`` method. + +Edit ``__main__.py``: + +.. code-block:: python + :emphasize-lines: 13-14 + + """Main module.""" + + from .containers import ApplicationContainer + + + def main() -> None: + """Run the application.""" + container = ApplicationContainer() + + container.config.from_yaml('config.yml') + container.configure_logging() + + dispatcher = container.dispatcher() + dispatcher.run() + + + if __name__ == '__main__': + main() + +Finally let's start the daemon to check that all works. + +Run in the terminal: + +.. code-block:: bash + + docker-compose up + +The output should look like: + +.. code-block:: bash + + Starting monitoring-daemon-tutorial_monitor_1 ... done + Attaching to monitoring-daemon-tutorial_monitor_1 + monitor_1 | [2020-08-08 16:12:35,772] [INFO] [Dispatcher]: Starting up + monitor_1 | [2020-08-08 16:12:35,774] [INFO] [Dispatcher]: Shutting down + monitor_1 | [2020-08-08 16:12:35,774] [INFO] [Dispatcher]: Shutdown finished successfully + monitoring-daemon-tutorial_monitor_1 exited with code 0 + +Everything works properly. Dispatcher starts up and exits because there are no monitoring tasks. + +By the end of this section we have the application skeleton ready. In the next section will will +add first monitoring task. + +Example.com monitor +------------------- + +In this section we will add the monitoring task that will check the availability of the +`http://example.com `_. + +We will start from the extending of our class model with a new type of the monitoring check, the +``HttpMonitor``. + +The ``HttpMonitor`` is a subclass of the ``Monitor``. We will implement the ``check()`` method that +will send the HTTP request to the specified URL. The http request sending will be delegated to +the ``HttpClient``. + +.. image:: asyncio_images/class_2.png + +First, we need to create the ``HttpClient``. + +Create ``http.py`` in the ``monitoringdaemon`` package: + +.. code-block:: bash + :emphasize-lines: 7 + + ./ + ├── monitoringdaemon/ + │ ├── __init__.py + │ ├── __main__.py + │ ├── containers.py + │ ├── dispatcher.py + │ ├── http.py + │ └── monitors.py + ├── config.yml + ├── docker-compose.yml + ├── Dockerfile + └── requirements.txt + +and put next into it: + +.. code-block:: python + + """Http client module.""" + + from aiohttp import ClientSession, ClientTimeout, ClientResponse + + + class HttpClient: + + async def request(self, method: str, url: str, timeout: int) -> ClientResponse: + async with ClientSession(timeout=ClientTimeout(timeout)) as session: + async with session.request(method, url) as response: + return response + +Now we need to add the ``HttpClient`` to the container. + +Edit ``containers.py``: + +.. code-block:: python + :emphasize-lines: 8, 23 + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + from . import http, dispatcher + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + + http_client = providers.Factory(http.HttpClient) + + dispatcher = providers.Factory( + dispatcher.Dispatcher, + monitors=providers.List( + # TODO: add monitors + ), + ) + +Now we're ready to add the ``HttpMonitor``. We will add it to the ``monitors`` module. + +Edit ``monitors.py``: + +.. code-block:: python + :emphasize-lines: 4-5,7,20-54 + + """Monitors module.""" + + import logging + import time + from typing import Dict, Any + + from .http import HttpClient + + + class Monitor: + + def __init__(self, check_every: int) -> None: + self.check_every = check_every + self.logger = logging.getLogger(self.__class__.__name__) + + async def check(self) -> None: + raise NotImplementedError() + + + class HttpMonitor(Monitor): + + def __init__( + self, + http_client: HttpClient, + options: Dict[str, Any], + ) -> None: + self._client = http_client + self._method = options.pop('method') + self._url = options.pop('url') + self._timeout = options.pop('timeout') + super().__init__(check_every=options.pop('check_every')) + + @property + def full_name(self) -> str: + return '{0}.{1}(url="{2}")'.format(__name__, self.__class__.__name__, self._url) + + async def check(self) -> None: + time_start = time.time() + + response = await self._client.request( + method=self._method, + url=self._url, + timeout=self._timeout, + ) + + time_end = time.time() + time_took = time_end - time_start + + self.logger.info( + 'Response code: %s, content length: %s, request took: %s seconds', + response.status, + response.content_length, + round(time_took, 3) + ) + +We have everything ready to add the `http://example.com `_ monitoring check. +We make two changes in the container: + +- Add the factory provider ``example_monitor``. +- Inject the ``example_monitor`` into the dispatcher. + +Edit ``containers.py``: + +.. code-block:: python + :emphasize-lines: 8,25-29,34 + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + from . import http, monitors, dispatcher + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + + http_client = providers.Factory(http.HttpClient) + + example_monitor = providers.Factory( + monitors.HttpMonitor, + http_client=http_client, + options=config.monitors.example, + ) + + dispatcher = providers.Factory( + dispatcher.Dispatcher, + monitors=providers.List( + example_monitor, + ), + ) + +Provider ``example_monitor`` has a dependency on the configuration options. Let's define these +options. + +Edit ``config.yml``: + +.. code-block:: yaml + :emphasize-lines: 5-11 + + log: + level: "INFO" + format: "[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s" + + monitors: + + example: + method: "GET" + url: "http://example.com" + timeout: 5 + check_every: 5 + + +All set. Start the daemon to check that all works. + +Run in the terminal: + +.. code-block:: bash + + docker-compose up + +You should see: + +.. code-block:: bash + + Starting monitoring-daemon-tutorial_monitor_1 ... done + Attaching to monitoring-daemon-tutorial_monitor_1 + monitor_1 | [2020-08-08 17:06:41,965] [INFO] [Dispatcher]: Starting up + monitor_1 | [2020-08-08 17:06:42,033] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.067 seconds + monitor_1 | + monitor_1 | [2020-08-08 17:06:47,040] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.073 seconds + +Our daemon can monitor `http://example.com `_ availability. + +Let's add the monitor for the `http://httpbin.org `_. + +Httpbin.org monitor +------------------- + +Adding of the monitor for the `httpbin.org`_ will be much easier because we have all the +components ready. We just need to create a new provider in the container and update the +configuration. + +Edit ``containers.py``: + +.. code-block:: python + :emphasize-lines: 31-35,41 + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + from . import http, monitors, dispatcher + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + + http_client = providers.Factory(http.HttpClient) + + example_monitor = providers.Factory( + monitors.HttpMonitor, + http_client=http_client, + options=config.monitors.example, + ) + + httpbin_monitor = providers.Factory( + monitors.HttpMonitor, + http_client=http_client, + options=config.monitors.httpbin, + ) + + dispatcher = providers.Factory( + dispatcher.Dispatcher, + monitors=providers.List( + example_monitor, + httpbin_monitor, + ), + ) + +Edit ``config.yml``: + +.. code-block:: yaml + :emphasize-lines: 13-17 + + log: + level: "INFO" + format: "[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s" + + monitors: + + example: + method: "GET" + url: "http://example.com" + timeout: 5 + check_every: 5 + + httpbin: + method: "GET" + url: "https://httpbin.org/get" + timeout: 5 + check_every: 5 + +Let's start the daemon and check the logs. + +Run in the terminal: + +.. code-block:: bash + + docker-compose up + +You should see: + +.. code-block:: bash + + Starting monitoring-daemon-tutorial_monitor_1 ... done + Attaching to monitoring-daemon-tutorial_monitor_1 + monitor_1 | [2020-08-08 18:09:08,540] [INFO] [Dispatcher]: Starting up + monitor_1 | [2020-08-08 18:09:08,618] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.077 seconds + monitor_1 | + monitor_1 | [2020-08-08 18:09:08,722] [INFO] [HttpMonitor]: Check + monitor_1 | GET https://httpbin.org/get + monitor_1 | response code: 200 + monitor_1 | content length: 310 + monitor_1 | request took: 0.18 seconds + monitor_1 | + monitor_1 | [2020-08-08 18:09:13,619] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.066 seconds + monitor_1 | + monitor_1 | [2020-08-08 18:09:13,681] [INFO] [HttpMonitor]: Check + monitor_1 | GET https://httpbin.org/get + monitor_1 | response code: 200 + monitor_1 | content length: 310 + monitor_1 | request took: 0.126 seconds + +The functional part is done. Daemon monitors `http://example.com `_ and +`https://httpbin.org `_. + +In the next section we will add some tests. + +Tests +----- + +It would be nice to add some tests. Let's do it. + +We will use `pytest `_ and +`coverage `_. + +Create ``tests.py`` in the ``monitoringdaemon`` package: + +.. code-block:: bash + :emphasize-lines: 9 + + ./ + ├── monitoringdaemon/ + │ ├── __init__.py + │ ├── __main__.py + │ ├── containers.py + │ ├── dispatcher.py + │ ├── http.py + │ ├── monitors.py + │ └── tests.py + ├── config.yml + ├── docker-compose.yml + ├── Dockerfile + └── requirements.txt + +and put next into it: + +.. code-block:: python + :emphasize-lines: 54,70-71 + + """Tests module.""" + + import asyncio + import dataclasses + from unittest import mock + + import pytest + + from .containers import ApplicationContainer + + + @dataclasses.dataclass + class RequestStub: + status: int + content_length: int + + + @pytest.fixture + def container(): + container = ApplicationContainer() + container.config.from_dict({ + 'log': { + 'level': 'INFO', + 'formant': '[%(asctime)s] [%(levelname)s] [%(name)s]: %(message)s', + }, + 'monitors': { + 'example': { + 'method': 'GET', + 'url': 'http://fake-example.com', + 'timeout': 1, + 'check_every': 1, + }, + 'httpbin': { + 'method': 'GET', + 'url': 'https://fake-httpbin.org/get', + 'timeout': 1, + 'check_every': 1, + }, + }, + }) + return container + + + @pytest.mark.asyncio + async def test_example_monitor(container, caplog): + caplog.set_level('INFO') + + http_client_mock = mock.AsyncMock() + http_client_mock.request.return_value = RequestStub( + status=200, + content_length=635, + ) + + with container.http_client.override(http_client_mock): + example_monitor = container.example_monitor() + await example_monitor.check() + + assert 'http://fake-example.com' in caplog.text + assert 'response code: 200' in caplog.text + assert 'content length: 635' in caplog.text + + + @pytest.mark.asyncio + async def test_dispatcher(container, caplog, event_loop): + caplog.set_level('INFO') + + example_monitor_mock = mock.AsyncMock() + httpbin_monitor_mock = mock.AsyncMock() + + with container.example_monitor.override(example_monitor_mock), \ + container.httpbin_monitor.override(httpbin_monitor_mock): + + dispatcher = container.dispatcher() + event_loop.create_task(dispatcher.start()) + await asyncio.sleep(0.1) + dispatcher.stop() + + assert example_monitor_mock.check.called + assert httpbin_monitor_mock.check.called + +Run in the terminal: + +.. code-block:: bash + + docker-compose run --rm monitor py.test monitoringdaemon/tests.py --cov=monitoringdaemon + +You should see: + +.. code-block:: bash + + platform linux -- Python 3.8.3, pytest-6.0.1, py-1.9.0, pluggy-0.13.1 + rootdir: /code + plugins: asyncio-0.14.0, cov-2.10.0 + collected 2 items + + monitoringdaemon/tests.py .. [100%] + + ----------- coverage: platform linux, python 3.8.3-final-0 ----------- + Name Stmts Miss Cover + ---------------------------------------------------- + monitoringdaemon/__init__.py 0 0 100% + monitoringdaemon/__main__.py 9 9 0% + monitoringdaemon/containers.py 11 0 100% + monitoringdaemon/dispatcher.py 43 5 88% + monitoringdaemon/http.py 6 3 50% + monitoringdaemon/monitors.py 23 1 96% + monitoringdaemon/tests.py 37 0 100% + ---------------------------------------------------- + TOTAL 129 18 86% + +.. note:: + + Take a look at the highlights in the ``tests.py``. + + In the ``test_example_monitor`` it emphasizes the overriding of the ``HttpClient``. The real + HTTP calls are mocked. + + In the ``test_dispatcher`` we override both monitors with the mocks. + + +Conclusion +---------- + +In this tutorial we've built an ``asyncio`` monitoring daemon following the dependency +injection principle. +We've used the ``Dependency Injector`` as a dependency injection framework. + +The benefit you get with the ``Dependency Injector`` is the container. It starts to payoff +when you need to understand or change your application structure. It's easy with the container, +cause you have everything in one place: + +.. code-block:: python + + """Application containers module.""" + + import logging + import sys + + from dependency_injector import containers, providers + + from . import http, monitors, dispatcher + + + class ApplicationContainer(containers.DeclarativeContainer): + """Application container.""" + + config = providers.Configuration() + + configure_logging = providers.Callable( + logging.basicConfig, + stream=sys.stdout, + level=config.log.level, + format=config.log.format, + ) + + http_client = providers.Factory(http.HttpClient) + + example_monitor = providers.Factory( + monitors.HttpMonitor, + http_client=http_client, + options=config.monitors.example, + ) + + httpbin_monitor = providers.Factory( + monitors.HttpMonitor, + http_client=http_client, + options=config.monitors.httpbin, + ) + + dispatcher = providers.Factory( + dispatcher.Dispatcher, + monitors=providers.List( + example_monitor, + httpbin_monitor, + ), + ) + +What's next? + +- Look at the other :ref:`tutorials`. +- Know more about the :ref:`providers`. +- Go to the :ref:`contents`. + +.. disqus:: diff --git a/docs/tutorials/asyncio.rst b/docs/tutorials/asyncio.rst deleted file mode 100644 index d32c8cd2..00000000 --- a/docs/tutorials/asyncio.rst +++ /dev/null @@ -1,6 +0,0 @@ -Asyncio tutorial -================ - -Coming soon... - -.. disqus:: diff --git a/docs/tutorials/asyncio_images/class_1.png b/docs/tutorials/asyncio_images/class_1.png new file mode 100644 index 0000000000000000000000000000000000000000..2c502a52e6a1c1bae7e20bbdb13d12995e066ac6 GIT binary patch literal 23574 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
%}Gl&{e@;f3B`2GC8zR4h7N4Drp_DGU8 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 Rp>Qa)7JCou$v5-(;qQiqt%3jm literal 0 HcmV?d00001 diff --git a/docs/tutorials/asyncio_images/diagram.png b/docs/tutorials/asyncio_images/diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..59c9bf77cb41aa9767fdf7d643926285bc2925b6 GIT binary patch literal 66589 zcmeEu2Un9>)Na&K#>zJ%%19kYihzKEh;)=;kRl);NLLY&t|W9q&>3+Q1r5Ch=}46x zT2uy*me6}ZB_WX(2_=Mta8H25nRVCw1^2_{QXubn&)MbK&)#RB^VHN>@9+VE0}u%0 zu>O_b%^;8;vmuZl&i}X%{3JV7!wvlNgUh9>mmrY0Q3si~_JZ$!b-H496#@y8fI!0j zfigVnbit~lqIifQxD?{bMjEtnSfwNo zF=LQzCIzOo^<{dg;n@++H`?>p40i2&ll~zi$sZvp#p`!ne-Hl=cC z=KBnD2(SGsAkmfB@w&+@pOeHvim)|dT4 z73rBVWG)gX5u3$%2`t~$u;b{7uo*>nU+VA&@D3R^faH_^XZs;-T=zKAj;dW&pHCKh zmv(4A*@&*)d$V&d&qv#xm5~+9r=_yAD{Ut%ScM-RnsGp*_IIeEPwO&Ru<(P{Wva{Z zBY&B(u^N1JiyP@bTyP3Br*4es=BC#b$iy0CXXtGI5>n}@1NB*jgN3gS^vguE4zoX^ zz`-RlY%(aD{KGrew-KUt0(TwK=4R=^in5P4oVhQ_Z(P3&WVGkOtfH=DdL4ISs$GwK z+ZxKB8SfJM`w1yltE04pD_3La(DRI=kl0VrO4`4aaZ)TX)E9AM~hC&E{) zX$#w(j`RvDB>wndQNT&By99wI?#4GF{+$MeVFzBmqVkUWp`}FqBAD&fRyQMoN}zz zY_|vpwbFk}vPG)p@Tcx3AMiJlM@--H=C1VFS@FF=k;JQQG#CEVM{ZVD(y<1*Pj*yL zTYb2zZG?6VJm_X#VzjQz2R_1;?EQC*D+WNazpc%cD@$1upWJs&Pd6 zF4VfTSpDR#cNKhodfY+ex8pxZZ2S$q;@4?Cc0YoBi+eN1@A zolXyiPZQ=C03nvobIc!mn__KV67bk;?$kX7+wEIuIQYQHa2v)a}>nuTeduQ8^9)LW% zYh&Qa0kJTVnL(EbV@PS!)u>~sVFsKi9VT*bw3qO;8Q9$Lt-%>8`spZF_!`}wxMQi1 zn^xGXm0aNmC9sWuKjckU;Xs?yL12s7{{^4op6>wwQm0(utw7wP|K~YDd|LcYj0k!u zwZvx@Hd9rfA5xsb_&${kwD^|vA*22v0H{PPaHSvgqq$kw!tI>^@JV~%KX`|&e66Cw zXatdCE;-*yVngtm@p~3G00f0?$v+HE8Xss#8^f2brYM`u;C|3;d<%WvvFcV5 zGme&GIQE|&E_)+>T&;l22Vqdy_J0D;wg3Loy1RU-kWcSa;(bjxS~1OJ+y5^R@`91! z*EH@he{9)5M4FV-`po!UBUd#7=RIAi%U{6sEwF_HM5rMC3CDE$)5p?eRCj3;RjPgE zxx+i<$jX}VLGqN!EhVF5MdzWyIHmd*r%Bs{zmXx^g_QElyRY>VL)JKS>LLPP$i zZ2;=uR>A0&3NqI@uBiP2AlE{I1MEN;c1s0OGhEbD`Tzu$dt)Ld1mV{sb@Bt2*=0^Bp?&g8YLVRSA(2z%*4oi_HG%4Ql|r3u!~qk&Ueh>}`nxE_h` ztjH!lg+MAU?69EHtN#%PIROAUk_Sn=sw=rG&sc{cVXpb|{4agiF3RsDRIpQQ5(Js+ zVj~dp3s(Wkz)RM)s|z6TMD@ACI!%fGtUmn;7R z_*FYFyjv91eTXXxX+=+0y8QaCyh7`O=+@)MQ!_~am4|beY@0Z*SV!_RooDiG`2Mh=W{c6WCLQ_COcaa4;l93dgoT~2p ze@Ljd30DKlXE+-0ZsAen_-dQip==;zJJc6(aeP(0O%Z}G_l#ASpr@0@gDDNVt-C)0`ikj( z;zs*WMu3|8H?SUE6HZRwJpi2Pd%Cd~y)u$S|KgKNYn6gIPxW9Felv~7( zG-1e<*&z~(K`}w5K(Q((6z>}4s^hBi<@JPpEwCE2@eF@KayrNN!aVO5$)S=>PB_4j z+#r-n0FUE*hwS6U(4@3r)$AArFyndLgD$0^)7jd}K3n`ay=W{AKshq#nDDlG-3Izh zwD4bXi_{Kz{)Xgtp$SzLOny4VBA#O~ew7gL6vUI>_mrg#o|8H*t5rmWWoB>6>p)@vO* zO)hxN55rB=&a2$Msqi58kaw~EbdlkN1Ioy;3ZWu_!#^m*iX_^dlL)+TOf3+vyE|)z z3i+1c6aKXWNs1FIr3Vi`-zU+yf7-XZ2hijHMG7kDW&DzD<9?ejj* zp5`=7z2lxwj+q}@RZ+QXI!ha7)nintLXslA>*Z_HNrc>`j?IOSi%Ay?Lpq}eN5Yr& zi$#*puj;clR`3|*)(a9CxCfmY?M-39CxpkTM%z(Zl*ecX6jd)lq0qaX2|ZtNOT$i4 z#~KPum6DQ^%U%0&4*haAoqRf2$=QLOlw~62Q4KVdWSe^dQi~bL5dXVb5Sc6~ z(X>8avj8k8Ms*b0aY8LkQEIZJfpO$(bO`kyLhaNjf|+|bQN> zKvfDVw8E}Fzr=8%@mCdhLYjBEnk29LMhz<22CH0kjz0akD2jMNIiLTyE=pO0hx_GM9bg8?s25|4 ztYr0SJC-YhRliU}ow8rNiH4Qc(Z;LB?CAGtr!UQW1e(+B;PixyXc!_$W6Q8gqq7a; zEeQ{%aj40!*2&4qOCL`~!Pb}N+Iq7M%R}KjdcSJ(Cuku;_Z<;Rh>&l*$g8nzdc9FA zc{{E8@@~069zh>}B|jQXsCnN8kB`GtOe7a&6Z}V0dK*Lh&=-5tfFs*qVNdmgc`yd| zQj=&WER`ijlqX1HFm{k(ex3C>`VD;0AM{DY{mZlRO#juDgR3EjCMLRUL$07S_{~Na zaCrWhgXabaWtr`*=mw^mD9R-D2AuJB-gh`2*M>1NU`?8|a>yjd6VW1D${E zKkD=OG5>S}1@0|}CLqtBUt528TZ8)X)Yw7WXo;)sJX&k-LzXi|=fAn26@6(^QY*e~ ze_GA06PNIc(eajI-i7+>%3@RdBsW)5i9iR!j^T(euNq7q-Kc3)pLZh3zujEOAUJ7F zEd3sZkJSt%f!{&$OJvwGZ8eWTqU5hQSX)now!S1pOI9@Ei(KXsj`aLQv$tW<2xy}C z3r*N^r2N{G6&Zf%s;e7oy(P$jWdGD(po1UrCUEPrw<~^56zZbDV2NF4pr1Zn#ihu= zSnE8R{B4l<$g?@dWFy0g(L3U&d0Y)6u}QxhD0<;M z2BxC^j)@b6aH@4-?YRdO|DbK=YMZj-CEI2W zuN<0Io1|kywe<8>v*)4p;8!YN{yyb1;v8S8mgwA@rJtxCSa$os<9iHiZ}$&>?WYqY zwGw5DYclXS8<*j&4EG^V-tJL3-7*g+G^DIf+;awGI@*3LpP-Qzf(EU6Q{7RsZiNtC z=d!>uTwkvx)KNS)nnU&Cn28q))njkF1WR`w`f4s0G{+R8)yFXhmg*35*Y>nWYx=E@ zz7cLt!f(`jE>yJ!QpfT9Kdvs{2)0!qI!(1_|CI{AkT->?=u5 zy@LyJ5w0c6{ntn1+*emsz5+a-CfG}^R?w2>ysXn3<~J7(XvJ^brzQH)hSe~~>w*ib zC}@h~=(?i0Y)Ka@A;=m1sfqPAgm+808dw!lO0;BJK!(oa7%?>PEb2c;P56ZCOcC^W z#K`OHM-st&5n1bI}`0!ne3|9srxtC z5>of8$_3W$vui3@zEbYkp;;@rzbZ%vO=2;GiRtiYKMWIh-N|1z0+#hZ58B9sVtyowbu_aF!H$S>dOYm5PwVh#rZi6 zy}2%@mb>5^A2Px<(RASRUA@VC(V}C7w{;Mb+ww%I5 zTm}oR!OAtGv(!hX5G>qg;#8!XT+@SAcc@Ilhe zKypl726iE-CupW^WopdvuCsf-UBF1-fse}a9t|GY;g-RpS`N0?Sw5Ikcje?wLNB`B z^SOfZX=zAoEMzt_t2Vsr2nN9uc6~vN9uO(pq9#XuH&OOwQx`nr?~No^5ySBGAuC&x z>6#!9Mn^L&2Y*aO)$E4^@N}(rum%8tG?BhnG-nqy@%iA`WHO#L`?k`;Vf8NQtJsim ze8|dUynJBaYI#ky*#MSBF)VVV2^vd_l2+peKr9`{&!cR6gX-pc&F~}24rk(Xj0{J# zjtK5pch#fjqUwpH&DBYkZGn6`&!JylcF1GY0YrR!{bXUSZyBHk+kjQRW<{^A)p*7? zkD!Nv*sWmq_NT9=0CZ8IjYFej;-yE>F+N|ON?HXpF~N7Sx8wTq}f`kc<#RGjt)IJHV!f1x~)P*BpSdQ{T5a5#9aKwfCg ziEsYVwW4ao#at(vZA~LHn{IuoW6b5n8TqGu6Z|U&ha^#<=jrQviSr;dI<6tS+yc%1 z0ZM^0w3zfrSF!n#3oExA;}S>EVn|p$^ILz$DzwXPVo_+`)%M76Y84v9g{sa6Hp%*D zwL%LvGXA;X-&i`OfsDyT@L89R&^3@SCR8ENi~7O18QCnj%50>YCSPxF+;D46b0X#p zil=3T%!wj`DYP*>qkMjJ!hLLuD7If4Y)=fj| zOJ7u#qmPtba->tFu4BUqm zHP(pjD_7h1?#c0%Fs4fAx1ibiqr9%0n(}jZ4|L4V*W*SP{Pp7I-`r)_zB)$ychaZs zQ+PNHKR=N(uW&)ea;~XbQ)zmAw#1uuVUvhq#@okjpqbQ;h{z*6gjaeZZKtBtky-WQ zLtKi`?PEJuQGMRXzsGNX;z@Y)Ne2DKlf&d;pHupQ`e^|4oTQtuhACpiUW4Fhkq zO_h+F3Jc1(9zSWLGIy!m%uzXfxtcfZ(*@zh{)`O_<@Lt1xCV zb9vPBslQcp^`2-(;f3SjQg@2H%)_M1{^`SyD>YTbZ0zL5+EEqN`J!VfP~%x|k+cwM z8*@=~^FdEf-8kSps>^$sbrUPamSba$AD`H~ElQ^*;zA^jN*H~V)S|bsQHdR6MJVMr z?dkG!b#*7LwtQG8e9bHj|kvL+gdBJN)+)CQjf#29_ zINs+&=0RHuts^!&>Ul#;6E%!S*w`T0rLeWXoHmcG>!TJ{rn3kq-7N#BLmt&X}! zL_$jS{3ilQA`yImdP%D~R8wC?g=FbeyO-2_!3e^td}nJH#x}vs2#P4Wk>*k&?hfJO zD>Q3;cIh)O;-X|K%&cIHT@usFR#?BjX50L<2}xOKLjC~)k3Y`H>mED+ItC4PoWA1? zm@z5t8o9YX)ahNh5R8pX)^o4&AM}-EXQ@Md$dQ5wv zb=VdTL(=^cF6)>m-TLrX$V!1@7gF4ix;o}fig0A!)`U_2J~VF&D{CLdiy_x*ivt(5 zw6a(DUdV5}QP+1$o{cobsufN}`BO^=$2u;=9lQ`MlLZ4=35;2#$LrQ$Pbia%lJjW5 zS6%F}_kH606a*>NOEiTFZ=W`DhB-`r+kZ{Zc{kGU_WT5?QUfILS!DMqSs<4vt)l7L17p$y7k~DwY*o= z%rviLtnyu1S$<8YXM6*lu%Af1mfax~tR`}5y}HrM2}*}omBe|DUyCz9Mu$uEsg)Lj zys=GQv)+l3uiJ)FuVU=i^o$=5#Qh{JlifcwUkkhb>Zng`GMFDd^9b`nkbtnrmSNm1 zu`Imtc9Q0K?;Gtc452&`;KUBC9wTMq0BKBo=)`#cJdiN*8_NgrN>4dDdN#mUh9l)a zFLfR4*aU%~RRY#OB+h2xzSZh|wPN4a#@aMW=7&WF<L++kGKL9LU>d&|xFK<($8R$6>$qup3k&y`(&(K-fZMnv0_=ne)oWp6dJXz>$}p;VXu$Pk*ga zX!%Dw%vAt0l1pOZb>}BZyvFx5+NRQm+Qnn48WoCs6F-+_+Q_??sg+bG9$HjurO>ND za=rgd9kesuBDl2-QKy`xt-ns6$ zSM6v_AkkH7EJdk|dE%b8)@Y+Q;@f(fH>M7EI~aE^%Y>e=P&j|i1=pe!ha=9Z?d-YT zEMeybg^rUfl$jP|uDqy^K#Jt=*c}uI`0)TT!#qB| z##K$$*_&~$>cP;5ZUS1^wk1c=Q+8femKYx0p8cwd^41geN)6`?-za<0w&6Xu5eW3j z?0;Ifc_vc8R5MNuvrtkrGhB8#rV{>wd{J>}%Vg7!9uiRpeNmuBkmg>}P-Tu<0%@jk z<4TdYZ#z=9fMb2MFCe<3vKjpqAw;V*=k{ZTVuUxQ5a)~8EjxTD!u{e zdy4c8;v7y+N^~ho$TsbC@1Uf}2%}d+KEz{EA%s3>AMY?a;;c2k^tSfvTdI5Y{4npV z)kIVlbF>~Ukq9F!(40W-yGp8?xkACm1h(zXv_Ty4x|q+zRSgk_TksS;BoljTUOu;? z4hJ?<0c28__7ZOoU@64ZsOw`2{K0--$yAk;4JS^~_R&$}dks0w&rc{yH`aFnr1L|2 zwZ}-MmT3*y``f1le0i$DVon58y8IiLQZ0v41E&*Hk$aE)1MtrWr$M{Zh7=D3RT^q5 zg4vqtaAjn=Wxp;3?i{j|?eppuN!$QQ<)0f8t|nb>j}N`xNJ#?~i;hETh=(k6zOYQN zQCi)sk3@B9C1cD>Rvfk7ynv`Gx>*hlmk~9#^pcMMA@Rue&=BM@$-2E3!a@A(rc zC<6Aj0oJoZSQViD^~Tkv<-am-zF@k;AK<1x($&s5-YN!4(9N=V_G*S`5ON2#V&)pa9~{=F=&FyMdo$H8pU5?JvSe1x_+1;(=LSV1EGQ zHPI^2X%9qXvRADXn`19D&?ewPk^0f?v!_x3n;H}KPX?bLxH~dzit83?Eotb*7C|-V z+Xv^O^rIz+dRpt(28(RtQA~m)8nCds!oSPPn|LIKB4yU^S+p!W6U$mON-7a!buMwa zP9gq-6W;yPV6{JBI8-C}iV@7^1t22ZTo5OJWt>j<_8PWu(KuJc$b||UI zE1G*&9s6x{b<`-$7XCQK^MaRbe7LGl3d+V}B1%xi6H#{MCkdP^1~(ck>YdyIZQH|O zC4uVpl*;JwW_A^YdTyg%{>{>j>oVqMN9@?!V!~@pY)|bzIxtY_P&!_c6y~P%pAyoM zV~VS^(6NwtcgGGFKosHa>(j~J3x2!X)6^ILIjTabUt0aD0x&wQL9Q7}X`od}C$cdO zvFd_|(-R5II>n0u(s8B|+6<&%=v1w8cHk;*T%Sn+#(90kVSJ}OLb{+)?nIB)*U6X9 z1yc&~DfMr2nB^eTYFsu}B3q#jeYH*Vqpq&sX=}OTY|d~Tj}mz4;UVXz+M2gZEv{O> zz4@=yT&TxbwbMRv9$ImlbNFiWOHF-DxNzUSyG7E7NL8x9^=J*av2=szSenb&V$dz? zMM~d-$4o47==lce+ZGYjmZWEDt!IuSHaCRjpmR~6+NoSU5#;U#XsK~1mPw4@2v zIo^J7q49K^J_10|Igv$Tf7 z9^rOjMxFNn*fgMO;R8jH#f%h>;IxI%`Zw=arjD6OzdyNE#Y>+){L9&2hwPwTtMg!M zCfA%&eN{(CCzKkEB0QB$`#6MQtpK80aXsIOP1?yB5egw|-`L^=r4XoJ-JD4OH!;?Y zJn0uI?HgUZJ2uWME6coo7aDNSm`cxmW_-ziXo9Nojzu5OZ&PXoxxs~H>7AClZn#v| zI~Mv54Diq%Dabwddy|AWZ*_C?ggM)L-OU0);>spqHyz@MSAQE4nWG?NuoYn-r^8&O zAOp_#CaLJecJ9XW?(@qAjXqvrwBhMNMI-(E^9MDy`$4oX8J|dd?rsG3vsCxvds?RN zP{)PG`arhwV{OS6=K}k9!Qc1s*eM1cbv*Ua!aZUR*l~+6-c|YeU@m`Z`h^qfd$#AW zSJgSdXZml@B(Q8ZCD1{-EnQMP+9Jg^;}6 z%EqA0M;kXaK8EH_{D6?=S+t)W`a-bYAov@9&;K8u=(H*yg1cmRkWn3HM z^m>I!_h3$Pusui?=JE$j_pPB&hdbYHg&I`B68MYyh`9i$tz;W~%6g?jyC1z%XZ zz-V=dSN81pH@T5xLx|(-;UaBuXT`G%RK~YIZ<@WOSYRXCH09!RTYZ~B-0r!&+m06- zz`XG&sOvedke;O~sH;GK2d`)Ao(Pq)H{tXhycw6JNCT%I zLbOR-h15RTQAkfYcaIwX`(`*{eGzm5<%JGKSzXEB$90VtA#5K6KgY%nT;j~W_7&@J zTRgidPkUv3JU=JP;vlC1jC@z_L@GOpJOCO+LE<+soMB%2f}>xU;^79cJ9r$lTda?> zJuOQ$V5bKvT~I-GZ+hixcn9f^H{325m=1WLBxP&32eT)@n*`;z%D@l^%slsyNsAJD ztbi$j=q0^lsgJ6-vKM50`1*hMhRki#eB)iFDQtzD9N@MH)}jG3hV2gfG9DP(vw!#~ zcRkZbL=)^(Ye8FvJ*BsY2>o?n+j)RlxV?LE6zr;ZucR>EBy*P7AGRHo+5Ir*#Ix7` z9}0PU;k=~FBwKC8=T_RY5IQ|l!-Cvyj6asWuM~?qZZ+d<1U!ye;5G`neQccsO^;z% zlHHI7*KQAUJp`7v=u;Ub*k+~6) zv66VUC0ALzT+Ett+lfW#X50s#xRPUmYXB+M)dt?C3+Z}(Guw$RymxF4n0kh<%A%70 z6}XuOTp(| zB2TOC?T%(^sgY z^m$EIB)gCDA@nLPozw5$a_mT#hwEY&f(a%;x+KSao0Lj%LZB1*Q>R zX*V=myA=cSw{1PlJ|S+m#b|dU5qeOA3s$8OTQw?K(5r0dr2)`5t)*ip+{_Jb)r8n{ zcwf^(U|s`_>fHJSBzXC8AL!8R-%UcMaeZSrldFwXwl)mOf!vuj)DrE1o!6Fc`Gzhh z970xSzCCQq&IF=?>BUFNp>)WJ+-LmoTk7y9jQ5mtTDTzdsv$Rh=4(K}!#|ah`d2&W zzk`S8_a5WhoE~E_4pxO70hVqD_WAg<{qF;;;^V#${%z48#4GZV6qzgEf7s1Y#+xl= zJXYW!?M;-Of+~O;Fp!eKs508kgWX=u2}JKSIeww7wB;AOo^tG=RMg0D*XUL#5A*!~ zqCpN&y=g0QNkCq9pV&Fx^e$9o2dK1_ei=$g*>Vg)?ldslKsE3V9ftod*f9=Jo$jq^ zp`sz99L#|n`M4FzO|!Oi@x62X;;&nE1<*2_{v%r#dv1bOscpv$+v7L&7qC;^ZzC?> z+wAxFt-T|RJ^(gSi{a$cPDE4zmbxHJ?BW%^jiFLV}LPWs1u-ju2=xX z-db*WPtV}^ME42c6RhVtdI1I7i-H^jXCBxrtOMmqKFtwl`WNtkqY7KA;`pF&DXBR@ zZ~pBE(#=y8)K3iE00R2CMM;7b1^5J>OBK3Z8}A2!lLH3dtnVT?*a=CU=0tFzzd;1Y zDa^@m-(bi5DAu8-f1TIBZ-wwVUX=a6&YXN@ z$9%P7GT*z#v*M5U{I|u{ZIS~{uzt>&6E$vYEBWUQLF8;J`y9pJv#l~&_djtpA-A;c z4?m)=OLM6dSpj@rKJ_~6z)kNhO<06;G|`>Sp;9;fIht^L{Qb8aO_ZvE+y(K+>!0gm zcg#x;Xu<-;*2L93KCXN^IDrD31!8N$BCdKTP?-MB2^3;P+!uN#$ft_9rhi~*3!KC> zBVb3kW1R)u3oCRDc7Qwrs*zd|rmp|#!w1|bg3|&Ffmoz)CJlic<96Ibw41pw1To#I zud^5M|LezxOkof=6R2TX03d_uE`mK;uBK|+jW>`3SuvNJuO`Nau<|p^wQ;N2<;ad! zK${>Cva4m`WDLDP`A&0qPN!q#$tA0zj%SB$%R=nUr%P;5^nyW`=I}1-x3|nMczdd( zlirjRbd)}XD}>yfJT%j%_F{v#{TmD3F$NFLed|a$BswhF#JdoG34WygoE`X%X_d-xB3!*x^uJTkZ?k@o-i^x>Y|v_krN3$fAVBm z$hWN=tE-grR9w+Wg|B;3l}A^2SC=>&*Hneb*dnIOsh=O`eY{ z^c+QI&nA_*O-&b$)~G}bdUbwL5-fL{$~j|GcW(BA5@l6oUDyJ3?#ZFfycU*&*fxkubkUj=QOd}YP#_&RM8jv zMSXq!OM_fxUtObBq)5>Hmcybkije|oictb_51M$KmtQ{2r(93GtY2weRwV_sEbK}- zHmd-C|E#|BrtWm%jd*Lrp*tOeaT*hpPnw6(_vdb@tbEj=vX1JJDtelpO&kNJmnUE# zW%19m974t>u!vGMP9X!-Kdfx){oo=ADq1F8)=9b3XWB~mOR#C7`fM?9 zc1dL^?^a^KT6dBxYOX-(YVy*Obp(~kB+>_LJC?|Ey4KaM9U|UZUp_Ue%zwPa{!1t4 zJNbP1cv6?b=H7gNNIibGHW%I2v;+?N%we-LqsMSkpj-s$K4w{DACFic7-y2R0|S{W z;v*GL_KP<0tadS4MH9j((Y&g?jTbW!%h%e_ST6xDBN@Ef>{07g@ zH)feRTE$1Syy(o96iSOS5la26BM=eEZVR(Fkb1nQ>ZZL9{ZGIPR$D5-fvvo&eU8DW zqOKxTO8SM7j`B9KqzRj}%H*VIv5jD5!kP{b@$dJ0d^J=>Cit4es6jJ$jdFl3ZT1V{lzW_jztTSPBhbb7+u zUUO>?^baQ~mz1+|Pec@I$o61fVaAy;A9jIb1aDBFKn5`tw6U?FmIJAZDozu$Tsk{G zC<)qb)NfuoOdodDBk4#A$3{en#y0W{@C&2$#>VTFcrj(aMmsvZq^NKHVd*_y-{BeQ zA@tI4Qbiio_$gH-u)jOw6aWKlU8(H*+INc#ibL4PB=wj}!ASFP5MF_^i3%!vcSSj- zqQ(#kiY8t5wH>%9uu@S?dfqtf{eG3ZFQ-2^%xmN@;C;` zAhcF0jY0!M{aBCj`Fe-CCPUWj18Kue&m#A;hyEQ5eb?XsObb*^D2>Xlpf%uU;NeAV z)1>4!#$f^if-F79>o?Y)J`qJC>R0PieEtF2=+#|7smPGWiH+aEplorgi(T_Ot zOdpI26Eu*Ti+?gLhC+Zm^Brrg*Sd}91iS?TnVaM3BN1pAMgY)r*+%XAjUbXaNd&d& zx7fx;IxupxjX^eh#w<$z5VeVa(xAgT^syCiil~$j3(Y|6Vj%88rkRx$j7^}26|?zP zt-*=mwmogsoQ!A)!|C4Sopzor8U5xtQLn62B zVU_9wGgi5MFKCD%x*%2}Yn}SU!QrK2L**HB2kV#Ov+bCe6TKz=ny}skCRS}9ac;3S z*BdpVs|S2N%reGo*acu9`*1G+1(&|KBKkKi=J{wu!%c?o6t5r>gP9&r3GDxtF?EeN z=HbgXL(jsPH(OT^H2Bsi(G^K&R&YK)MGd}Uf3VL6GXx3SrGAq z;Ug(_MU-Mm_bcw2vv`rHbWp9t&AjL2I!fS5D*?nmdvEiH+0&QEJWrrn94Ks$hNT(Rt+uQg21fD0qk1->cat{9H zW#wBX#eo;5x*9^Eq0Ih@@ul^3=FRn#3b8=i+fzP$dnKp;lzbtlDxyRHqf>DvIINbI zqS}&GtYmJA+I08$`CIqpRG_y7c#fP_{S634 zq>?^T2f(X|Cfrrxxqun$yxX`x3ZbaHNm8^f4bnlf11NniSb}hn9~BcGzMe4!Cfxn! z>Fn;4GD*k?RylwXmjLoJ_92;EAf!>~Jcjw(WFV_cOyAy~`cBlS{n%908P($&|Eza) z1x_j>ka{liqoMdN{uek$1le9!58zTd&ozVBI+~0-)Nl0w98y2`_O#8Dwiub4PQFFE zjtNWJ-`Fuu&mmY%@5qUlCTZ}HVwL#>A+@+FXkOQKuRy223x7 zHUU*5OfYmn9V* zNZ1})DrsWe;fg*IL;sd|K+56;+eIf#>|UPS2$s|r2@1R<0iXYT#(vBKb{-7jmSA=u zSjj!sIXGQ1AizPv)0NH5(izgR$P)E+GbEdPHPU;a3T#|zePjs&iI}1m?Xw*-nKq4c zk#9e-$#@d@;PbPLOrRRm%rlcs4)!W4iIt$rs%-^Q@~yK(>=6UqrVG&Y-14P=k_~-& zYF^Q2c^hSNg;fg4H%j%g&8S_H4sBgDt>l&D(lKFxpTv`nX+7lMVWC^eX zeWXdsxeNY|zJBX8uhXgmVC705s2X!UTW4d*Zq*v`=c~6gUK>T}3Q?2A(4i zwA>fkmCMNt7IxIW5G?o7F}EzVjwcoj#Z@a`aCV*|7Y^5`xF=WL@$H*FznL>~O*(ed zL`vT^x3!~c-b^aHKRd?k$jpGupNth_r_G742vePXqW#J*+$TH3Lg9TF6VxHi0PTIE z>Ngq0mWLaP>E4rv$U~A1LBea3UpuX9E|NCqaf*nQmXLL(|MVtv^@MBQyQ#}Rv2gMZ z?ekHcof(yaebtSc{1_*T(AmFq6kzi+h4z?p?#dpWElq!9yXsI1@f9lW%AQ!j`pf;y zp@SDZ_05+CV+^v-_tOkO=nWbe$Ocw26D;1)E7K4pzS0l`zBh9ml6i879Q}IFI$$rh z&~M1*6Qcq5!w-wZ{K=qoyx(AWPKtDwc=tR3_x6PCNssv;_peOk^oO0}uA%WqAlf`d zll9{AXKuWD;*f-T;*f^opL9r+l^tNrhKD=&s?6qnW-Cg1()VpW)GV3QMp*Nj*Ne_$5I-c{$}0vT4VK}am3`4FX|&-Z!iedqmdt-C52v@ zAJGzPeR0pIq_#H0i48ZGKr{r0Ho+|f5XkCXdTox8ZRu~(j-fKV4fVg4$l9mEzosw0 zDd_0Y;ki3kdP$}5Eh17t;a9-lvg7~?+0V=%YdskL^i{Ru$*R=C$?+7l%%JnavlZ*w zVkxLqamR-N!BudB5AwN)!mkveo`j=+9KqH_X`G>ms43{I(?^b$8_0N-(`R2=GEqIXh|9nFDSpi(sIUjauM@f zpu6rQMI+QgPHpjTz#U4Bgp@9>tgPsYDgYl^)s}i}364J^sTDEoym2e!g}Ie_z|C_S z-=6QAmdEK}LS;;F_Eke;G>tq>$>+bMyakB_AwBd&;C;+VpV~*lJLwVdtZ3?zd(p>E>Lv(++L3knRlS5xtU_@eA{~hC!gv~KYDwruWn-41lXxtM$Bay z1miaK1wX(ci$7;uB@yRAy%dn9$|Bq9X{(a@w0uR!F8383#g#7c#KxP>ek|hqcbbPm zT8L;ltafoKT=_0oy^2S7rGoQ{@xJ$Pn65{^`tI5&LDiOI>cGWlH7oMQw%I?q&D7TF%&%pDT|m zZYy*q&Vvjfi>Qp5n6sahp$KT4afv*UHf12=Gx)UCyOP>Q>G z*sH3dH&WO^<9>SRO8XqMb+%xsGbKBa*(E+w# z2SDVHG&^9;=_eTI1n3sF;0mx|T-npOakV2}(RZPDeu#HrNDYMvxE#7!IHdsenc=h> zmZ)^q)&~bIAtjqMCh;FH91h($2}p*!RcdNfYLL;)%rj$PanCr6RczGO))J6YytqyJyy8;iPcL-!emLEakJ?n-#BJc5o2IAdhf>wuuCS=j z`k?fudVInle@>S;oxOa&+)~_1(+&tsZH+_|%RL0j&XKiM1XPMXs93&)!*yb7uL242M+(0(5mEk? zqOw7F{)=i28Qca3!N-{y@cMHyM?8C@r?G>b0=)yxOzX&yWyjF8y#>l*`jJ8kztWi4 zy(*i-KLIvLK7PT&3!56%n1WgV+R3ih=$pk8D4Kr8tWR@O5s_fSyIWQ&d--NxoCJo^ z2lS19$`;T7=>^e!X@r65g3EW}L-FT;zw>V1H#7c4rG^{;!DHJGCog?QthtJ$Hk{V? zF)gWOc6p;-31Zbw`ughT0v1blh%pN~3oc`TD;1xkF9b)2JAi8oAiwH^f{MJ=Mjx)6 zo#C>J0j!~8xzmai&65qY8&Ma+HY%%J4Ou9jv@R{9)Y$1bs)}FlgC|7M5)FC4c5lGI zrFdapI#StBf_55oz=o8gsth{Bh)orPie+u92*FzR$&^m|^_=?JUu|s+R9M|D^)%rp z?A*{>^?>$XSx1bNW9Xef*tEj{YA6LthtQ?3r>JyZ#{?Ffv8~`4AQ$a_9r=gpZC$x= z6J%)G*EFG%=JZh~j4|@LP`^Aal=;Z+{6Z;+(ESx`@S%h-;sgCA%Ea2f?SfPNhf+7*Oa_3xV{O^*$)4%h1<#Qr|4F)OT3|uF-S3+Kk(oIi z(Dt8nA|m&7Pi-&`LZSF-QBVXe0uC^#zMLNcop}YS1;9&8!ER{KOD@)n?_hoT8M}s) zRv}B0iB&gsk#|1ioun^N91{E^f3X7@Lg>_@@^R9aIz$TFcS`+r9M+;Epq-yjMQjbJ z1kUP*6)zQ8fo-XN0n#x@81|e?^Jof!6jjA<=5>)G9Jr2~D0#Wt)R|pRVa%enJBG zS>@@*M;d!+<+3An<>y4SA@sAAqzkCLsw{tMq_-W8zYEq4?o3GE0}AVHu80k7hmc@r zBw-A*w7`t-i;`764ua+DGn0LL&fLg-xf_wdJ0plQ1x7tfYY2C2ov zp$3CqZdedOme#JulWKH$j)7&umme->Lf;R+(nnskwWW5sY-Ile00iv$_SaY!0OF-O z*|daoWvv|qEp?zqea32H33kD2B&liNN(V1%)|&{pFk4<5rjrG7(VOHiA&U)1`)KLw zOq8A@J8ze1Ra!X|}`GZ#8AHVuD&$0`P&`8bmyzrSX=T~R# zVP_!HpGf5s*sPMxi?Z2fZ0%BGc~RCdF?JkxF*7)vTxD@`FIlzRG8qK(QhB!ZMlqXk z)YYWJC&o+sMb-#nkNLs`Kt9++Z9E!v1<9m1)~6(vllX)|2ube%3oYHcJEyyEeATXZ z+zfUA)Xu8!_k2m&Q0AS^M-we6>>#4J6`FRL-r8g|x!eK#3go{@s@3F+K;rhsQrUlK zoNome-^_N|q#7lHcnb!hHKTCt6?)`JiPuZ_|Xj#Q_XcAhP z%Czlx776M&-5?QjGv(ZEr!gShcNNs}hLfu;i#ymg3;iuhglM4jvxj+#6;M>i_)piw zAjiLL8m#tJ`P{Z4-Zr zT?tpb)&ElcK_8=cxWu15%-{p*n6a5ZpM*lR5e`5(Z51i?l{f*K5_c{ z<2gS=23i95L(=Esz0Y7Vn6r{E0Ht7QCB&TE0O4VO*zR!_t4}eHa!DU4+U0Rt6*K^B zz4#}YB;W^caLNuw;JPNZAl|Y!m1uA$g9{$6ZCVac2f4u3JfIZQms5J@r%mM5&*@XU zA35?11H(`60}}Xq3E`8y&BbUb>6=-_Ge4`e@`GhdFAj;S zYk*>ZyQg`MOY=-65G088=MALr;23_S6istCM1v@;|0!xgI<;HbJZGFu-%Zb;+2B`!_<3+HJJtN z!%@Tz=vq)|7OFIrCS75bCPhH$Ad7SX=~82b6-AUPAWeFWC=fa*BGMrNB7_i;8bWA+ zP(t9Fug)i-Rp_SyK;eJE{#9HmPrUP4VC#V9eumfYpN(! zSykCg|C{2WZe+w8YJVMwg9)-pYMeD77>(WOZLfK(B_y}JXn&v~_`lsT63+H9;^@3A zz&ai3P^_2Jv9rNb^o?U*z=cGvFFem=x(zX~hC5DB9MX!G0ph#3IiA_0?Gj_CE!X$I zLQM3jH>8|w@c#1_-CbbVGsA$!c3+EAcwn$iN#I0T-uZ7wGh#7pP@H9|&apObnTriBqc$9%P4gSAH*YLjk4nQ{jeAmSDyIhh{Fr8~Y@JiuWN!{0i6j)iHeCq(0J zX)xbE4c`Bs0)&C<2OQ$DIWcO1Vq7ZV zD(BvyH2(X^|E zhBsv{W+OiNqr^qFWrpZ2Q4$KUBiC|oYv&vOXZQjC&+r?!oJXpC=@Y}sTy#H0;i|}mmfe-_U-MxlTyriUMT?X@|O7}T*=>Q4`_Eju| zy+HCmX9{1bW;7|#o(xwB5!IO!x;yWM{q%JoxP-R9G9`EYs*B^2o$yu-mRRxitr}Bz zgms0NGZM)*J`FCTZR#sqC({xAk_$gPbXz;%jtJ{x;h*!Zv=yZC?K zW~iNi1-boMLvV~&NmQm*!vDVN~gFulQ|I3(o^(ug2jdNkz%NQ zVzB2!@K`gfq;dFv5vPa2?LVE)uazGwW-~9zj&P#Hhv(S$CPivRukzfr`Oi>tV-0WI zVnsN01{_69yT9R5aiUMyljU~KCbPmGy#6jxD_R8-0+Lzo$sG^^A;S2-(^0k($r-~+ zW~PBXo-I5>m5e34tL%<(U2)q24y;Y5hC%zDi9vZl)dqIM2b8WZdeW)Pu4}y=iA}_{ zmfETZZYPTeOYe7++Xvt)9$#Gg_Vff^a(l<+GZ$1x`Z&+yrQ?rxpliBe;0N?A^7M0;c*L3-T2EcgHki?Onf;|L4lUK?p_`Rkq%c zIm-E~Y|*3FL%o^X_+5|PWnvTkmJ z6H|_S%1V4l+^<^K<%L^Hn{WG8F>1T+t;QD--XjAX{Gf^vn)=9FtDs`k!2;V`8%av4$QwYGq{eZ{ zg0Xvf~^8P48TIr_}&(HH`2fcWLeBnqL@yRR<3B+>FhuJApWnN5+UO;|liZv(!K3NC#%WO>lmr`)1C^FnX_w&fr>{tHmUJ-T znq+;Q7v1+5hbn(VEoq4xsN$V!+U&9H*r!U;LhGAGH*(W8nRk9^lx`tW=m#orq$c@r z{J&KHvH4}>#K!R2y#9o$LkB*T5C99dik$xl2{{V#+GT_G0htN??Xkq*sdc%}<=LBL zJd?I;V2r$gHW1sLhM?(7(98G#6L!53IBHjnmZaN$ei+i5A1I5`TD`O*Hp+B9`z9SF zYf~EnmsU1|2k^`YkQsjXr*AG_@}VDZI&Ro$z54_FXC`PGs z`@ryKTK6Ow*eLu~?ve+OziIty4X6Dy!e(xlffcmK3h^m9`!GRe@N61iCkqf;ly32^ zhOUk7VX7kM_)|}Se4vv3$wXVks_1`QF^!P7t95*JK9FHX1bI0EJ%qlaJw#p+LZYYZ z3Uv9D1lKp6C)x!=3&F44zPT9B=p# z`T*F1d#DYbzPEJM_0-{&>Gt(6+m8ef-SznC5fb9Hweiex95fC~VQ+vV8z)ia#Q&e#qRGqx-qbA?2?$${^nv}cQvXjPJDI>Bw4pER)6IW zQQPg<0N4JF&DIw}lbseNZ3!dDz%aI13!r;`NkT~rihsN*q%?+sgyQJGwV!=_1w&UH z1McPg!}M(-0HA(G>{~xBxyX&vKMZT3%Bdz7t z43z~BmEfD~1*_Y8Sq!+Cd_luDj@b5IeQypFWeT@RQvr5gKkgKv$}k47fPZLHuk;Me z^u@K|5_^5{%CGTxn-Smq7?8*U{ig>+s<{^-RLlbpA}67mUcVlXKfT>r!>$YW->og; zYU>pe>&4b5zAbr)^2m6at}j+3D*3leoC|5A`z)vPbjyHd4M+}VpJ*NPn75!EQZ(&Y zZ{EB=HV~q!q9}=DDle!8ZNI;7t!VRWzMJYdF0;N^3pW%)f`)IiM8||vl=0tfTLm&> z;F9&P)!dVmMf1>db5sJ}6(Q`sdbqh#yEkw9NLtpl|cSolUq( za9XZ%GmsnqUa5vZ@rq=CuRXbC7$4M7Q|)@wi!RTE6$Pyuk-F>Tv~30C%9lhE6gF_F zez)AW8%e<2JdPkksyWA4V_pBLx+Ml&#e4nX)xyo?FdYm%9byoa8Q=2f|4+oDIe;F{ z(!N)Ep7(CDX@bLSq2==F)`xz5L(x|-TifI}4Dy4ms#^-{OM{A`p-cXF+ld{@ueNw$Az>-m+znc|+;eCEQLrg~{El#kU#IYgAJhNo66MZuCno*On++ z6H8sGV)*x)>&I$B;p@mUO9Ycq7)Hqf&1b2gwl5)2{(L$wOkq$C}CU@r; zGV-qXy@=UN8IbLyvJ~y567}}&`q?}Jr=g#9g(LniHOe5~b;*WUMONX>`!O=X;2S_G z9hlgz|Dc5CAMCN*TBoSma|I?N@j?#LR`m{{&@g7vjue>Si5 zE-`J};0%35g2`(3G>K&UeD2m)UTDd?yV_8i`STrrE>Duumf!l)zNkS@hHGJ4^OHAv z$Wt=+aG!t7#qUe1tKRI6nxd>>kjZb3-}I|++i2-(Z+`IQVTe~#W@}oS;g%ONIa#P; zo0|(g$B>N^&IY4S;iHCo(>%1&D+Jl`gC9QSFXG#@#s2{Qwsa;;H9V~cM zU7aB3>w;hrd%WZLf5Io^&-%pRe9MZVs(W6rZI_AoD=PDR*uWqVO=t`EkM)UOnrH}A zF{{hB3?}{LPoD$9|7f}dlPxfaZEiQ2*j}Ho(2Ax;@x0q+WJq}pXGAhxhJ-KKK6gBX zxT!T_UZ=tt;_Jn`KF%tC|L5-=r>p!PEUgy=fQtHW&?W1}~!}#i+9SxyhIGdgIo)gCh6`;sT(9z2e)n(NFUdR)kB8#b`yU zOh8?y( z-0f1FR9+oC!ioq?WlK)>9wlyxp(M;=peN{jL+zqhI}Oou!7B9IQM}L#xF&p_80@D9 z*%L_Y0sDDuM}1j=h_)ekt{1(Vun!7bc2;)#vn8jn^$2t%Q+ThGv)JTFTH2(3DrL%u z4qm`F5M|qC1&xNx9P-@`2x;A1Mt#3sLgh(vnQW&F64rbwb^F{ zmO#1jv=Ze8NJ|a!B?9OD)Q+UQi1ZJ4`kCiGhb`ogMP6Ru zI;SS$)@bJDdvpK3I})Oo4D25GlRP%8lC9ShJ=&?YM;iKHz2TPG`qOJW7VjR}9n^OL z@z!LPpg?;*N?fqf@k|Tde!hxY`QU#oH@<(NM$(*CeeGezF#TQ}dV{}Ge_nBlK;H7g z)T}=xcn3`bfq(7lIuidzJ9lgYT=01qI9g4fI!*p<552 zfe?YHy&;^<_CP`6gvtAokBrR>z10`;&j^aykGN=gqo?^7XL(0oRW~I+QV1Ok*)Wz; zPwNw|!Yly*-4i{+p~y{n&Yt`AlWIYDl}) zbg%kq<$G3spV>QldUt?G_bU5QT~@6mY|^1Q$2PqCcDir<;b*p=hF&!&R_ysaMbkvD zM*mq8*@w8MNpDT&Yd51{2u*?HIomqj1eT`HpFf+|fzXPBu!>53fBPbO@Qb5P^p7_@ zh3nL*WQl#0`=C~K@#4kk@w9o5=V|Qkj-J7zl1G#c(zCbGCjJ~#jsoyxk7+Fv3aa$} zt%aFr!?8F9#!jwAb+Y}E}QY}&L(RGBtPQuC3O!w z)r;QRqN-9>FHX+~9**-|c-nux*~F1#`qzSj??UJZ`Hy)+{X_062ewL=q=;e3yN`@m z2QS{}gfFJKk_U=&bawYVr`ns8O|Rkww1|4-LJ7}a_@6_ERb#$kUml|b=W?hGpu<-4 z8Qc3>N|Gdi3_)Bwbw2iwMj`wAlEx3zxPgbtTv28=-ScjPUVf?00c^@j?hY4z|KYpE7eOoZsy_%M=tC1KH5fPh~hT7Z=#%3b|eOu1OSrtd~htzpQkh~tt zmfN+kV+9%!-!vBzzW-uBGm`m=pLDNP9y)&7d9>4ymhhiLG?kz zezsR9#SI%m8GR@lRc!Xzjw(xuy2=0~Wf@23PnI~a>)V8v%vyQiiVJ!jwxxf%_Q_Qr zd^lgIQ}v!x*G?VS@>z|n6VS5xQ2(n<0Fqh6C0~=FsWZg z>MD>zt0ZsTJ!h-KY+L?~AM(DNgjpS0mJ8HG@hr`i6Q^$@&7A7Sc+b7+#RZ@}=JjN( zs!q3iXJ^~#n(R8;qYR2TNh%?MOl$gZRjJtQ%MYIekNHWN`l{G>|ByL9n%R(1yINDs ztNw08!rB^}n-?(XtA+maBQs!sg-<2)a*e90swmZL+1c4(^cWDjkqKUV=sWxCwup#G zL{yXq<6H7u*b>kh5s{Qc`PD`D6`Dv6QpC5{+NkfZaZ{L1*@X#TUK{lb& zpQ(P+b;XseSVT5PwXpS4`6#&5r+)?{nLYl9;J)m~B~@_Ojwh)ym! z_YWW)YehftuYX(e_qWRX`8_5r8V)!6ej;Zl+TH(>Sh9cgyTh0M(9Trl8rtHA58S#R zuHGh8`x?RKO1lk7!&~RuG=zR0d|+PY^zMURt_k_Qa*!WI;p4}T!>JZu93m~)*h1{> z?bmCe+A5!<98^*5KVS0v`5sW&*Y}?6$R~use=z@QKtMn!-ZA<_wb|$UFCWMzgCuTl zS(!9?g+|7qS|8pF4Gqo2r^du&9=&k0Pf-vaBBs*;3o3xMDuSspDAQ6kkVTE{bTC4@ z6I{q8`BjteIZvDjs2eUS5<|O*i23ksS5%G7Re3zA4)lMC>qy?{XAfZ>IRxdUK?I+e z2QfKbZ7B5%=IbF`PK;gllayqn)q^ab!X`#3hyMGKGt{}+{tf#FqOo1^Hp#pngnbu3 zVs9llxsIH1Y%jLYSXqi7^TqIX4wtQEW(?3pEIm{AJ{}lsKqASUyVqJ*W5g* zJA*TPY>1ESTjL%VA723G*Y@-00-naL5^NfMV&Rl(XmE^`!<8#ne5jprbe~&bs?zpt z$Hh%QrMHfWo3$v3i$~rQ+WmvjR9l$|3_Sudgvf}!tKjoQLS&1!X}wBH@bFOBbJRIz zi!Qs`V%-+g*0eAgrDHOj>&RY4(|0wl%9^58s?xq()|Eu-lr6U_4)X=MN0p0}S;y&^ z2mNA{ZtHq%hAcHkVxBb-o{5c4ri@|c8aFoi5Kr4mtZHs0AT*=jq}3Ez*`(a*?(#Ih zvLXmxr>(smyS6yyn#;o;4vrvud3iaIdh+B+rr>3cPRSiOZpj|?Ro22;4qR8Hq-0zN ziULu|QjTx*Q*7ocn;20|NpF8JR*A&>`*Q@?xv!>!g);r`2u<4OmY278or)k>owkln zA?Hmk_&32Ol`JeKW(?L_X4|y4!Ck25FKigi(9$@I1ROC0*K?|e=Z=o>;vK4=_84Ik zGjj^ny^6}*KQA|iV|riBeGTJXH2fjHQj=AraLXQ@0x{^fja!nVU1EYBdm? zH}>VF9xHZO^u6`^v8OVM&IGyv=+0w zRwXKC$M}Xtzbw;YD41RUSZyWW6>rggsWsW|&*>Sbx%VH$;x2nkSzM1fBQqb9;+Pes zXTB@Dl#pE$Xrp+NBUqRb8c~&`8x)vOCh;2GP<;HviTqEW4B$+eH-v^z#<02ixP{Rs z-zGM>pY9%8IJRy@O(R3Y<9vL?S@LE%cP=&`PLI>}7GtQ~HG!S`Q|Q~nr?32-c{36N zVy@;^`oY1qhK7bSoiT6#?ONVAx4hvg_n%>hpJCa@ZcMBXk#QfsieA^z(IFFh@t6z; zrBxG@bzQB3^_JlmB9}Q*Pw&k@iB(~5riSZ}*QZx#4OmiNj&AaD4UwS-f3P3EMjF(b z9B?EGp>1o8cUfr?oJ%0N80`a6z(ez;By4V>2eJN)yjK>EEPC;xp);wRPi=%(&c=Ew z;DM~i$SgJVLFekk7K83P{`06Cq54j=uhPvZ-r|?Xgk;xL)Ycx^&EJ+Uv`Uh4d0aw1 z^~3G=ks~w;J{MHDw4#~THR+5D3m{1{72lTzLr)B7B`&{&Reibtt)|#t-F<| zulWm&`pcZLE@?XY`Z!TkE#|(}NUBhRxW(jv*7wne(;!1to}-sCBWrW_ZoKS+U%&6R zEKRh_01`oky-rjKskR7@efo4ah1fu(lrAs(5d83NXRba>2MA?RL*bOL%u8|qcd9!n zgih-Zd(M0?6YGFx%2Xk&*l?9MVW7^T^NcdJLrQmR*h?X$8nmZ|)ud&1o#tN#iMbxS2IXcxwVAg z{eSM~mm_E9k}Y`H<_oLir(}7w^S#WTgjL(dSn%K~N~`Ra8pGi?%bG8rUQDW@$eUdZ zQMK4eQ;_>3(4uX$VQ!PkyP>JTJvmjVE-(;47c8;gxDgs!4;F%*CKUUsP7^=d>%?$c z^ON-ktNl|XEGrGVRkv&PWxx#%&==~fd=*plm}_BO9+@WN8h^Lge8R{nb56zUDz}2~ zj4{OL8GqVg;pdMviMxXWTG?Frz)5}nidx~;pZ4+hrwdw;^J;x z6}aUlA8Z~iU4oPYxK^&(#6@4XL*rLAsojNnc|R$eHGY&KL8PjdmX`A}cS3YD=1-4} z6&#C|(CyaFPB))Aqg=f^?(QWR4911eqS`0lL{*ed^WA2d0H=s+ixYLt<-#My2fLE& zm|F5qTbt`Esc1Z_L5Ob8RQMr5selNx!_p(znetHBzd7ma?O+iN`>u zTVLJOL#_5Vt;;LV&keOfT%~x(DvNawdXacZ;07Qgc%S+uQ;Hs9U3-qZUE-v`RNOJ6k5;Yi?d%-q-k*NZ8HDoLh;8C><@M znTkS5F|nc$H?SR8i=@L@(t;`~)`vJHe1c{{xPB!-J{8s4(eVH$AtHk}#KAz6Gl#P@ z2Ml(>Vh(+>eP(esyX5uj!xIw|yxkG0YLc9!z(qMH}I$1Py$f^I^6Bs zhjVNmjlOVb3I(};f37YeIXM#uO`Ro$j@_y5*wd#^m#dQN4#aL;6c;aUef*NYZW*KF zj+IHNI%9}k&nj_D4agZJCWEl8r#v@q%b*M5|N5#$BQg5e{%q!^I3azsoio_heYBii zC+^%0k6a`a+iJR#1ljb8REab-*GEaZEp_uh7JFO6YP6m|rN&`!)(L_uo_t;{SlBu2 zd1s=$tJ7JJSQ9OdQ2t0yO{`J&t`sg+!EHM0^?zv(>kX@^;v%w!Gl^#-X9Ruc&hj*f z@l+cie-=LU&-<=ma!XgnN^8OV^L?$lBN~8NK-={w8=s0LkD^~6pyKjSMj%@8DW{le zI$Rx)4g4CiJlzYY)ZO;EZnA7Zzs$!UFph?h!v~VEH>WzgyHPk2tfkXPZNM2Bmsrr7 zE?_#%kva=~Rfdn7l?-Q7a&=5)3CLwvQ^Hde{as)fN77}xn}u(h^h1}9q3``*j#HX# z=G2E@D8ny<>$JENqpAc#v#_s#nD_y$nZF87rL*OI9bHNbp`Z^|$#0hKiS z*=Y42bE_LSZnzTyHw8pR3u($mQqo^j{73R3WRW1Cu8c52tn5 zJMwsYe_7T;c=^ze$x_v7K9M7OK=qxh>#6uNx$Tv|=OQI~4U4Q4Y(}>;BCiU5y?_x6 z37jt{MYar;e9=3r6Y)+qMCUVBw8N2&RX*v=AO8Qqtbb5Z{-~M~izJ+mp&EabNjaRS zs`8kGBwmaI93FR0Pqphxw^>oQ7}YhhS<-FnLpt3{&9%2ptxnQDSskxTBJl%+hp3fRE5xuvDBtjzepfdebn zM*fe4y4@Bh=s6PI^YiiSL?i#8nZ3nlEUeYlZDsu5by4X!{AiH*hC(+bI+!mh_j0N_ z4U#aop)xHvm?$|9^(HrYZuSsRSEr0j2z_`IO4J;n&%!`29LS#HOPYik>H{Yk4lUS!n}xC8Wm6#9DcOxAk-M_C|veqg^f>9eSO4 zz<;wyw3avKjO{VJ1u<5g-WPl{bfIfq+ZDO4`1ZW#t*2Uqg}3}Eh0<2{5PxGN2L~L?cuK_sUqvcIQXnlBeAiuf|7ZU z*aODp39&ooh;nmQg`4Z8x982~n}yPXF~vGMwze65v%hQujlStYxPyqB z?oOz7{{HV#^U{BA)Ew6MJn`>J>I^|3BTi@cW-cJl9G!*4srgHwshX*e(%1LrcpN%DAUMi-~R@>=Z3-KMe(V4 zJ76_NCBXR|m5jVq5%#g#!+?rfzsa#ms{IFRVcX>$lyxP{d-dhirHinDpr!kO=9~KD z$wYgC+?h#DEv)V-pjJ)1;A3czx%_Lp6=HZXJ;RvBn~D3)=`XqBE8uPoC6_eA3OK7Y)WdXwPfQMxw(uM3m-p7 z-s0O@2zSRmxm2Vcv=hyP{()&T*1lYMT-woD`}l%;mUEt$(+=iYdfp}7>lM(#e42Zi zBgd6@;&nDK4`fjdO5rtB!8|evCcs>-hf-3kXEl6u zax|YsT%Cy@U){WT4Conz*5B8SPc_<{SJ~(ftuc@FXTp(!X~MLm$1K7T-?rPhdEyQk({Ko+TfVLj#W}WklNzK zOfama?*BZ3CefyU{TBC_+p~Iju#e5<`DdUVYIK9bbkD>jCC!|?N6jw$Yv?ZFvG(d5 zq5OX9U*NFT?FUT?3tYE}s`;5DUDl^VFAj0uO6Vz3N0y&dwL7A%@b}W~OYrKCX`I36 zMLM(x1~8O#zZ+swch%=*}LVN&6Vw*~6{N zdNp3cYDSh|yuVTE_n(JXYuRzXD1HzN zq*2~l8`E`UGX}u96ACfC2aF! z&hl270$Rvlp{8V;HYdhYwZ57DLRZO4kNl)HZ{0EmKxfik^=R=Uei;DknG~Em+7%#y zd(&d=+MidEVON)ymS)PYr%5{-X11$({&|jH{$$%!JMt#%_{ozS+@WhQ(+KltMW(C) z_yYnB2Px;7x~ub54JRcmO;I}GT2KDsw@n@jchqBA`E(@RI-c$T@e=>>56$5FYCZdwAbMWysugbqSLMvpR z>s!H#K8v&*ledr%?|P@Vp)wn!si1VfgkMcW{4xZalMMq>fB$Kfiv0|Su5PJKlr2nX zB$%p;CUtal2-ZBetoCVjQvjgJ*jRC0tQZHg48}DyC_0K+*Zy)tD$`(`W0+wm%)zMA zrAwWC7RG8gE%Y`veqj50U()Iyz#3;Ljn5km<{ zzGlFs=vRbae!?>R1be*Ob~n&w+QO{YMI%Oom@l<+n%~QH_^={=yLX#8x8VmKDs>J% zx|LKv638aT!cla^O0CEAi-T@Wv8aGR_Q)j(7{%>Uw+_(9;*@&yWLFA){4;fFX~<16 zX-EYLR49&_Gv&gFMy}Z{L!frRJL2>J)O%iM{ZUqSK|4sCgW?E?|BPyAEo?@aQ}6kS z@$o(`7hNyDdeE@mhqY%p_rlu=8+^Lrul+vuCLfAzpz{cUSo>E`MCHBWb10AO?rt>% z=Gt(w#jtyiv%#P8DZMyt$F^*&y}nr=qFj8`0@PQR72q9D9e!Ce}tk&O(#r{6hxEYV+ZwfXw2dQ-8som7#@(l>rNPY_|%%h)715XS!FmnfP{_n3x=upDDGTYRiCrAGjrg zKzuurHo1Pb%iUM!-22^UkHndnsc&#gT(;7B_+IYT#^@!LTeJa~6g7QPJ76NtWT>qD z2V}Mr53d@VnhKN5SEH)Qo9o@kIa(5=SOtR-KNwa~Ws>0YW6GqG(l>d79XXT|d?e z3tM56hj$n6*aG6A9i(pUbpY+}=8uQ_q?<{NI3Y)VRs)%+^v2f!l|pepS5m&Yu4 zru`IBY)cz@D zST6`wL%hw&%M&g(E&aAE;o|)t$ngp4km4pB0Uiy?VXi>H%nTGK1JylJkiqZIL@p+0 z_Z&~SnrVl!v5^4!);*0UbplA>?_Yq=S*C*SvlyNisv-2W_{ zJztJ8m2hFXE+q0pA*xAk=VYO3m$Z{nQUU_al#jl)wzd>Pb}D)G@F(eP_lN4yUS3{9 z!4^Z$0Gl4uSGuieB{lvIOY*6CEDhA~Ude~&K-B}Woa22PQjo?MpOnI}1$ef687Ojy zC$u*wq}303+T3s_PcN7lfq}$3S7k@>;B!kLMG_Yby%?HKJKL7p2v3p>4@JoMPkUtaE``&VW?TC*3_Du~q1!rIo zn7jhB@CZb+xOti8g`2N?fJ~U_@3)@XkNqy$r0U!SeqGr$4mnfrJbX>*~4Kk1V^>7zRVt|sp z-}pi?bghZcDEvs0;B%6LDJlBpOsGixbf0ZvZ180hXMTRZg7@TWFn?Dh8gl+399#Ce z#KgqF&BYeo`6NFXUs((8e`~JQ#W#hvg1q#7S`9-nc)k(NBO<4y8&%> z=PJHc4$oq`;u%)WU^cT3AZOhY2L}hOeRUGA*hesb6l@?8m@k<7(m-7Gc7=>qR7&cL zp8|Mc)$R3e*IXL6}I-kN#wPEOPNyK87% zp8>~0CG#enh+Z%_W_mDV-V+LdCl4+!PXoLH`mX?YH2X5`Usq(c^|*w`^TgQL;{Z!q zbEzqg2{k$Kj8>tvKJpLDd#Jz_Lw>HWvYw@HrK;B4mv7`d*>M^bbt5pa8fea;kHm&q zzZ$5ugec5Cm+n2DptCXC7l5^AF4%tc(bWS_(|%pZ61u6S`iSTQ^r46H

Fp;>+HX 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�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 X(<*Umcp0=0eDIm4tDnm{r-UW|lP$I< literal 0 HcmV?d00001 diff --git a/docs/tutorials/flask.rst b/docs/tutorials/flask.rst index 7a233454..af3a222e 100644 --- a/docs/tutorials/flask.rst +++ b/docs/tutorials/flask.rst @@ -3,7 +3,15 @@ Flask tutorial ============== -This tutorials shows how to build ``Flask`` application following the dependency injection +.. meta:: + :keywords: Python,Flask,Tutorial,Education,Web,Example,DI,Dependency injection,IoC, + Inversion of control,Refactoring,Tests,Unit tests,Pytest,py.test,Bootstrap, + HTML,CSS + :description: This tutorial shows how to build a Flask application following the dependency + injection principle. You will create the web application, connect to the Github + API, cover it with unit the test and make some refactoring. + +This tutorial shows how to build a ``Flask`` application following the dependency injection principle. Start from the scratch or jump to the section: @@ -1085,8 +1093,8 @@ Conclusion We are done. -In this tutorial we've build ``Flask`` application following the dependency injection principle. -We've used ``Dependency Injector`` as a dependency injection framework. +In this tutorial we've built a ``Flask`` application following the dependency injection principle. +We've used the ``Dependency Injector`` as a dependency injection framework. The main part of this application is the container. It keeps all the application components and their dependencies in one place: diff --git a/docs/tutorials/index.rst b/docs/tutorials/index.rst index 51c6f09a..bfe6a2c2 100644 --- a/docs/tutorials/index.rst +++ b/docs/tutorials/index.rst @@ -11,6 +11,6 @@ frameworks. flask aiohttp - asyncio + asyncio-daemon .. disqus:: diff --git a/examples/miniapps/monitoring-daemon-asyncio/README.rst b/examples/miniapps/monitoring-daemon-asyncio/README.rst index cfda8b9a..c9432dab 100644 --- a/examples/miniapps/monitoring-daemon-asyncio/README.rst +++ b/examples/miniapps/monitoring-daemon-asyncio/README.rst @@ -25,11 +25,31 @@ The output should be something like: Starting monitoring-daemon-asyncio_monitor_1 ... done Attaching to monitoring-daemon-asyncio_monitor_1 - monitor_1 | [2020-08-06 01:57:08,249] [INFO] [monitoringdaemon.dispatcher]: Dispatcher is starting up - monitor_1 | [2020-08-06 01:57:08,249] [INFO] [monitoringdaemon.dispatcher]: Monitoring task has been started monitoringdaemon.monitors.HttpMonitor(url="http://example.com") - monitor_1 | [2020-08-06 01:57:08,249] [INFO] [monitoringdaemon.dispatcher]: Monitoring task has been started monitoringdaemon.monitors.HttpMonitor(url="http://httpbin.org/get") - monitor_1 | [2020-08-06 01:57:08,318] [INFO] [monitoringdaemon.monitors.HttpMonitor(url="http://example.com")]: Response code: 200, content length: 648, request took: 0.067 seconds - monitor_1 | [2020-08-06 01:57:08,363] [INFO] [monitoringdaemon.monitors.HttpMonitor(url="http://httpbin.org/get")]: Response code: 200, content length: 309, request took: 0.112 seconds + monitor_1 | [2020-08-08 17:04:36,655] [INFO] [Dispatcher]: Starting up + monitor_1 | [2020-08-08 17:04:36,732] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.074 seconds + monitor_1 | + monitor_1 | [2020-08-08 17:04:36,811] [INFO] [HttpMonitor]: Check + monitor_1 | GET https://httpbin.org/get + monitor_1 | response code: 200 + monitor_1 | content length: 310 + monitor_1 | request took: 0.153 seconds + monitor_1 | + monitor_1 | [2020-08-08 17:04:41,731] [INFO] [HttpMonitor]: Check + monitor_1 | GET http://example.com + monitor_1 | response code: 200 + monitor_1 | content length: 648 + monitor_1 | request took: 0.067 seconds + monitor_1 | + monitor_1 | [2020-08-08 17:04:41,787] [INFO] [HttpMonitor]: Check + monitor_1 | GET https://httpbin.org/get + monitor_1 | response code: 200 + monitor_1 | content length: 310 + monitor_1 | request took: 0.122 seconds + monitor_1 | Test ---- @@ -59,9 +79,9 @@ The output should be something like: monitoringdaemon/__init__.py 0 0 100% monitoringdaemon/__main__.py 9 9 0% monitoringdaemon/containers.py 11 0 100% - monitoringdaemon/dispatcher.py 45 5 89% + monitoringdaemon/dispatcher.py 43 5 88% monitoringdaemon/http.py 6 3 50% - monitoringdaemon/monitors.py 29 2 93% + monitoringdaemon/monitors.py 23 1 96% monitoringdaemon/tests.py 37 0 100% ---------------------------------------------------- - TOTAL 137 19 86% + TOTAL 129 18 86% diff --git a/examples/miniapps/monitoring-daemon-asyncio/config.yml b/examples/miniapps/monitoring-daemon-asyncio/config.yml index 5bbe8795..f9bfc8ac 100644 --- a/examples/miniapps/monitoring-daemon-asyncio/config.yml +++ b/examples/miniapps/monitoring-daemon-asyncio/config.yml @@ -12,6 +12,6 @@ monitors: httpbin: method: "GET" - url: "http://httpbin.org/get" + url: "https://httpbin.org/get" timeout: 5 check_every: 5 diff --git a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/dispatcher.py b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/dispatcher.py index d12c22b9..a71f850c 100644 --- a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/dispatcher.py +++ b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/dispatcher.py @@ -9,30 +9,24 @@ from typing import List from .monitors import Monitor -logger = logging.getLogger(__name__) - - class Dispatcher: def __init__(self, monitors: List[Monitor]) -> None: self._monitors = monitors self._monitor_tasks: List[asyncio.Task] = [] + self._logger = logging.getLogger(self.__class__.__name__) self._stopping = False def run(self) -> None: asyncio.run(self.start()) async def start(self) -> None: - logger.info('Dispatcher is starting up') + self._logger.info('Starting up') for monitor in self._monitors: self._monitor_tasks.append( asyncio.create_task(self._run_monitor(monitor)), ) - logger.info( - 'Monitoring task has been started %s', - monitor.full_name, - ) asyncio.get_event_loop().add_signal_handler(signal.SIGTERM, self.stop) asyncio.get_event_loop().add_signal_handler(signal.SIGINT, self.stop) @@ -47,11 +41,10 @@ class Dispatcher: self._stopping = True - logger.info('Dispatcher is shutting down') + self._logger.info('Shutting down') for task, monitor in zip(self._monitor_tasks, self._monitors): task.cancel() - logger.info('Monitoring task has been stopped %s', monitor.full_name) - logger.info('Dispatcher shutting down finished successfully') + self._logger.info('Shutdown finished successfully') @staticmethod async def _run_monitor(monitor: Monitor) -> None: @@ -67,6 +60,6 @@ class Dispatcher: except asyncio.CancelledError: break except Exception: - monitor.logger.exception('Error running monitoring check') + monitor.logger.exception('Error executing monitor check') await asyncio.sleep(_until_next(last=time_start)) diff --git a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/monitors.py b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/monitors.py index 3ffe71a7..ebcc8d0a 100644 --- a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/monitors.py +++ b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/monitors.py @@ -11,11 +11,7 @@ class Monitor: def __init__(self, check_every: int) -> None: self.check_every = check_every - self.logger = logging.getLogger(self.full_name) - - @property - def full_name(self) -> str: - raise NotImplementedError() + self.logger = logging.getLogger(self.__class__.__name__) async def check(self) -> None: raise NotImplementedError() @@ -34,10 +30,6 @@ class HttpMonitor(Monitor): self._timeout = options.pop('timeout') super().__init__(check_every=options.pop('check_every')) - @property - def full_name(self) -> str: - return '{0}.{1}(url="{2}")'.format(__name__, self.__class__.__name__, self._url) - async def check(self) -> None: time_start = time.time() @@ -51,7 +43,13 @@ class HttpMonitor(Monitor): time_took = time_end - time_start self.logger.info( - 'Response code: %s, content length: %s, request took: %s seconds', + 'Check\n' + ' %s %s\n' + ' response code: %s\n' + ' content length: %s\n' + ' request took: %s seconds\n', + self._method, + self._url, response.status, response.content_length, round(time_took, 3) diff --git a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/tests.py b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/tests.py index 3fb712c6..df16e6fa 100644 --- a/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/tests.py +++ b/examples/miniapps/monitoring-daemon-asyncio/monitoringdaemon/tests.py @@ -32,7 +32,7 @@ def container(): }, 'httpbin': { 'method': 'GET', - 'url': 'http://fake-httpbin.org/get', + 'url': 'https://fake-httpbin.org/get', 'timeout': 1, 'check_every': 1, }, @@ -56,7 +56,7 @@ async def test_example_monitor(container, caplog): await example_monitor.check() assert 'http://fake-example.com' in caplog.text - assert 'Response code: 200' in caplog.text + assert 'response code: 200' in caplog.text assert 'content length: 635' in caplog.text diff --git a/src/dependency_injector/providers.c b/src/dependency_injector/providers.c index 031d148b..f711fadb 100644 --- a/src/dependency_injector/providers.c +++ b/src/dependency_injector/providers.c @@ -1385,7 +1385,7 @@ struct __pyx_obj_19dependency_injector_9providers___pyx_scope_struct_1_genexpr { }; -/* "dependency_injector/providers.pyx":2523 +/* "dependency_injector/providers.pyx":2524 * return self.__providers[name] * * def __str__(self): # <<<<<<<<<<<<<< @@ -1398,7 +1398,7 @@ struct __pyx_obj_19dependency_injector_9providers___pyx_scope_struct_2___str__ { }; -/* "dependency_injector/providers.pyx":2533 +/* "dependency_injector/providers.pyx":2534 * selector=self.__selector, * providers=', '.join(( * '{0}={1}'.format(name, provider) # <<<<<<<<<<<<<< @@ -1643,7 +1643,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_Configuration { static struct __pyx_vtabstruct_19dependency_injector_9providers_Configuration *__pyx_vtabptr_19dependency_injector_9providers_Configuration; -/* "dependency_injector/providers.pyx":1493 +/* "dependency_injector/providers.pyx":1494 * * * cdef class Factory(Provider): # <<<<<<<<<<<<<< @@ -1657,7 +1657,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_Factory { static struct __pyx_vtabstruct_19dependency_injector_9providers_Factory *__pyx_vtabptr_19dependency_injector_9providers_Factory; -/* "dependency_injector/providers.pyx":1710 +/* "dependency_injector/providers.pyx":1711 * * * cdef class DelegatedFactory(Factory): # <<<<<<<<<<<<<< @@ -1671,7 +1671,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedFactory { static struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedFactory *__pyx_vtabptr_19dependency_injector_9providers_DelegatedFactory; -/* "dependency_injector/providers.pyx":1732 +/* "dependency_injector/providers.pyx":1733 * * * cdef class AbstractFactory(Factory): # <<<<<<<<<<<<<< @@ -1685,7 +1685,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_AbstractFactory { static struct __pyx_vtabstruct_19dependency_injector_9providers_AbstractFactory *__pyx_vtabptr_19dependency_injector_9providers_AbstractFactory; -/* "dependency_injector/providers.pyx":1773 +/* "dependency_injector/providers.pyx":1774 * * * cdef class FactoryDelegate(Delegate): # <<<<<<<<<<<<<< @@ -1699,7 +1699,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryDelegate { static struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryDelegate *__pyx_vtabptr_19dependency_injector_9providers_FactoryDelegate; -/* "dependency_injector/providers.pyx":1795 +/* "dependency_injector/providers.pyx":1796 * * * cdef class FactoryAggregate(Provider): # <<<<<<<<<<<<<< @@ -1714,7 +1714,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate { static struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *__pyx_vtabptr_19dependency_injector_9providers_FactoryAggregate; -/* "dependency_injector/providers.pyx":1882 +/* "dependency_injector/providers.pyx":1883 * * * cdef class BaseSingleton(Provider): # <<<<<<<<<<<<<< @@ -1728,7 +1728,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_BaseSingleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_BaseSingleton *__pyx_vtabptr_19dependency_injector_9providers_BaseSingleton; -/* "dependency_injector/providers.pyx":2035 +/* "dependency_injector/providers.pyx":2036 * * * cdef class Singleton(BaseSingleton): # <<<<<<<<<<<<<< @@ -1742,7 +1742,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_Singleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_Singleton *__pyx_vtabptr_19dependency_injector_9providers_Singleton; -/* "dependency_injector/providers.pyx":2091 +/* "dependency_injector/providers.pyx":2092 * * * cdef class DelegatedSingleton(Singleton): # <<<<<<<<<<<<<< @@ -1756,7 +1756,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedSingleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedSingleton *__pyx_vtabptr_19dependency_injector_9providers_DelegatedSingleton; -/* "dependency_injector/providers.pyx":2113 +/* "dependency_injector/providers.pyx":2114 * * * cdef class ThreadSafeSingleton(BaseSingleton): # <<<<<<<<<<<<<< @@ -1770,7 +1770,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_ThreadSafeSingleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_ThreadSafeSingleton *__pyx_vtabptr_19dependency_injector_9providers_ThreadSafeSingleton; -/* "dependency_injector/providers.pyx":2148 +/* "dependency_injector/providers.pyx":2149 * * * cdef class DelegatedThreadSafeSingleton(ThreadSafeSingleton): # <<<<<<<<<<<<<< @@ -1784,7 +1784,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedThreadSafeSing static struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedThreadSafeSingleton *__pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadSafeSingleton; -/* "dependency_injector/providers.pyx":2170 +/* "dependency_injector/providers.pyx":2171 * * * cdef class ThreadLocalSingleton(BaseSingleton): # <<<<<<<<<<<<<< @@ -1798,7 +1798,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_ThreadLocalSingleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_ThreadLocalSingleton *__pyx_vtabptr_19dependency_injector_9providers_ThreadLocalSingleton; -/* "dependency_injector/providers.pyx":2218 +/* "dependency_injector/providers.pyx":2219 * * * cdef class DelegatedThreadLocalSingleton(ThreadLocalSingleton): # <<<<<<<<<<<<<< @@ -1812,7 +1812,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedThreadLocalSin static struct __pyx_vtabstruct_19dependency_injector_9providers_DelegatedThreadLocalSingleton *__pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadLocalSingleton; -/* "dependency_injector/providers.pyx":2240 +/* "dependency_injector/providers.pyx":2241 * * * cdef class AbstractSingleton(BaseSingleton): # <<<<<<<<<<<<<< @@ -1826,7 +1826,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_AbstractSingleton { static struct __pyx_vtabstruct_19dependency_injector_9providers_AbstractSingleton *__pyx_vtabptr_19dependency_injector_9providers_AbstractSingleton; -/* "dependency_injector/providers.pyx":2285 +/* "dependency_injector/providers.pyx":2286 * * * cdef class SingletonDelegate(Delegate): # <<<<<<<<<<<<<< @@ -1840,7 +1840,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_SingletonDelegate { static struct __pyx_vtabstruct_19dependency_injector_9providers_SingletonDelegate *__pyx_vtabptr_19dependency_injector_9providers_SingletonDelegate; -/* "dependency_injector/providers.pyx":2307 +/* "dependency_injector/providers.pyx":2308 * * * cdef class List(Provider): # <<<<<<<<<<<<<< @@ -1854,7 +1854,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_List { static struct __pyx_vtabstruct_19dependency_injector_9providers_List *__pyx_vtabptr_19dependency_injector_9providers_List; -/* "dependency_injector/providers.pyx":2409 +/* "dependency_injector/providers.pyx":2410 * * * cdef class Container(Provider): # <<<<<<<<<<<<<< @@ -1868,7 +1868,7 @@ struct __pyx_vtabstruct_19dependency_injector_9providers_Container { static struct __pyx_vtabstruct_19dependency_injector_9providers_Container *__pyx_vtabptr_19dependency_injector_9providers_Container; -/* "dependency_injector/providers.pyx":2460 +/* "dependency_injector/providers.pyx":2461 * * * cdef class Selector(Provider): # <<<<<<<<<<<<<< @@ -25081,7 +25081,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19ConfigurationOption return __pyx_r; } -/* "dependency_injector/providers.pyx":1259 +/* "dependency_injector/providers.pyx":1260 * DEFAULT_NAME = 'config' * * def __init__(self, name=DEFAULT_NAME, default=None): # <<<<<<<<<<<<<< @@ -25131,7 +25131,7 @@ static int __pyx_pw_19dependency_injector_9providers_13Configuration_1__init__(P } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 1259, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 1260, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -25148,7 +25148,7 @@ static int __pyx_pw_19dependency_injector_9providers_13Configuration_1__init__(P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1259, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1260, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Configuration.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -25175,14 +25175,14 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":1260 + /* "dependency_injector/providers.pyx":1261 * * def __init__(self, name=DEFAULT_NAME, default=None): * self.__name = name # <<<<<<<<<<<<<< * * value = {} */ - if (!(likely(PyString_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(1, 1260, __pyx_L1_error) + if (!(likely(PyString_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_name)->tp_name), 0))) __PYX_ERR(1, 1261, __pyx_L1_error) __pyx_t_1 = __pyx_v_name; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); @@ -25191,19 +25191,19 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st __pyx_v_self->__pyx___name = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1262 + /* "dependency_injector/providers.pyx":1263 * self.__name = name * * value = {} # <<<<<<<<<<<<<< * if default is not None: * assert isinstance(default, dict), default */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1262, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1263 + /* "dependency_injector/providers.pyx":1264 * * value = {} * if default is not None: # <<<<<<<<<<<<<< @@ -25214,7 +25214,7 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "dependency_injector/providers.pyx":1264 + /* "dependency_injector/providers.pyx":1265 * value = {} * if default is not None: * assert isinstance(default, dict), default # <<<<<<<<<<<<<< @@ -25225,23 +25225,23 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st if (unlikely(!Py_OptimizeFlag)) { __pyx_t_3 = PyDict_Check(__pyx_v_default); if (unlikely(!(__pyx_t_3 != 0))) { - __pyx_t_1 = PyTuple_Pack(1, __pyx_v_default); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1264, __pyx_L1_error) + __pyx_t_1 = PyTuple_Pack(1, __pyx_v_default); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1265, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); PyErr_SetObject(PyExc_AssertionError, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1264, __pyx_L1_error) + __PYX_ERR(1, 1265, __pyx_L1_error) } } #endif - /* "dependency_injector/providers.pyx":1265 + /* "dependency_injector/providers.pyx":1266 * if default is not None: * assert isinstance(default, dict), default * value = default.copy() # <<<<<<<<<<<<<< * * self.__children = {} */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_default, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1265, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_default, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -25255,13 +25255,13 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1265, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1266, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1263 + /* "dependency_injector/providers.pyx":1264 * * value = {} * if default is not None: # <<<<<<<<<<<<<< @@ -25270,14 +25270,14 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st */ } - /* "dependency_injector/providers.pyx":1267 + /* "dependency_injector/providers.pyx":1268 * value = default.copy() * * self.__children = {} # <<<<<<<<<<<<<< * * super().__init__(value) */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1267, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1268, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___children); @@ -25285,14 +25285,14 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st __pyx_v_self->__pyx___children = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1269 + /* "dependency_injector/providers.pyx":1270 * self.__children = {} * * super().__init__(value) # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1269, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); @@ -25300,10 +25300,10 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1269, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1269, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -25318,12 +25318,12 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1269, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1259 + /* "dependency_injector/providers.pyx":1260 * DEFAULT_NAME = 'config' * * def __init__(self, name=DEFAULT_NAME, default=None): # <<<<<<<<<<<<<< @@ -25346,7 +25346,7 @@ static int __pyx_pf_19dependency_injector_9providers_13Configuration___init__(st return __pyx_r; } -/* "dependency_injector/providers.pyx":1271 +/* "dependency_injector/providers.pyx":1272 * super().__init__(value) * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -25384,16 +25384,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":1274 + /* "dependency_injector/providers.pyx":1275 * cdef Configuration copied * * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1274, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1274, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -25408,14 +25408,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1274, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_Configuration))))) __PYX_ERR(1, 1274, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_Configuration))))) __PYX_ERR(1, 1275, __pyx_L1_error) __pyx_v_copied = ((struct __pyx_obj_19dependency_injector_9providers_Configuration *)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1275 + /* "dependency_injector/providers.pyx":1276 * * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -25426,7 +25426,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":1276 + /* "dependency_injector/providers.pyx":1277 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -25438,7 +25438,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de __pyx_r = ((PyObject *)__pyx_v_copied); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1275 + /* "dependency_injector/providers.pyx":1276 * * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -25447,14 +25447,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de */ } - /* "dependency_injector/providers.pyx":1278 + /* "dependency_injector/providers.pyx":1279 * return copied * * copied = self.__class__(self.__name, self.__provides) # <<<<<<<<<<<<<< * memo[id(self)] = copied * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1278, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_7 = 0; @@ -25471,7 +25471,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_self->__pyx___name, __pyx_v_self->__pyx_base.__pyx___provides}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1278, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -25479,13 +25479,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_v_self->__pyx___name, __pyx_v_self->__pyx_base.__pyx___provides}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1278, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1278, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -25496,28 +25496,28 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de __Pyx_INCREF(__pyx_v_self->__pyx_base.__pyx___provides); __Pyx_GIVEREF(__pyx_v_self->__pyx_base.__pyx___provides); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_v_self->__pyx_base.__pyx___provides); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1278, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_Configuration))))) __PYX_ERR(1, 1278, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_Configuration))))) __PYX_ERR(1, 1279, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_copied, ((struct __pyx_obj_19dependency_injector_9providers_Configuration *)__pyx_t_1)); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1279 + /* "dependency_injector/providers.pyx":1280 * * copied = self.__class__(self.__name, self.__provides) * memo[id(self)] = copied # <<<<<<<<<<<<<< * * copied.__children = deepcopy(self.__children, memo) */ - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1279, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1280, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, ((PyObject *)__pyx_v_copied)) < 0)) __PYX_ERR(1, 1279, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, ((PyObject *)__pyx_v_copied)) < 0)) __PYX_ERR(1, 1280, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1281 + /* "dependency_injector/providers.pyx":1282 * memo[id(self)] = copied * * copied.__children = deepcopy(self.__children, memo) # <<<<<<<<<<<<<< @@ -25526,30 +25526,30 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de */ __pyx_t_1 = __pyx_v_self->__pyx___children; __Pyx_INCREF(__pyx_t_1); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1281, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1282, __pyx_L1_error) __pyx_t_8.__pyx_n = 1; __pyx_t_8.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_1, 0, &__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1281, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_1, 0, &__pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(1, 1281, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(1, 1282, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_copied->__pyx___children); __Pyx_DECREF(__pyx_v_copied->__pyx___children); __pyx_v_copied->__pyx___children = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1282 + /* "dependency_injector/providers.pyx":1283 * * copied.__children = deepcopy(self.__children, memo) * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1282, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1283, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_Configuration *)__pyx_v_self->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":1284 + /* "dependency_injector/providers.pyx":1285 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -25561,7 +25561,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de __pyx_r = ((PyObject *)__pyx_v_copied); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1271 + /* "dependency_injector/providers.pyx":1272 * super().__init__(value) * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -25584,7 +25584,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_2__de return __pyx_r; } -/* "dependency_injector/providers.pyx":1286 +/* "dependency_injector/providers.pyx":1287 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -25615,7 +25615,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_4__st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "dependency_injector/providers.pyx":1287 + /* "dependency_injector/providers.pyx":1288 * * def __str__(self): * return represent_provider(provider=self, provides=self.__name) # <<<<<<<<<<<<<< @@ -25625,14 +25625,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_4__st __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_v_self->__pyx___name; __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1287, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1288, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1286 + /* "dependency_injector/providers.pyx":1287 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -25652,7 +25652,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_4__st return __pyx_r; } -/* "dependency_injector/providers.pyx":1289 +/* "dependency_injector/providers.pyx":1290 * return represent_provider(provider=self, provides=self.__name) * * def __getattr__(self, item): # <<<<<<<<<<<<<< @@ -25688,14 +25688,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); - /* "dependency_injector/providers.pyx":1290 + /* "dependency_injector/providers.pyx":1291 * * def __getattr__(self, item): * if item.startswith('__') and item.endswith('__'): # <<<<<<<<<<<<<< * raise AttributeError( * '\'{cls}\' object has no attribute ' */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_item, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1290, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_item, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -25709,17 +25709,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1290, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1290, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_item, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1290, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_item, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -25733,70 +25733,70 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1290, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1290, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1291, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":1293 + /* "dependency_injector/providers.pyx":1294 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=item)) * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1293, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1293, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1293, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1293, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 1293, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":1294 + /* "dependency_injector/providers.pyx":1295 * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=item)) # <<<<<<<<<<<<<< * * child = self.__children.get(item) */ - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_item) < 0) __PYX_ERR(1, 1293, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_item) < 0) __PYX_ERR(1, 1294, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1293 + /* "dependency_injector/providers.pyx":1294 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=item)) * */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1293, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1294, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1291 + /* "dependency_injector/providers.pyx":1292 * def __getattr__(self, item): * if item.startswith('__') and item.endswith('__'): * raise AttributeError( # <<<<<<<<<<<<<< * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1291, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 1291, __pyx_L1_error) + __PYX_ERR(1, 1292, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1290 + /* "dependency_injector/providers.pyx":1291 * * def __getattr__(self, item): * if item.startswith('__') and item.endswith('__'): # <<<<<<<<<<<<<< @@ -25805,7 +25805,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge */ } - /* "dependency_injector/providers.pyx":1296 + /* "dependency_injector/providers.pyx":1297 * attribute_name=item)) * * child = self.__children.get(item) # <<<<<<<<<<<<<< @@ -25814,14 +25814,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge */ if (unlikely(__pyx_v_self->__pyx___children == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get"); - __PYX_ERR(1, 1296, __pyx_L1_error) + __PYX_ERR(1, 1297, __pyx_L1_error) } - __pyx_t_3 = __Pyx_PyDict_GetItemDefault(__pyx_v_self->__pyx___children, __pyx_v_item, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1296, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_GetItemDefault(__pyx_v_self->__pyx___children, __pyx_v_item, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1297, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_child = __pyx_t_3; __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1297 + /* "dependency_injector/providers.pyx":1298 * * child = self.__children.get(item) * if child is None: # <<<<<<<<<<<<<< @@ -25832,19 +25832,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge __pyx_t_5 = (__pyx_t_1 != 0); if (__pyx_t_5) { - /* "dependency_injector/providers.pyx":1298 + /* "dependency_injector/providers.pyx":1299 * child = self.__children.get(item) * if child is None: * child = ConfigurationOption((item,), self) # <<<<<<<<<<<<<< * self.__children[item] = child * return child */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1298, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_item); __Pyx_GIVEREF(__pyx_v_item); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_item); - __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1298, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); @@ -25852,13 +25852,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_6, 1, ((PyObject *)__pyx_v_self)); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ConfigurationOption), __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1298, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ConfigurationOption), __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1299, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_child, __pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1299 + /* "dependency_injector/providers.pyx":1300 * if child is None: * child = ConfigurationOption((item,), self) * self.__children[item] = child # <<<<<<<<<<<<<< @@ -25867,11 +25867,11 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge */ if (unlikely(__pyx_v_self->__pyx___children == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 1299, __pyx_L1_error) + __PYX_ERR(1, 1300, __pyx_L1_error) } - if (unlikely(PyDict_SetItem(__pyx_v_self->__pyx___children, __pyx_v_item, __pyx_v_child) < 0)) __PYX_ERR(1, 1299, __pyx_L1_error) + if (unlikely(PyDict_SetItem(__pyx_v_self->__pyx___children, __pyx_v_item, __pyx_v_child) < 0)) __PYX_ERR(1, 1300, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1297 + /* "dependency_injector/providers.pyx":1298 * * child = self.__children.get(item) * if child is None: # <<<<<<<<<<<<<< @@ -25880,7 +25880,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge */ } - /* "dependency_injector/providers.pyx":1300 + /* "dependency_injector/providers.pyx":1301 * child = ConfigurationOption((item,), self) * self.__children[item] = child * return child # <<<<<<<<<<<<<< @@ -25892,7 +25892,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge __pyx_r = __pyx_v_child; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1289 + /* "dependency_injector/providers.pyx":1290 * return represent_provider(provider=self, provides=self.__name) * * def __getattr__(self, item): # <<<<<<<<<<<<<< @@ -25915,7 +25915,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_6__ge return __pyx_r; } -/* "dependency_injector/providers.pyx":1302 +/* "dependency_injector/providers.pyx":1303 * return child * * def __getitem__(self, item): # <<<<<<<<<<<<<< @@ -25949,7 +25949,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getitem__", 0); - /* "dependency_injector/providers.pyx":1303 + /* "dependency_injector/providers.pyx":1304 * * def __getitem__(self, item): * child = self.__children.get(item) # <<<<<<<<<<<<<< @@ -25958,14 +25958,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge */ if (unlikely(__pyx_v_self->__pyx___children == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "get"); - __PYX_ERR(1, 1303, __pyx_L1_error) + __PYX_ERR(1, 1304, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_self->__pyx___children, __pyx_v_item, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1303, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_GetItemDefault(__pyx_v_self->__pyx___children, __pyx_v_item, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_child = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1304 + /* "dependency_injector/providers.pyx":1305 * def __getitem__(self, item): * child = self.__children.get(item) * if child is None: # <<<<<<<<<<<<<< @@ -25976,14 +25976,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { - /* "dependency_injector/providers.pyx":1305 + /* "dependency_injector/providers.pyx":1306 * child = self.__children.get(item) * if child is None: * child = ConfigurationOption(item, self) # <<<<<<<<<<<<<< * self.__children[item] = child * return child */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1305, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_item); __Pyx_GIVEREF(__pyx_v_item); @@ -25991,13 +25991,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ConfigurationOption), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1305, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ConfigurationOption), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1306, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF_SET(__pyx_v_child, __pyx_t_4); __pyx_t_4 = 0; - /* "dependency_injector/providers.pyx":1306 + /* "dependency_injector/providers.pyx":1307 * if child is None: * child = ConfigurationOption(item, self) * self.__children[item] = child # <<<<<<<<<<<<<< @@ -26006,11 +26006,11 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge */ if (unlikely(__pyx_v_self->__pyx___children == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 1306, __pyx_L1_error) + __PYX_ERR(1, 1307, __pyx_L1_error) } - if (unlikely(PyDict_SetItem(__pyx_v_self->__pyx___children, __pyx_v_item, __pyx_v_child) < 0)) __PYX_ERR(1, 1306, __pyx_L1_error) + if (unlikely(PyDict_SetItem(__pyx_v_self->__pyx___children, __pyx_v_item, __pyx_v_child) < 0)) __PYX_ERR(1, 1307, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1304 + /* "dependency_injector/providers.pyx":1305 * def __getitem__(self, item): * child = self.__children.get(item) * if child is None: # <<<<<<<<<<<<<< @@ -26019,7 +26019,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge */ } - /* "dependency_injector/providers.pyx":1307 + /* "dependency_injector/providers.pyx":1308 * child = ConfigurationOption(item, self) * self.__children[item] = child * return child # <<<<<<<<<<<<<< @@ -26031,7 +26031,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge __pyx_r = __pyx_v_child; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1302 + /* "dependency_injector/providers.pyx":1303 * return child * * def __getitem__(self, item): # <<<<<<<<<<<<<< @@ -26052,7 +26052,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_8__ge return __pyx_r; } -/* "dependency_injector/providers.pyx":1309 +/* "dependency_injector/providers.pyx":1310 * return child * * def get_name(self): # <<<<<<<<<<<<<< @@ -26078,7 +26078,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_10get __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_name", 0); - /* "dependency_injector/providers.pyx":1310 + /* "dependency_injector/providers.pyx":1311 * * def get_name(self): * return self.__name # <<<<<<<<<<<<<< @@ -26090,7 +26090,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_10get __pyx_r = __pyx_v_self->__pyx___name; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1309 + /* "dependency_injector/providers.pyx":1310 * return child * * def get_name(self): # <<<<<<<<<<<<<< @@ -26105,7 +26105,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_10get return __pyx_r; } -/* "dependency_injector/providers.pyx":1312 +/* "dependency_injector/providers.pyx":1313 * return self.__name * * def get(self, selector): # <<<<<<<<<<<<<< @@ -26144,14 +26144,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); - /* "dependency_injector/providers.pyx":1321 + /* "dependency_injector/providers.pyx":1322 * :rtype: Any * """ * keys = selector.split('.') # <<<<<<<<<<<<<< * value = self.__call__() * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_selector, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1321, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_selector, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26165,20 +26165,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s__4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s__4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1321, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1322, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_keys = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1322 + /* "dependency_injector/providers.pyx":1323 * """ * keys = selector.split('.') * value = self.__call__() # <<<<<<<<<<<<<< * * while len(keys) > 0: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1322, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26192,13 +26192,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1322, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1324 + /* "dependency_injector/providers.pyx":1325 * value = self.__call__() * * while len(keys) > 0: # <<<<<<<<<<<<<< @@ -26206,30 +26206,30 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get * value = value.get(key) */ while (1) { - __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1324, __pyx_L1_error) + __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1325, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 0) != 0); if (!__pyx_t_5) break; - /* "dependency_injector/providers.pyx":1325 + /* "dependency_injector/providers.pyx":1326 * * while len(keys) > 0: * key = keys.pop(0) # <<<<<<<<<<<<<< * value = value.get(key) * if value is None: */ - __pyx_t_1 = __Pyx_PyObject_PopIndex(__pyx_v_keys, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1325, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_PopIndex(__pyx_v_keys, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1326 + /* "dependency_injector/providers.pyx":1327 * while len(keys) > 0: * key = keys.pop(0) * value = value.get(key) # <<<<<<<<<<<<<< * if value is None: * break */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1326, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26243,13 +26243,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_key) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_key); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1326, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1327, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1327 + /* "dependency_injector/providers.pyx":1328 * key = keys.pop(0) * value = value.get(key) * if value is None: # <<<<<<<<<<<<<< @@ -26260,7 +26260,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":1328 + /* "dependency_injector/providers.pyx":1329 * value = value.get(key) * if value is None: * break # <<<<<<<<<<<<<< @@ -26269,7 +26269,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get */ goto __pyx_L4_break; - /* "dependency_injector/providers.pyx":1327 + /* "dependency_injector/providers.pyx":1328 * key = keys.pop(0) * value = value.get(key) * if value is None: # <<<<<<<<<<<<<< @@ -26280,7 +26280,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get } __pyx_L4_break:; - /* "dependency_injector/providers.pyx":1330 + /* "dependency_injector/providers.pyx":1331 * break * * return value # <<<<<<<<<<<<<< @@ -26292,7 +26292,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get __pyx_r = __pyx_v_value; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1312 + /* "dependency_injector/providers.pyx":1313 * return self.__name * * def get(self, selector): # <<<<<<<<<<<<<< @@ -26316,7 +26316,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_12get return __pyx_r; } -/* "dependency_injector/providers.pyx":1332 +/* "dependency_injector/providers.pyx":1333 * return value * * def set(self, selector, value): # <<<<<<<<<<<<<< @@ -26359,11 +26359,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_13Configuration_15set case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, 1); __PYX_ERR(1, 1332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, 1); __PYX_ERR(1, 1333, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set") < 0)) __PYX_ERR(1, 1332, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set") < 0)) __PYX_ERR(1, 1333, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -26376,7 +26376,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_13Configuration_15set } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1332, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("set", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1333, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Configuration.set", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -26410,14 +26410,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set", 0); - /* "dependency_injector/providers.pyx":1344 + /* "dependency_injector/providers.pyx":1345 * :rtype: :py:class:`OverridingContext` * """ * keys = selector.split('.') # <<<<<<<<<<<<<< * original_value = current_value = self.__call__() * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_selector, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1344, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_selector, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26431,20 +26431,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s__4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s__4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1344, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1345, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_keys = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1345 + /* "dependency_injector/providers.pyx":1346 * """ * keys = selector.split('.') * original_value = current_value = self.__call__() # <<<<<<<<<<<<<< * * while len(keys) > 0: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1345, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26458,7 +26458,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1345, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_t_1); @@ -26467,7 +26467,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set __pyx_v_current_value = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1347 + /* "dependency_injector/providers.pyx":1348 * original_value = current_value = self.__call__() * * while len(keys) > 0: # <<<<<<<<<<<<<< @@ -26475,43 +26475,43 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set * if len(keys) == 0: */ while (1) { - __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1347, __pyx_L1_error) + __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1348, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 0) != 0); if (!__pyx_t_5) break; - /* "dependency_injector/providers.pyx":1348 + /* "dependency_injector/providers.pyx":1349 * * while len(keys) > 0: * key = keys.pop(0) # <<<<<<<<<<<<<< * if len(keys) == 0: * current_value[key] = value */ - __pyx_t_1 = __Pyx_PyObject_PopIndex(__pyx_v_keys, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1348, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_PopIndex(__pyx_v_keys, __pyx_int_0, 0, 1, Py_ssize_t, PyInt_FromSsize_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1349, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1349 + /* "dependency_injector/providers.pyx":1350 * while len(keys) > 0: * key = keys.pop(0) * if len(keys) == 0: # <<<<<<<<<<<<<< * current_value[key] = value * break */ - __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1349, __pyx_L1_error) + __pyx_t_4 = PyObject_Length(__pyx_v_keys); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1350, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 == 0) != 0); if (__pyx_t_5) { - /* "dependency_injector/providers.pyx":1350 + /* "dependency_injector/providers.pyx":1351 * key = keys.pop(0) * if len(keys) == 0: * current_value[key] = value # <<<<<<<<<<<<<< * break * temp_value = current_value.get(key, {}) */ - if (unlikely(PyObject_SetItem(__pyx_v_current_value, __pyx_v_key, __pyx_v_value) < 0)) __PYX_ERR(1, 1350, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_current_value, __pyx_v_key, __pyx_v_value) < 0)) __PYX_ERR(1, 1351, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1351 + /* "dependency_injector/providers.pyx":1352 * if len(keys) == 0: * current_value[key] = value * break # <<<<<<<<<<<<<< @@ -26520,7 +26520,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set */ goto __pyx_L4_break; - /* "dependency_injector/providers.pyx":1349 + /* "dependency_injector/providers.pyx":1350 * while len(keys) > 0: * key = keys.pop(0) * if len(keys) == 0: # <<<<<<<<<<<<<< @@ -26529,16 +26529,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set */ } - /* "dependency_injector/providers.pyx":1352 + /* "dependency_injector/providers.pyx":1353 * current_value[key] = value * break * temp_value = current_value.get(key, {}) # <<<<<<<<<<<<<< * current_value[key] = temp_value * current_value = temp_value */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_current_value, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_current_value, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; __pyx_t_7 = 0; @@ -26555,7 +26555,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_key, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -26564,14 +26564,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_key, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -26582,7 +26582,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1352, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1353, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } @@ -26590,16 +26590,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set __Pyx_XDECREF_SET(__pyx_v_temp_value, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1353 + /* "dependency_injector/providers.pyx":1354 * break * temp_value = current_value.get(key, {}) * current_value[key] = temp_value # <<<<<<<<<<<<<< * current_value = temp_value * */ - if (unlikely(PyObject_SetItem(__pyx_v_current_value, __pyx_v_key, __pyx_v_temp_value) < 0)) __PYX_ERR(1, 1353, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_current_value, __pyx_v_key, __pyx_v_temp_value) < 0)) __PYX_ERR(1, 1354, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1354 + /* "dependency_injector/providers.pyx":1355 * temp_value = current_value.get(key, {}) * current_value[key] = temp_value * current_value = temp_value # <<<<<<<<<<<<<< @@ -26611,7 +26611,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set } __pyx_L4_break:; - /* "dependency_injector/providers.pyx":1356 + /* "dependency_injector/providers.pyx":1357 * current_value = temp_value * * return self.override(original_value) # <<<<<<<<<<<<<< @@ -26619,7 +26619,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set * def override(self, provider): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1356, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26633,14 +26633,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set } __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_8, __pyx_v_original_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_original_value); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1356, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1332 + /* "dependency_injector/providers.pyx":1333 * return value * * def set(self, selector, value): # <<<<<<<<<<<<<< @@ -26668,7 +26668,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_14set return __pyx_r; } -/* "dependency_injector/providers.pyx":1358 +/* "dependency_injector/providers.pyx":1359 * return self.override(original_value) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -26702,14 +26702,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove int __pyx_clineno = 0; __Pyx_RefNannySetupContext("override", 0); - /* "dependency_injector/providers.pyx":1369 + /* "dependency_injector/providers.pyx":1370 * :rtype: :py:class:`OverridingContext` * """ * context = super().override(provider) # <<<<<<<<<<<<<< * self.reset_cache() * return context */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1369, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); @@ -26717,10 +26717,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1369, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1369, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -26735,20 +26735,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_provider) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_provider); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1369, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_context = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1370 + /* "dependency_injector/providers.pyx":1371 * """ * context = super().override(provider) * self.reset_cache() # <<<<<<<<<<<<<< * return context * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1370, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -26762,12 +26762,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1370, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1371 + /* "dependency_injector/providers.pyx":1372 * context = super().override(provider) * self.reset_cache() * return context # <<<<<<<<<<<<<< @@ -26779,7 +26779,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove __pyx_r = __pyx_v_context; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1358 + /* "dependency_injector/providers.pyx":1359 * return self.override(original_value) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -26801,7 +26801,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_16ove return __pyx_r; } -/* "dependency_injector/providers.pyx":1373 +/* "dependency_injector/providers.pyx":1374 * return context * * def reset_last_overriding(self): # <<<<<<<<<<<<<< @@ -26834,14 +26834,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_18res int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset_last_overriding", 0); - /* "dependency_injector/providers.pyx":1381 + /* "dependency_injector/providers.pyx":1382 * :rtype: None * """ * super().reset_last_overriding() # <<<<<<<<<<<<<< * self.reset_cache() * */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1381, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); @@ -26849,10 +26849,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_18res __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1381, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reset_last_overriding); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1381, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reset_last_overriding); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -26867,38 +26867,38 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_18res } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1381, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "dependency_injector/providers.pyx":1382 - * """ - * super().reset_last_overriding() - * self.reset_cache() # <<<<<<<<<<<<<< - * - * def reset_override(self): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1382, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1382, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1373 + /* "dependency_injector/providers.pyx":1383 + * """ + * super().reset_last_overriding() + * self.reset_cache() # <<<<<<<<<<<<<< + * + * def reset_override(self): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dependency_injector/providers.pyx":1374 * return context * * def reset_last_overriding(self): # <<<<<<<<<<<<<< @@ -26921,7 +26921,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_18res return __pyx_r; } -/* "dependency_injector/providers.pyx":1384 +/* "dependency_injector/providers.pyx":1385 * self.reset_cache() * * def reset_override(self): # <<<<<<<<<<<<<< @@ -26954,14 +26954,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_20res int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset_override", 0); - /* "dependency_injector/providers.pyx":1389 + /* "dependency_injector/providers.pyx":1390 * :rtype: None * """ * super().reset_override() # <<<<<<<<<<<<<< * self.reset_cache() * */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1389, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration)); @@ -26969,10 +26969,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_20res __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1389, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reset_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1389, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reset_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -26987,38 +26987,38 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_20res } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1389, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "dependency_injector/providers.pyx":1390 - * """ - * super().reset_override() - * self.reset_cache() # <<<<<<<<<<<<<< - * - * def reset_cache(self): - */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1390, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - } - } - __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1390, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1384 + /* "dependency_injector/providers.pyx":1391 + * """ + * super().reset_override() + * self.reset_cache() # <<<<<<<<<<<<<< + * + * def reset_cache(self): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "dependency_injector/providers.pyx":1385 * self.reset_cache() * * def reset_override(self): # <<<<<<<<<<<<<< @@ -27041,7 +27041,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_20res return __pyx_r; } -/* "dependency_injector/providers.pyx":1392 +/* "dependency_injector/providers.pyx":1393 * self.reset_cache() * * def reset_cache(self): # <<<<<<<<<<<<<< @@ -27078,7 +27078,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset_cache", 0); - /* "dependency_injector/providers.pyx":1397 + /* "dependency_injector/providers.pyx":1398 * :rtype: None * """ * for child in self.__children.values(): # <<<<<<<<<<<<<< @@ -27087,17 +27087,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res */ if (unlikely(__pyx_v_self->__pyx___children == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(1, 1397, __pyx_L1_error) + __PYX_ERR(1, 1398, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_Values(__pyx_v_self->__pyx___children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_Values(__pyx_v_self->__pyx___children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1398, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -27105,17 +27105,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1398, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1398, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1397, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -27125,7 +27125,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 1397, __pyx_L1_error) + else __PYX_ERR(1, 1398, __pyx_L1_error) } break; } @@ -27134,14 +27134,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res __Pyx_XDECREF_SET(__pyx_v_child, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1398 + /* "dependency_injector/providers.pyx":1399 * """ * for child in self.__children.values(): * child.reset_cache() # <<<<<<<<<<<<<< * * def update(self, value): */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_child, __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1398, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_child, __pyx_n_s_reset_cache); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -27155,12 +27155,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res } __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1398, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1399, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1397 + /* "dependency_injector/providers.pyx":1398 * :rtype: None * """ * for child in self.__children.values(): # <<<<<<<<<<<<<< @@ -27170,7 +27170,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1392 + /* "dependency_injector/providers.pyx":1393 * self.reset_cache() * * def reset_cache(self): # <<<<<<<<<<<<<< @@ -27195,7 +27195,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_22res return __pyx_r; } -/* "dependency_injector/providers.pyx":1400 +/* "dependency_injector/providers.pyx":1401 * child.reset_cache() * * def update(self, value): # <<<<<<<<<<<<<< @@ -27228,14 +27228,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_24upd int __pyx_clineno = 0; __Pyx_RefNannySetupContext("update", 0); - /* "dependency_injector/providers.pyx":1412 + /* "dependency_injector/providers.pyx":1413 * :rtype: None * """ * self.override(value) # <<<<<<<<<<<<<< * * def from_ini(self, filepath): */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1412, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -27249,12 +27249,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_24upd } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1412, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1413, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1400 + /* "dependency_injector/providers.pyx":1401 * child.reset_cache() * * def update(self, value): # <<<<<<<<<<<<<< @@ -27277,7 +27277,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_24upd return __pyx_r; } -/* "dependency_injector/providers.pyx":1414 +/* "dependency_injector/providers.pyx":1415 * self.override(value) * * def from_ini(self, filepath): # <<<<<<<<<<<<<< @@ -27322,14 +27322,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro int __pyx_clineno = 0; __Pyx_RefNannySetupContext("from_ini", 0); - /* "dependency_injector/providers.pyx":1424 + /* "dependency_injector/providers.pyx":1425 * :rtype: None * """ * parser = _parse_ini_file(filepath) # <<<<<<<<<<<<<< * * config = {} */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_parse_ini_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1424, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_parse_ini_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -27343,32 +27343,32 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_v_filepath) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_filepath); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1424, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1425, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_parser = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1426 + /* "dependency_injector/providers.pyx":1427 * parser = _parse_ini_file(filepath) * * config = {} # <<<<<<<<<<<<<< * for section in parser.sections(): * config[section] = dict(parser.items(section)) */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1426, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_config = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1427 + /* "dependency_injector/providers.pyx":1428 * * config = {} * for section in parser.sections(): # <<<<<<<<<<<<<< * config[section] = dict(parser.items(section)) * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_parser, __pyx_n_s_sections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_parser, __pyx_n_s_sections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -27382,16 +27382,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1427, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { - __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1428, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -27399,17 +27399,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 1428, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 1428, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1427, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1428, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -27419,7 +27419,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 1427, __pyx_L1_error) + else __PYX_ERR(1, 1428, __pyx_L1_error) } break; } @@ -27428,14 +27428,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro __Pyx_XDECREF_SET(__pyx_v_section, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1428 + /* "dependency_injector/providers.pyx":1429 * config = {} * for section in parser.sections(): * config[section] = dict(parser.items(section)) # <<<<<<<<<<<<<< * * current_config = self.__call__() */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parser, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1428, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_parser, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -27449,16 +27449,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro } __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_v_section) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_section); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1428, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1428, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1429, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_config, __pyx_v_section, __pyx_t_3) < 0)) __PYX_ERR(1, 1428, __pyx_L1_error) + if (unlikely(PyDict_SetItem(__pyx_v_config, __pyx_v_section, __pyx_t_3) < 0)) __PYX_ERR(1, 1429, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1427 + /* "dependency_injector/providers.pyx":1428 * * config = {} * for section in parser.sections(): # <<<<<<<<<<<<<< @@ -27468,14 +27468,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1430 + /* "dependency_injector/providers.pyx":1431 * config[section] = dict(parser.items(section)) * * current_config = self.__call__() # <<<<<<<<<<<<<< * if not current_config: * current_config = {} */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1430, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -27489,36 +27489,36 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro } __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1430, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_current_config = __pyx_t_2; __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1431 + /* "dependency_injector/providers.pyx":1432 * * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< * current_config = {} * self.override(merge_dicts(current_config, config)) */ - __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 1431, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(1, 1432, __pyx_L1_error) __pyx_t_8 = ((!__pyx_t_7) != 0); if (__pyx_t_8) { - /* "dependency_injector/providers.pyx":1432 + /* "dependency_injector/providers.pyx":1433 * current_config = self.__call__() * if not current_config: * current_config = {} # <<<<<<<<<<<<<< * self.override(merge_dicts(current_config, config)) * */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1432, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_current_config, __pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1431 + /* "dependency_injector/providers.pyx":1432 * * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< @@ -27527,16 +27527,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro */ } - /* "dependency_injector/providers.pyx":1433 + /* "dependency_injector/providers.pyx":1434 * if not current_config: * current_config = {} * self.override(merge_dicts(current_config, config)) # <<<<<<<<<<<<<< * * def from_yaml(self, filepath): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1433, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1433, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_10 = 0; @@ -27553,7 +27553,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_current_config, __pyx_v_config}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1433, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -27561,13 +27561,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_v_current_config, __pyx_v_config}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1433, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 1433, __pyx_L1_error) + __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -27578,7 +27578,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro __Pyx_INCREF(__pyx_v_config); __Pyx_GIVEREF(__pyx_v_config); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_config); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1433, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } @@ -27596,12 +27596,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1433, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1414 + /* "dependency_injector/providers.pyx":1415 * self.override(value) * * def from_ini(self, filepath): # <<<<<<<<<<<<<< @@ -27631,7 +27631,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_26fro return __pyx_r; } -/* "dependency_injector/providers.pyx":1435 +/* "dependency_injector/providers.pyx":1436 * self.override(merge_dicts(current_config, config)) * * def from_yaml(self, filepath): # <<<<<<<<<<<<<< @@ -27681,28 +27681,28 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro int __pyx_clineno = 0; __Pyx_RefNannySetupContext("from_yaml", 0); - /* "dependency_injector/providers.pyx":1445 + /* "dependency_injector/providers.pyx":1446 * :rtype: None * """ * if yaml is None: # <<<<<<<<<<<<<< * raise Error( * 'Unable to load yaml configuration - PyYAML is not installed. ' */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1445, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__pyx_t_1 == Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (unlikely(__pyx_t_3)) { - /* "dependency_injector/providers.pyx":1446 + /* "dependency_injector/providers.pyx":1447 * """ * if yaml is None: * raise Error( # <<<<<<<<<<<<<< * 'Unable to load yaml configuration - PyYAML is not installed. ' * 'Install PyYAML or install Dependency Injector with yaml extras: ' */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1446, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { @@ -27716,14 +27716,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_kp_s_Unable_to_load_yaml_configuratio) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_s_Unable_to_load_yaml_configuratio); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1446, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1446, __pyx_L1_error) + __PYX_ERR(1, 1447, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1445 + /* "dependency_injector/providers.pyx":1446 * :rtype: None * """ * if yaml is None: # <<<<<<<<<<<<<< @@ -27732,7 +27732,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro */ } - /* "dependency_injector/providers.pyx":1452 + /* "dependency_injector/providers.pyx":1453 * ) * * try: # <<<<<<<<<<<<<< @@ -27748,7 +27748,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { - /* "dependency_injector/providers.pyx":1453 + /* "dependency_injector/providers.pyx":1454 * * try: * with open(filepath) as opened_file: # <<<<<<<<<<<<<< @@ -27756,11 +27756,11 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro * except IOError: */ /*with:*/ { - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_open, __pyx_v_filepath); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1453, __pyx_L4_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_open, __pyx_v_filepath); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1454, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1453, __pyx_L4_error) + __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1454, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1453, __pyx_L10_error) + __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_enter); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1454, __pyx_L10_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_10 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -27774,7 +27774,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro } __pyx_t_4 = (__pyx_t_10) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_10) : __Pyx_PyObject_CallNoArg(__pyx_t_5); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1453, __pyx_L10_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1454, __pyx_L10_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_t_4; @@ -27792,21 +27792,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_v_opened_file = __pyx_t_5; __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1454 + /* "dependency_injector/providers.pyx":1455 * try: * with open(filepath) as opened_file: * config = yaml.load(opened_file, yaml.Loader) # <<<<<<<<<<<<<< * except IOError: * return */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1454, __pyx_L14_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_load); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_load); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1454, __pyx_L14_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_yaml); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Loader); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_Loader); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; @@ -27824,7 +27824,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_opened_file, __pyx_t_10}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -27833,14 +27833,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_opened_file, __pyx_t_10}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else #endif { - __pyx_t_15 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_15 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_1) { __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); __pyx_t_1 = NULL; @@ -27851,7 +27851,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_10); __pyx_t_10 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1454, __pyx_L14_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1455, __pyx_L14_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } @@ -27859,7 +27859,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_v_config = __pyx_t_5; __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1453 + /* "dependency_injector/providers.pyx":1454 * * try: * with open(filepath) as opened_file: # <<<<<<<<<<<<<< @@ -27879,20 +27879,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /*except:*/ { __Pyx_AddTraceback("dependency_injector.providers.Configuration.from_yaml", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(1, 1453, __pyx_L16_except_error) + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_15) < 0) __PYX_ERR(1, 1454, __pyx_L16_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); - __pyx_t_10 = PyTuple_Pack(3, __pyx_t_5, __pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1453, __pyx_L16_except_error) + __pyx_t_10 = PyTuple_Pack(3, __pyx_t_5, __pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1454, __pyx_L16_except_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; - if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 1453, __pyx_L16_except_error) + if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 1454, __pyx_L16_except_error) __Pyx_GOTREF(__pyx_t_16); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; - if (__pyx_t_3 < 0) __PYX_ERR(1, 1453, __pyx_L16_except_error) + if (__pyx_t_3 < 0) __PYX_ERR(1, 1454, __pyx_L16_except_error) __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_5); @@ -27900,7 +27900,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_4, __pyx_t_15); __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_15 = 0; - __PYX_ERR(1, 1453, __pyx_L16_except_error) + __PYX_ERR(1, 1454, __pyx_L16_except_error) } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -27926,7 +27926,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro if (__pyx_t_9) { __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__2, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1453, __pyx_L4_error) + if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1454, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } @@ -27941,7 +27941,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_L23:; } - /* "dependency_injector/providers.pyx":1452 + /* "dependency_injector/providers.pyx":1453 * ) * * try: # <<<<<<<<<<<<<< @@ -27960,7 +27960,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1455 + /* "dependency_injector/providers.pyx":1456 * with open(filepath) as opened_file: * config = yaml.load(opened_file, yaml.Loader) * except IOError: # <<<<<<<<<<<<<< @@ -27970,12 +27970,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_IOError); if (__pyx_t_14) { __Pyx_AddTraceback("dependency_injector.providers.Configuration.from_yaml", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(1, 1455, __pyx_L6_except_error) + if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(1, 1456, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); - /* "dependency_injector/providers.pyx":1456 + /* "dependency_injector/providers.pyx":1457 * config = yaml.load(opened_file, yaml.Loader) * except IOError: * return # <<<<<<<<<<<<<< @@ -27992,7 +27992,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro goto __pyx_L6_except_error; __pyx_L6_except_error:; - /* "dependency_injector/providers.pyx":1452 + /* "dependency_injector/providers.pyx":1453 * ) * * try: # <<<<<<<<<<<<<< @@ -28013,14 +28013,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_L9_try_end:; } - /* "dependency_injector/providers.pyx":1458 + /* "dependency_injector/providers.pyx":1459 * return * * current_config = self.__call__() # <<<<<<<<<<<<<< * if not current_config: * current_config = {} */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1458, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -28034,36 +28034,36 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro } __pyx_t_5 = (__pyx_t_15) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1458, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_current_config = __pyx_t_5; __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1459 + /* "dependency_injector/providers.pyx":1460 * * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< * current_config = {} * self.override(merge_dicts(current_config, config)) */ - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1459, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1460, __pyx_L1_error) __pyx_t_3 = ((!__pyx_t_2) != 0); if (__pyx_t_3) { - /* "dependency_injector/providers.pyx":1460 + /* "dependency_injector/providers.pyx":1461 * current_config = self.__call__() * if not current_config: * current_config = {} # <<<<<<<<<<<<<< * self.override(merge_dicts(current_config, config)) * */ - __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1460, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF_SET(__pyx_v_current_config, __pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1459 + /* "dependency_injector/providers.pyx":1460 * * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< @@ -28072,18 +28072,18 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro */ } - /* "dependency_injector/providers.pyx":1461 + /* "dependency_injector/providers.pyx":1462 * if not current_config: * current_config = {} * self.override(merge_dicts(current_config, config)) # <<<<<<<<<<<<<< * * def from_dict(self, options): */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1461, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1461, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); - if (unlikely(!__pyx_v_config)) { __Pyx_RaiseUnboundLocalError("config"); __PYX_ERR(1, 1461, __pyx_L1_error) } + if (unlikely(!__pyx_v_config)) { __Pyx_RaiseUnboundLocalError("config"); __PYX_ERR(1, 1462, __pyx_L1_error) } __pyx_t_1 = NULL; __pyx_t_14 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_10))) { @@ -28099,7 +28099,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_current_config, __pyx_v_config}; - __pyx_t_15 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1461, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_15); } else @@ -28107,13 +28107,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) { PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_current_config, __pyx_v_config}; - __pyx_t_15 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1461, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-__pyx_t_14, 2+__pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_15); } else #endif { - __pyx_t_17 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 1461, __pyx_L1_error) + __pyx_t_17 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_17); if (__pyx_t_1) { __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_1); __pyx_t_1 = NULL; @@ -28124,7 +28124,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __Pyx_INCREF(__pyx_v_config); __Pyx_GIVEREF(__pyx_v_config); PyTuple_SET_ITEM(__pyx_t_17, 1+__pyx_t_14, __pyx_v_config); - __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_17, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1461, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_17, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; } @@ -28142,12 +28142,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro __pyx_t_5 = (__pyx_t_10) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_10, __pyx_t_15) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1461, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":1435 + /* "dependency_injector/providers.pyx":1436 * self.override(merge_dicts(current_config, config)) * * def from_yaml(self, filepath): # <<<<<<<<<<<<<< @@ -28176,7 +28176,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_28fro return __pyx_r; } -/* "dependency_injector/providers.pyx":1463 +/* "dependency_injector/providers.pyx":1464 * self.override(merge_dicts(current_config, config)) * * def from_dict(self, options): # <<<<<<<<<<<<<< @@ -28216,14 +28216,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro int __pyx_clineno = 0; __Pyx_RefNannySetupContext("from_dict", 0); - /* "dependency_injector/providers.pyx":1473 + /* "dependency_injector/providers.pyx":1474 * :rtype: None * """ * current_config = self.__call__() # <<<<<<<<<<<<<< * if not current_config: * current_config = {} */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1473, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -28237,36 +28237,36 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1473, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_current_config = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1474 + /* "dependency_injector/providers.pyx":1475 * """ * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< * current_config = {} * self.override(merge_dicts(current_config, options)) */ - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1474, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_current_config); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1475, __pyx_L1_error) __pyx_t_5 = ((!__pyx_t_4) != 0); if (__pyx_t_5) { - /* "dependency_injector/providers.pyx":1475 + /* "dependency_injector/providers.pyx":1476 * current_config = self.__call__() * if not current_config: * current_config = {} # <<<<<<<<<<<<<< * self.override(merge_dicts(current_config, options)) * */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1475, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_current_config, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1474 + /* "dependency_injector/providers.pyx":1475 * """ * current_config = self.__call__() * if not current_config: # <<<<<<<<<<<<<< @@ -28275,16 +28275,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro */ } - /* "dependency_injector/providers.pyx":1476 + /* "dependency_injector/providers.pyx":1477 * if not current_config: * current_config = {} * self.override(merge_dicts(current_config, options)) # <<<<<<<<<<<<<< * * def from_env(self, name, default=None): */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1476, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1476, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -28301,7 +28301,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_current_config, __pyx_v_options}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1476, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -28309,13 +28309,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_current_config, __pyx_v_options}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1476, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1476, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -28326,7 +28326,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro __Pyx_INCREF(__pyx_v_options); __Pyx_GIVEREF(__pyx_v_options); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_options); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1476, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } @@ -28344,12 +28344,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1476, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1477, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1463 + /* "dependency_injector/providers.pyx":1464 * self.override(merge_dicts(current_config, config)) * * def from_dict(self, options): # <<<<<<<<<<<<<< @@ -28376,7 +28376,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_30fro return __pyx_r; } -/* "dependency_injector/providers.pyx":1478 +/* "dependency_injector/providers.pyx":1479 * self.override(merge_dicts(current_config, options)) * * def from_env(self, name, default=None): # <<<<<<<<<<<<<< @@ -28424,7 +28424,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_13Configuration_33fro } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "from_env") < 0)) __PYX_ERR(1, 1478, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "from_env") < 0)) __PYX_ERR(1, 1479, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -28440,7 +28440,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_13Configuration_33fro } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("from_env", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1478, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("from_env", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1479, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Configuration.from_env", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -28467,16 +28467,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro int __pyx_clineno = 0; __Pyx_RefNannySetupContext("from_env", 0); - /* "dependency_injector/providers.pyx":1489 + /* "dependency_injector/providers.pyx":1490 * :rtype: None * """ * value = os.getenv(name, default) # <<<<<<<<<<<<<< * self.override(value) * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1489, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_os); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getenv); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1489, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getenv); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -28494,7 +28494,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_name, __pyx_v_default}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1489, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -28502,13 +28502,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_name, __pyx_v_default}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1489, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_4, 2+__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1489, __pyx_L1_error) + __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; @@ -28519,7 +28519,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro __Pyx_INCREF(__pyx_v_default); __Pyx_GIVEREF(__pyx_v_default); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_default); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1489, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1490, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -28527,14 +28527,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1490 + /* "dependency_injector/providers.pyx":1491 * """ * value = os.getenv(name, default) * self.override(value) # <<<<<<<<<<<<<< * * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1490, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_override); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -28548,12 +28548,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_32fro } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_v_value) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1490, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1491, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1478 + /* "dependency_injector/providers.pyx":1479 * self.override(merge_dicts(current_config, options)) * * def from_env(self, name, default=None): # <<<<<<<<<<<<<< @@ -28915,7 +28915,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13Configuration_36__s return __pyx_r; } -/* "dependency_injector/providers.pyx":1546 +/* "dependency_injector/providers.pyx":1547 * provided_type = None * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -28972,7 +28972,7 @@ static int __pyx_pw_19dependency_injector_9providers_7Factory_1__init__(PyObject } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 1546, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 1547, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -28983,7 +28983,7 @@ static int __pyx_pw_19dependency_injector_9providers_7Factory_1__init__(PyObject } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1546, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1547, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -29020,19 +29020,19 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":1552 + /* "dependency_injector/providers.pyx":1553 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< * not issubclass(provides, self.__class__.provided_type)): * raise Error('{0} can provide only {1} instances'.format( */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1552, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1552, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1552, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1553, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { } else { @@ -29040,25 +29040,25 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ goto __pyx_L4_bool_binop_done; } - /* "dependency_injector/providers.pyx":1553 + /* "dependency_injector/providers.pyx":1554 * """ * 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)) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1553, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1553, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = PyObject_IsSubclass(__pyx_v_provides, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1553, __pyx_L1_error) + __pyx_t_4 = PyObject_IsSubclass(__pyx_v_provides, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; - /* "dependency_injector/providers.pyx":1552 + /* "dependency_injector/providers.pyx":1553 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< @@ -29067,30 +29067,30 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ */ if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":1554 + /* "dependency_injector/providers.pyx":1555 * 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)) * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1554, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_provide_only_1_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1554, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_provide_only_1_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "dependency_injector/providers.pyx":1555 + /* "dependency_injector/providers.pyx":1556 * not issubclass(provides, self.__class__.provided_type)): * raise Error('{0} can provide only {1} instances'.format( * self.__class__, self.__class__.provided_type)) # <<<<<<<<<<<<<< * * self.__instantiator = Callable(provides, *args, **kwargs) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1555, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1555, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1555, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1556, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; @@ -29108,7 +29108,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1554, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -29118,7 +29118,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1554, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -29126,7 +29126,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ } else #endif { - __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1554, __pyx_L1_error) + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -29137,7 +29137,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_10); __pyx_t_8 = 0; __pyx_t_10 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1554, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } @@ -29155,14 +29155,14 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1554, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 1554, __pyx_L1_error) + __PYX_ERR(1, 1555, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1552 + /* "dependency_injector/providers.pyx":1553 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< @@ -29171,22 +29171,22 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ */ } - /* "dependency_injector/providers.pyx":1557 + /* "dependency_injector/providers.pyx":1558 * self.__class__, self.__class__.provided_type)) * * self.__instantiator = Callable(provides, *args, **kwargs) # <<<<<<<<<<<<<< * * self.__attributes = tuple() */ - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1557, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_provides); __Pyx_GIVEREF(__pyx_v_provides); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_provides); - __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1557, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Callable), __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1557, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Callable), __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GIVEREF(__pyx_t_2); @@ -29195,14 +29195,14 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ __pyx_v_self->__pyx___instantiator = ((struct __pyx_obj_19dependency_injector_9providers_Callable *)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1559 + /* "dependency_injector/providers.pyx":1560 * self.__instantiator = Callable(provides, *args, **kwargs) * * self.__attributes = tuple() # <<<<<<<<<<<<<< * self.__attributes_len = 0 * */ - __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1559, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1560, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_self->__pyx___attributes); @@ -29210,7 +29210,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ __pyx_v_self->__pyx___attributes = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1560 + /* "dependency_injector/providers.pyx":1561 * * self.__attributes = tuple() * self.__attributes_len = 0 # <<<<<<<<<<<<<< @@ -29219,14 +29219,14 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ */ __pyx_v_self->__pyx___attributes_len = 0; - /* "dependency_injector/providers.pyx":1562 + /* "dependency_injector/providers.pyx":1563 * self.__attributes_len = 0 * * super(Factory, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1562, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); @@ -29234,10 +29234,10 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1562, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1562, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -29252,12 +29252,12 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ } __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1562, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1546 + /* "dependency_injector/providers.pyx":1547 * provided_type = None * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -29284,7 +29284,7 @@ static int __pyx_pf_19dependency_injector_9providers_7Factory___init__(struct __ return __pyx_r; } -/* "dependency_injector/providers.pyx":1564 +/* "dependency_injector/providers.pyx":1565 * super(Factory, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -29324,16 +29324,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":1566 + /* "dependency_injector/providers.pyx":1567 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1566, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1566, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -29348,13 +29348,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1566, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1567, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1567 + /* "dependency_injector/providers.pyx":1568 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -29365,7 +29365,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":1568 + /* "dependency_injector/providers.pyx":1569 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -29377,7 +29377,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1567 + /* "dependency_injector/providers.pyx":1568 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -29386,19 +29386,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ */ } - /* "dependency_injector/providers.pyx":1570 + /* "dependency_injector/providers.pyx":1571 * return copied * * cls = self.cls # <<<<<<<<<<<<<< * if isinstance(cls, Provider): * cls = deepcopy(cls, memo) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1570, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_cls = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1571 + /* "dependency_injector/providers.pyx":1572 * * cls = self.cls * if isinstance(cls, Provider): # <<<<<<<<<<<<<< @@ -29409,22 +29409,22 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __pyx_t_5 = (__pyx_t_6 != 0); if (__pyx_t_5) { - /* "dependency_injector/providers.pyx":1572 + /* "dependency_injector/providers.pyx":1573 * cls = self.cls * if isinstance(cls, Provider): * cls = deepcopy(cls, memo) # <<<<<<<<<<<<<< * * copied = self.__class__(cls, */ - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1572, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1573, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_cls, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1572, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_cls, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_cls, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1571 + /* "dependency_injector/providers.pyx":1572 * * cls = self.cls * if isinstance(cls, Provider): # <<<<<<<<<<<<<< @@ -29433,89 +29433,89 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ */ } - /* "dependency_injector/providers.pyx":1574 + /* "dependency_injector/providers.pyx":1575 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_cls); __Pyx_GIVEREF(__pyx_v_cls); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_cls); - /* "dependency_injector/providers.pyx":1575 + /* "dependency_injector/providers.pyx":1576 * * copied = self.__class__(cls, * *deepcopy(self.args, memo), # <<<<<<<<<<<<<< * **deepcopy(self.kwargs, memo)) * copied.set_attributes(**deepcopy(self.attributes, memo)) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1575, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1575, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1576, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1575, __pyx_L1_error) + __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1574 + /* "dependency_injector/providers.pyx":1575 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1576 + /* "dependency_injector/providers.pyx":1577 * copied = self.__class__(cls, * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) # <<<<<<<<<<<<<< * copied.set_attributes(**deepcopy(self.attributes, memo)) * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1576, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1576, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1577, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1576, __pyx_L1_error) + __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(__pyx_t_8 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 1576, __pyx_L1_error) + __PYX_ERR(1, 1577, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_8))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1576, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1577, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - /* "dependency_injector/providers.pyx":1574 + /* "dependency_injector/providers.pyx":1575 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1574, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1575, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -29523,54 +29523,54 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __Pyx_DECREF_SET(__pyx_v_copied, __pyx_t_8); __pyx_t_8 = 0; - /* "dependency_injector/providers.pyx":1577 + /* "dependency_injector/providers.pyx":1578 * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) * copied.set_attributes(**deepcopy(self.attributes, memo)) # <<<<<<<<<<<<<< * * self._copy_overridings(copied, memo) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_copied, __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_copied, __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attributes); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attributes); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1577, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1578, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 1577, __pyx_L1_error) + __PYX_ERR(1, 1578, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_1))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1577, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1579 + /* "dependency_injector/providers.pyx":1580 * copied.set_attributes(**deepcopy(self.attributes, memo)) * * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 1579, __pyx_L1_error) - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1579, __pyx_L1_error) + if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 1580, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1580, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_Factory *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":1581 + /* "dependency_injector/providers.pyx":1582 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -29582,7 +29582,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1564 + /* "dependency_injector/providers.pyx":1565 * super(Factory, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -29607,7 +29607,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_2__deepcopy_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1583 +/* "dependency_injector/providers.pyx":1584 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -29642,7 +29642,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4__str__(str int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "dependency_injector/providers.pyx":1588 + /* "dependency_injector/providers.pyx":1589 * :rtype: str * """ * return represent_provider(provider=self, # <<<<<<<<<<<<<< @@ -29651,31 +29651,31 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4__str__(str */ __Pyx_XDECREF(__pyx_r); - /* "dependency_injector/providers.pyx":1589 + /* "dependency_injector/providers.pyx":1590 * """ * return represent_provider(provider=self, * provides=self.__instantiator.provides) # <<<<<<<<<<<<<< * * @property */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1589, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1590, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":1588 + /* "dependency_injector/providers.pyx":1589 * :rtype: str * """ * return represent_provider(provider=self, # <<<<<<<<<<<<<< * provides=self.__instantiator.provides) * */ - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1588, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1589, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1583 + /* "dependency_injector/providers.pyx":1584 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -29695,7 +29695,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4__str__(str return __pyx_r; } -/* "dependency_injector/providers.pyx":1592 +/* "dependency_injector/providers.pyx":1593 * * @property * def cls(self): # <<<<<<<<<<<<<< @@ -29725,7 +29725,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_3cls___get__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1594 + /* "dependency_injector/providers.pyx":1595 * def cls(self): * """Return provided type.""" * return self.provides # <<<<<<<<<<<<<< @@ -29733,13 +29733,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_3cls___get__ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1594, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1592 + /* "dependency_injector/providers.pyx":1593 * * @property * def cls(self): # <<<<<<<<<<<<<< @@ -29758,7 +29758,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_3cls___get__ return __pyx_r; } -/* "dependency_injector/providers.pyx":1597 +/* "dependency_injector/providers.pyx":1598 * * @property * def provides(self): # <<<<<<<<<<<<<< @@ -29788,7 +29788,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8provides___ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1599 + /* "dependency_injector/providers.pyx":1600 * def provides(self): * """Return provided type.""" * return self.__instantiator.provides # <<<<<<<<<<<<<< @@ -29796,13 +29796,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8provides___ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1599, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_provides); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1600, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1597 + /* "dependency_injector/providers.pyx":1598 * * @property * def provides(self): # <<<<<<<<<<<<<< @@ -29821,7 +29821,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8provides___ return __pyx_r; } -/* "dependency_injector/providers.pyx":1602 +/* "dependency_injector/providers.pyx":1603 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -29851,7 +29851,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4args___get_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1604 + /* "dependency_injector/providers.pyx":1605 * def args(self): * """Return positional argument injections.""" * return self.__instantiator.args # <<<<<<<<<<<<<< @@ -29859,13 +29859,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4args___get_ * def add_args(self, *args): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1604, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1602 + /* "dependency_injector/providers.pyx":1603 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -29884,7 +29884,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_4args___get_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1606 +/* "dependency_injector/providers.pyx":1607 * return self.__instantiator.args * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -29921,21 +29921,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6add_args(st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_args", 0); - /* "dependency_injector/providers.pyx":1611 + /* "dependency_injector/providers.pyx":1612 * :return: Reference ``self`` * """ * self.__instantiator.add_args(*args) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1611, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1611, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1612, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1612 + /* "dependency_injector/providers.pyx":1613 * """ * self.__instantiator.add_args(*args) * return self # <<<<<<<<<<<<<< @@ -29947,7 +29947,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6add_args(st __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1606 + /* "dependency_injector/providers.pyx":1607 * return self.__instantiator.args * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -29967,7 +29967,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6add_args(st return __pyx_r; } -/* "dependency_injector/providers.pyx":1614 +/* "dependency_injector/providers.pyx":1615 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -30004,21 +30004,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8set_args(st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_args", 0); - /* "dependency_injector/providers.pyx":1621 + /* "dependency_injector/providers.pyx":1622 * :return: Reference ``self`` * """ * self.__instantiator.set_args(*args) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1621, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1621, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1622, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1622 + /* "dependency_injector/providers.pyx":1623 * """ * self.__instantiator.set_args(*args) * return self # <<<<<<<<<<<<<< @@ -30030,7 +30030,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8set_args(st __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1614 + /* "dependency_injector/providers.pyx":1615 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -30050,7 +30050,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_8set_args(st return __pyx_r; } -/* "dependency_injector/providers.pyx":1624 +/* "dependency_injector/providers.pyx":1625 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -30083,14 +30083,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10clear_args int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_args", 0); - /* "dependency_injector/providers.pyx":1629 + /* "dependency_injector/providers.pyx":1630 * :return: Reference ``self`` * """ * self.__instantiator.clear_args() # <<<<<<<<<<<<<< * return self * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1629, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -30104,12 +30104,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10clear_args } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1629, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1630 + /* "dependency_injector/providers.pyx":1631 * """ * self.__instantiator.clear_args() * return self # <<<<<<<<<<<<<< @@ -30121,7 +30121,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10clear_args __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1624 + /* "dependency_injector/providers.pyx":1625 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -30142,7 +30142,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10clear_args return __pyx_r; } -/* "dependency_injector/providers.pyx":1633 +/* "dependency_injector/providers.pyx":1634 * * @property * def kwargs(self): # <<<<<<<<<<<<<< @@ -30172,7 +30172,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6kwargs___ge int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1635 + /* "dependency_injector/providers.pyx":1636 * def kwargs(self): * """Return keyword argument injections.""" * return self.__instantiator.kwargs # <<<<<<<<<<<<<< @@ -30180,13 +30180,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6kwargs___ge * def add_kwargs(self, **kwargs): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1635, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1636, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1633 + /* "dependency_injector/providers.pyx":1634 * * @property * def kwargs(self): # <<<<<<<<<<<<<< @@ -30205,7 +30205,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_6kwargs___ge return __pyx_r; } -/* "dependency_injector/providers.pyx":1637 +/* "dependency_injector/providers.pyx":1638 * return self.__instantiator.kwargs * * def add_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -30248,21 +30248,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_12add_kwargs int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_kwargs", 0); - /* "dependency_injector/providers.pyx":1642 + /* "dependency_injector/providers.pyx":1643 * :return: Reference ``self`` * """ * self.__instantiator.add_kwargs(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1642, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1642, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1643, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1643 + /* "dependency_injector/providers.pyx":1644 * """ * self.__instantiator.add_kwargs(**kwargs) * return self # <<<<<<<<<<<<<< @@ -30274,7 +30274,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_12add_kwargs __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1637 + /* "dependency_injector/providers.pyx":1638 * return self.__instantiator.kwargs * * def add_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -30294,7 +30294,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_12add_kwargs return __pyx_r; } -/* "dependency_injector/providers.pyx":1645 +/* "dependency_injector/providers.pyx":1646 * return self * * def set_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -30337,21 +30337,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_14set_kwargs int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_kwargs", 0); - /* "dependency_injector/providers.pyx":1652 + /* "dependency_injector/providers.pyx":1653 * :return: Reference ``self`` * """ * self.__instantiator.set_kwargs(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1652, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1652, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1653 + /* "dependency_injector/providers.pyx":1654 * """ * self.__instantiator.set_kwargs(**kwargs) * return self # <<<<<<<<<<<<<< @@ -30363,7 +30363,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_14set_kwargs __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1645 + /* "dependency_injector/providers.pyx":1646 * return self * * def set_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -30383,7 +30383,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_14set_kwargs return __pyx_r; } -/* "dependency_injector/providers.pyx":1655 +/* "dependency_injector/providers.pyx":1656 * return self * * def clear_kwargs(self): # <<<<<<<<<<<<<< @@ -30416,14 +30416,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_16clear_kwar int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_kwargs", 0); - /* "dependency_injector/providers.pyx":1660 + /* "dependency_injector/providers.pyx":1661 * :return: Reference ``self`` * """ * self.__instantiator.clear_kwargs() # <<<<<<<<<<<<<< * return self * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1660, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -30437,12 +30437,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_16clear_kwar } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1660, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1661, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1661 + /* "dependency_injector/providers.pyx":1662 * """ * self.__instantiator.clear_kwargs() * return self # <<<<<<<<<<<<<< @@ -30454,7 +30454,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_16clear_kwar __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1655 + /* "dependency_injector/providers.pyx":1656 * return self * * def clear_kwargs(self): # <<<<<<<<<<<<<< @@ -30475,7 +30475,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_16clear_kwar return __pyx_r; } -/* "dependency_injector/providers.pyx":1664 +/* "dependency_injector/providers.pyx":1665 * * @property * def attributes(self): # <<<<<<<<<<<<<< @@ -30511,19 +30511,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1670 + /* "dependency_injector/providers.pyx":1671 * cdef dict attributes * * attributes = dict() # <<<<<<<<<<<<<< * for index in range(self.__attributes_len): * attribute = self.__attributes[index] */ - __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1670, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1671, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_attributes = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1671 + /* "dependency_injector/providers.pyx":1672 * * attributes = dict() * for index in range(self.__attributes_len): # <<<<<<<<<<<<<< @@ -30535,7 +30535,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_index = __pyx_t_4; - /* "dependency_injector/providers.pyx":1672 + /* "dependency_injector/providers.pyx":1673 * attributes = dict() * for index in range(self.__attributes_len): * attribute = self.__attributes[index] # <<<<<<<<<<<<<< @@ -30544,15 +30544,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes */ if (unlikely(__pyx_v_self->__pyx___attributes == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 1672, __pyx_L1_error) + __PYX_ERR(1, 1673, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->__pyx___attributes, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1672, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->__pyx___attributes, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1673, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_NamedInjection))))) __PYX_ERR(1, 1672, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_NamedInjection))))) __PYX_ERR(1, 1673, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_attribute, ((struct __pyx_obj_19dependency_injector_9providers_NamedInjection *)__pyx_t_1)); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1673 + /* "dependency_injector/providers.pyx":1674 * for index in range(self.__attributes_len): * attribute = self.__attributes[index] * attributes[attribute.__name] = attribute.__value # <<<<<<<<<<<<<< @@ -30561,11 +30561,11 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes */ __pyx_t_1 = __pyx_v_attribute->__pyx_base.__pyx___value; __Pyx_INCREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_attributes, __pyx_v_attribute->__pyx___name, __pyx_t_1) < 0)) __PYX_ERR(1, 1673, __pyx_L1_error) + if (unlikely(PyDict_SetItem(__pyx_v_attributes, __pyx_v_attribute->__pyx___name, __pyx_t_1) < 0)) __PYX_ERR(1, 1674, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "dependency_injector/providers.pyx":1674 + /* "dependency_injector/providers.pyx":1675 * attribute = self.__attributes[index] * attributes[attribute.__name] = attribute.__value * return attributes # <<<<<<<<<<<<<< @@ -30577,7 +30577,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes __pyx_r = __pyx_v_attributes; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1664 + /* "dependency_injector/providers.pyx":1665 * * @property * def attributes(self): # <<<<<<<<<<<<<< @@ -30598,7 +30598,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_10attributes return __pyx_r; } -/* "dependency_injector/providers.pyx":1676 +/* "dependency_injector/providers.pyx":1677 * return attributes * * def add_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -30638,16 +30638,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_18add_attrib int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_attributes", 0); - /* "dependency_injector/providers.pyx":1681 + /* "dependency_injector/providers.pyx":1682 * :return: Reference ``self`` * """ * self.__attributes += parse_named_injections(kwargs) # <<<<<<<<<<<<<< * self.__attributes_len = len(self.__attributes) * return self */ - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1681, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_self->__pyx___attributes, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1681, __pyx_L1_error) + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_self->__pyx___attributes, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1682, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_2); @@ -30656,7 +30656,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_18add_attrib __pyx_v_self->__pyx___attributes = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1682 + /* "dependency_injector/providers.pyx":1683 * """ * self.__attributes += parse_named_injections(kwargs) * self.__attributes_len = len(self.__attributes) # <<<<<<<<<<<<<< @@ -30667,13 +30667,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_18add_attrib __Pyx_INCREF(__pyx_t_2); if (unlikely(__pyx_t_2 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 1682, __pyx_L1_error) + __PYX_ERR(1, 1683, __pyx_L1_error) } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1682, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1683, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_self->__pyx___attributes_len = __pyx_t_3; - /* "dependency_injector/providers.pyx":1683 + /* "dependency_injector/providers.pyx":1684 * self.__attributes += parse_named_injections(kwargs) * self.__attributes_len = len(self.__attributes) * return self # <<<<<<<<<<<<<< @@ -30685,7 +30685,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_18add_attrib __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1676 + /* "dependency_injector/providers.pyx":1677 * return attributes * * def add_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -30705,7 +30705,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_18add_attrib return __pyx_r; } -/* "dependency_injector/providers.pyx":1685 +/* "dependency_injector/providers.pyx":1686 * return self * * def set_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -30744,14 +30744,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_20set_attrib int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_attributes", 0); - /* "dependency_injector/providers.pyx":1692 + /* "dependency_injector/providers.pyx":1693 * :return: Reference ``self`` * """ * self.__attributes = parse_named_injections(kwargs) # <<<<<<<<<<<<<< * self.__attributes_len = len(self.__attributes) * return self */ - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1692, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1693, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___attributes); @@ -30759,7 +30759,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_20set_attrib __pyx_v_self->__pyx___attributes = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1693 + /* "dependency_injector/providers.pyx":1694 * """ * self.__attributes = parse_named_injections(kwargs) * self.__attributes_len = len(self.__attributes) # <<<<<<<<<<<<<< @@ -30770,13 +30770,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_20set_attrib __Pyx_INCREF(__pyx_t_1); if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 1693, __pyx_L1_error) + __PYX_ERR(1, 1694, __pyx_L1_error) } - __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1693, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1694, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->__pyx___attributes_len = __pyx_t_2; - /* "dependency_injector/providers.pyx":1694 + /* "dependency_injector/providers.pyx":1695 * self.__attributes = parse_named_injections(kwargs) * self.__attributes_len = len(self.__attributes) * return self # <<<<<<<<<<<<<< @@ -30788,7 +30788,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_20set_attrib __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1685 + /* "dependency_injector/providers.pyx":1686 * return self * * def set_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -30807,7 +30807,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_20set_attrib return __pyx_r; } -/* "dependency_injector/providers.pyx":1696 +/* "dependency_injector/providers.pyx":1697 * return self * * def clear_attributes(self): # <<<<<<<<<<<<<< @@ -30839,14 +30839,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_22clear_attr int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_attributes", 0); - /* "dependency_injector/providers.pyx":1701 + /* "dependency_injector/providers.pyx":1702 * :return: Reference ``self`` * """ * self.__attributes = tuple() # <<<<<<<<<<<<<< * self.__attributes_len = len(self.__attributes) * return self */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1701, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1702, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___attributes); @@ -30854,7 +30854,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_22clear_attr __pyx_v_self->__pyx___attributes = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1702 + /* "dependency_injector/providers.pyx":1703 * """ * self.__attributes = tuple() * self.__attributes_len = len(self.__attributes) # <<<<<<<<<<<<<< @@ -30865,13 +30865,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_22clear_attr __Pyx_INCREF(__pyx_t_1); if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 1702, __pyx_L1_error) + __PYX_ERR(1, 1703, __pyx_L1_error) } - __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1702, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 1703, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->__pyx___attributes_len = __pyx_t_2; - /* "dependency_injector/providers.pyx":1703 + /* "dependency_injector/providers.pyx":1704 * self.__attributes = tuple() * self.__attributes_len = len(self.__attributes) * return self # <<<<<<<<<<<<<< @@ -30883,7 +30883,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_22clear_attr __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1696 + /* "dependency_injector/providers.pyx":1697 * return self * * def clear_attributes(self): # <<<<<<<<<<<<<< @@ -30902,7 +30902,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_22clear_attr return __pyx_r; } -/* "dependency_injector/providers.pyx":1705 +/* "dependency_injector/providers.pyx":1706 * return self * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -30933,7 +30933,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_7Factory_25_provide)) { __Pyx_XDECREF(__pyx_r); @@ -30953,7 +30953,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -30961,13 +30961,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -30978,7 +30978,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -31001,7 +31001,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru #endif } - /* "dependency_injector/providers.pyx":1707 + /* "dependency_injector/providers.pyx":1708 * cpdef object _provide(self, tuple args, dict kwargs): * """Return new instance.""" * return __factory_call(self, args, kwargs) # <<<<<<<<<<<<<< @@ -31009,13 +31009,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_7Factory__provide(stru * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers___factory_call(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1707, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers___factory_call(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1708, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1705 + /* "dependency_injector/providers.pyx":1706 * return self * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -31073,11 +31073,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_7Factory_25_provide(P case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 1705, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 1706, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 1705, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 1706, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -31090,14 +31090,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_7Factory_25_provide(P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1705, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1706, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Factory._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 1705, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 1705, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 1706, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 1706, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_7Factory_24_provide(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -31118,7 +31118,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_7Factory_24_provide(s int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_7Factory__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1705, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_7Factory__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -31799,7 +31799,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16DelegatedFactory_2_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1742 +/* "dependency_injector/providers.pyx":1743 * """ * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< @@ -31852,7 +31852,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); - /* "dependency_injector/providers.pyx":1747 + /* "dependency_injector/providers.pyx":1748 * Callable interface implementation. * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -31863,16 +31863,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":1748 + /* "dependency_injector/providers.pyx":1749 * """ * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) # <<<<<<<<<<<<<< * return self.__last_overriding(*args, **kwargs) * */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1748, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1748, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -31886,7 +31886,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1748, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -31902,14 +31902,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1748, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 1748, __pyx_L1_error) + __PYX_ERR(1, 1749, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1747 + /* "dependency_injector/providers.pyx":1748 * Callable interface implementation. * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -31918,7 +31918,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c */ } - /* "dependency_injector/providers.pyx":1749 + /* "dependency_injector/providers.pyx":1750 * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) * return self.__last_overriding(*args, **kwargs) # <<<<<<<<<<<<<< @@ -31926,13 +31926,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c * def override(self, provider): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1749, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1750, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1742 + /* "dependency_injector/providers.pyx":1743 * """ * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< @@ -31955,7 +31955,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory___c return __pyx_r; } -/* "dependency_injector/providers.pyx":1751 +/* "dependency_injector/providers.pyx":1752 * return self.__last_overriding(*args, **kwargs) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -31994,7 +31994,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov int __pyx_clineno = 0; __Pyx_RefNannySetupContext("override", 0); - /* "dependency_injector/providers.pyx":1762 + /* "dependency_injector/providers.pyx":1763 * :rtype: :py:class:`OverridingContext` * """ * if not isinstance(provider, Factory): # <<<<<<<<<<<<<< @@ -32005,24 +32005,24 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":1763 + /* "dependency_injector/providers.pyx":1764 * """ * if not isinstance(provider, Factory): * raise Error('{0} must be overridden only by ' # <<<<<<<<<<<<<< * '{1} providers'.format(self, Factory)) * return super(AbstractFactory, self).override(provider) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1763, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "dependency_injector/providers.pyx":1764 + /* "dependency_injector/providers.pyx":1765 * if not isinstance(provider, Factory): * raise Error('{0} must be overridden only by ' * '{1} providers'.format(self, Factory)) # <<<<<<<<<<<<<< * return super(AbstractFactory, self).override(provider) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_only_by_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1764, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_only_by_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -32039,7 +32039,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1764, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1765, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -32047,13 +32047,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1764, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1765, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1764, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -32064,7 +32064,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1764, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1765, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } @@ -32082,14 +32082,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1763, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1764, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 1763, __pyx_L1_error) + __PYX_ERR(1, 1764, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1762 + /* "dependency_injector/providers.pyx":1763 * :rtype: :py:class:`OverridingContext` * """ * if not isinstance(provider, Factory): # <<<<<<<<<<<<<< @@ -32098,7 +32098,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov */ } - /* "dependency_injector/providers.pyx":1765 + /* "dependency_injector/providers.pyx":1766 * raise Error('{0} must be overridden only by ' * '{1} providers'.format(self, Factory)) * return super(AbstractFactory, self).override(provider) # <<<<<<<<<<<<<< @@ -32106,7 +32106,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov * cpdef object _provide(self, tuple args, dict kwargs): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1765, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_AbstractFactory)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_AbstractFactory)); @@ -32114,10 +32114,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1765, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1765, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -32132,14 +32132,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_provider) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_provider); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1765, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1751 + /* "dependency_injector/providers.pyx":1752 * return self.__last_overriding(*args, **kwargs) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -32163,7 +32163,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_2ov return __pyx_r; } -/* "dependency_injector/providers.pyx":1767 +/* "dependency_injector/providers.pyx":1768 * return super(AbstractFactory, self).override(provider) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -32194,7 +32194,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_15AbstractFactory__pro if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_15AbstractFactory_5_provide)) { __Pyx_XDECREF(__pyx_r); @@ -32214,7 +32214,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_15AbstractFactory__pro #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -32222,13 +32222,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_15AbstractFactory__pro #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -32239,7 +32239,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_15AbstractFactory__pro __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -32262,20 +32262,20 @@ static PyObject *__pyx_f_19dependency_injector_9providers_15AbstractFactory__pro #endif } - /* "dependency_injector/providers.pyx":1769 + /* "dependency_injector/providers.pyx":1770 * cpdef object _provide(self, tuple args, dict kwargs): * """Return result of provided callable's call.""" * raise NotImplementedError('Abstract provider forward providing logic ' # <<<<<<<<<<<<<< * 'to overriding provider') * */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1769, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1769, __pyx_L1_error) + __PYX_ERR(1, 1770, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1767 + /* "dependency_injector/providers.pyx":1768 * return super(AbstractFactory, self).override(provider) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -32333,11 +32333,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_15AbstractFactory_5_p case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 1767, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 1768, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 1767, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 1768, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -32350,14 +32350,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_15AbstractFactory_5_p } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1767, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1768, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.AbstractFactory._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 1767, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 1767, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 1768, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 1768, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_15AbstractFactory_4_provide(((struct __pyx_obj_19dependency_injector_9providers_AbstractFactory *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -32378,7 +32378,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_4_p int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_15AbstractFactory__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1767, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_15AbstractFactory__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1768, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -32727,7 +32727,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15AbstractFactory_8__ return __pyx_r; } -/* "dependency_injector/providers.pyx":1783 +/* "dependency_injector/providers.pyx":1784 * """ * * def __init__(self, factory): # <<<<<<<<<<<<<< @@ -32768,7 +32768,7 @@ static int __pyx_pw_19dependency_injector_9providers_15FactoryDelegate_1__init__ else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 1783, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 1784, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; @@ -32779,7 +32779,7 @@ static int __pyx_pw_19dependency_injector_9providers_15FactoryDelegate_1__init__ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1783, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1784, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.FactoryDelegate.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -32810,7 +32810,7 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":1789 + /* "dependency_injector/providers.pyx":1790 * :type factory: object * """ * if isinstance(factory, Factory) is False: # <<<<<<<<<<<<<< @@ -32821,26 +32821,26 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( __pyx_t_2 = ((__pyx_t_1 == 0) != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":1790 + /* "dependency_injector/providers.pyx":1791 * """ * if isinstance(factory, Factory) is False: * raise Error('{0} can wrap only {1} providers'.format( # <<<<<<<<<<<<<< * self.__class__, Factory)) * super(FactoryDelegate, self).__init__(factory) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1790, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_wrap_only_1_providers, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1790, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_wrap_only_1_providers, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "dependency_injector/providers.pyx":1791 + /* "dependency_injector/providers.pyx":1792 * if isinstance(factory, Factory) is False: * raise Error('{0} can wrap only {1} providers'.format( * self.__class__, Factory)) # <<<<<<<<<<<<<< * super(FactoryDelegate, self).__init__(factory) * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1791, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1792, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; @@ -32857,7 +32857,7 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1790, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -32866,14 +32866,14 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1790, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1790, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -32884,7 +32884,7 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory)); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1790, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } @@ -32902,14 +32902,14 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1790, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1791, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 1790, __pyx_L1_error) + __PYX_ERR(1, 1791, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1789 + /* "dependency_injector/providers.pyx":1790 * :type factory: object * """ * if isinstance(factory, Factory) is False: # <<<<<<<<<<<<<< @@ -32918,14 +32918,14 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( */ } - /* "dependency_injector/providers.pyx":1792 + /* "dependency_injector/providers.pyx":1793 * raise Error('{0} can wrap only {1} providers'.format( * self.__class__, Factory)) * super(FactoryDelegate, self).__init__(factory) # <<<<<<<<<<<<<< * * */ - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1792, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryDelegate)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryDelegate)); @@ -32933,10 +32933,10 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1792, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1792, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -32951,12 +32951,12 @@ static int __pyx_pf_19dependency_injector_9providers_15FactoryDelegate___init__( } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_factory) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_factory); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1792, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1793, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1783 + /* "dependency_injector/providers.pyx":1784 * """ * * def __init__(self, factory): # <<<<<<<<<<<<<< @@ -33299,7 +33299,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_15FactoryDelegate_4__ return __pyx_r; } -/* "dependency_injector/providers.pyx":1811 +/* "dependency_injector/providers.pyx":1812 * __IS_DELEGATED__ = True * * def __init__(self, **factories): # <<<<<<<<<<<<<< @@ -33353,22 +33353,22 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":1817 + /* "dependency_injector/providers.pyx":1818 * :type factories: dict[str, :py:class:`Factory`] * """ * for factory in factories.values(): # <<<<<<<<<<<<<< * if isinstance(factory, Factory) is False: * raise Error( */ - __pyx_t_1 = __Pyx_PyDict_Values(__pyx_v_factories); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_Values(__pyx_v_factories); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1818, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -33376,17 +33376,17 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1818, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 1818, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1817, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1818, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -33396,7 +33396,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 1817, __pyx_L1_error) + else __PYX_ERR(1, 1818, __pyx_L1_error) } break; } @@ -33405,7 +33405,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __Pyx_XDECREF_SET(__pyx_v_factory, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1818 + /* "dependency_injector/providers.pyx":1819 * """ * for factory in factories.values(): * if isinstance(factory, Factory) is False: # <<<<<<<<<<<<<< @@ -33416,26 +33416,26 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __pyx_t_6 = ((__pyx_t_5 == 0) != 0); if (unlikely(__pyx_t_6)) { - /* "dependency_injector/providers.pyx":1819 + /* "dependency_injector/providers.pyx":1820 * for factory in factories.values(): * if isinstance(factory, Factory) is False: * raise Error( # <<<<<<<<<<<<<< * '{0} can aggregate only instances of {1}, given - {2}' * .format(self.__class__, Factory, factory)) */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1819, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Error); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "dependency_injector/providers.pyx":1821 + /* "dependency_injector/providers.pyx":1822 * raise Error( * '{0} can aggregate only instances of {1}, given - {2}' * .format(self.__class__, Factory, factory)) # <<<<<<<<<<<<<< * self.__factories = factories * super(FactoryAggregate, self).__init__() */ - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_aggregate_only_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_aggregate_only_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; __pyx_t_12 = 0; @@ -33452,7 +33452,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_t_10, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory), __pyx_v_factory}; - __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; @@ -33461,14 +33461,14 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) { PyObject *__pyx_temp[4] = {__pyx_t_11, __pyx_t_10, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory), __pyx_v_factory}; - __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else #endif { - __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_13 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_11); __pyx_t_11 = NULL; @@ -33482,7 +33482,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __Pyx_GIVEREF(__pyx_v_factory); PyTuple_SET_ITEM(__pyx_t_13, 2+__pyx_t_12, __pyx_v_factory); __pyx_t_10 = 0; - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_13, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1821, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_13, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } @@ -33500,14 +33500,14 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_9, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1819, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1820, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1819, __pyx_L1_error) + __PYX_ERR(1, 1820, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1818 + /* "dependency_injector/providers.pyx":1819 * """ * for factory in factories.values(): * if isinstance(factory, Factory) is False: # <<<<<<<<<<<<<< @@ -33516,7 +33516,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ */ } - /* "dependency_injector/providers.pyx":1817 + /* "dependency_injector/providers.pyx":1818 * :type factories: dict[str, :py:class:`Factory`] * """ * for factory in factories.values(): # <<<<<<<<<<<<<< @@ -33526,7 +33526,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1822 + /* "dependency_injector/providers.pyx":1823 * '{0} can aggregate only instances of {1}, given - {2}' * .format(self.__class__, Factory, factory)) * self.__factories = factories # <<<<<<<<<<<<<< @@ -33539,14 +33539,14 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __Pyx_DECREF(__pyx_v_self->__pyx___factories); __pyx_v_self->__pyx___factories = __pyx_v_factories; - /* "dependency_injector/providers.pyx":1823 + /* "dependency_injector/providers.pyx":1824 * .format(self.__class__, Factory, factory)) * self.__factories = factories * super(FactoryAggregate, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1823, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryAggregate)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryAggregate)); @@ -33554,10 +33554,10 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1823, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1823, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; @@ -33572,12 +33572,12 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ } __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1823, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1824, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1811 + /* "dependency_injector/providers.pyx":1812 * __IS_DELEGATED__ = True * * def __init__(self, **factories): # <<<<<<<<<<<<<< @@ -33605,7 +33605,7 @@ static int __pyx_pf_19dependency_injector_9providers_16FactoryAggregate___init__ return __pyx_r; } -/* "dependency_injector/providers.pyx":1825 +/* "dependency_injector/providers.pyx":1826 * super(FactoryAggregate, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -33643,16 +33643,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":1829 + /* "dependency_injector/providers.pyx":1830 * cdef FactoryAggregate copied * * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1829, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1829, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -33667,14 +33667,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1829, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1830, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_FactoryAggregate))))) __PYX_ERR(1, 1829, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_FactoryAggregate))))) __PYX_ERR(1, 1830, __pyx_L1_error) __pyx_v_copied = ((struct __pyx_obj_19dependency_injector_9providers_FactoryAggregate *)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1830 + /* "dependency_injector/providers.pyx":1831 * * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -33685,7 +33685,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":1831 + /* "dependency_injector/providers.pyx":1832 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -33697,7 +33697,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ __pyx_r = ((PyObject *)__pyx_v_copied); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1830 + /* "dependency_injector/providers.pyx":1831 * * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -33706,14 +33706,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ */ } - /* "dependency_injector/providers.pyx":1833 + /* "dependency_injector/providers.pyx":1834 * return copied * * copied = self.__class__() # <<<<<<<<<<<<<< * copied.__factories = deepcopy(self.__factories, memo) * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1833, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -33727,14 +33727,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1833, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1834, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_FactoryAggregate))))) __PYX_ERR(1, 1833, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_FactoryAggregate))))) __PYX_ERR(1, 1834, __pyx_L1_error) __Pyx_DECREF_SET(__pyx_v_copied, ((struct __pyx_obj_19dependency_injector_9providers_FactoryAggregate *)__pyx_t_1)); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1834 + /* "dependency_injector/providers.pyx":1835 * * copied = self.__class__() * copied.__factories = deepcopy(self.__factories, memo) # <<<<<<<<<<<<<< @@ -33743,30 +33743,30 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ */ __pyx_t_1 = __pyx_v_self->__pyx___factories; __Pyx_INCREF(__pyx_t_1); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1834, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1835, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_1, 0, &__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1834, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_1, 0, &__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(1, 1834, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(1, 1835, __pyx_L1_error) __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_copied->__pyx___factories); __Pyx_DECREF(__pyx_v_copied->__pyx___factories); __pyx_v_copied->__pyx___factories = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1836 + /* "dependency_injector/providers.pyx":1837 * copied.__factories = deepcopy(self.__factories, memo) * * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1836, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1837, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":1838 + /* "dependency_injector/providers.pyx":1839 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -33778,7 +33778,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ __pyx_r = ((PyObject *)__pyx_v_copied); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1825 + /* "dependency_injector/providers.pyx":1826 * super(FactoryAggregate, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -33801,7 +33801,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_2_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1840 +/* "dependency_injector/providers.pyx":1841 * return copied * * def __call__(self, factory_name, *args, **kwargs): # <<<<<<<<<<<<<< @@ -33858,7 +33858,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_16FactoryAggregate_5_ } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__call__") < 0)) __PYX_ERR(1, 1840, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__call__") < 0)) __PYX_ERR(1, 1841, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -33869,7 +33869,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_16FactoryAggregate_5_ } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1840, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__call__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1841, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -33896,7 +33896,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_4_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); - /* "dependency_injector/providers.pyx":1845 + /* "dependency_injector/providers.pyx":1846 * Callable interface implementation. * """ * return self.__get_factory(factory_name)(*args, **kwargs) # <<<<<<<<<<<<<< @@ -33904,17 +33904,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_4_ * def __getattr__(self, factory_name): */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyString_CheckExact(__pyx_v_factory_name))||((__pyx_v_factory_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_factory_name)->tp_name), 0))) __PYX_ERR(1, 1845, __pyx_L1_error) - __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___get_factory(__pyx_v_self, ((PyObject*)__pyx_v_factory_name))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1845, __pyx_L1_error) + if (!(likely(PyString_CheckExact(__pyx_v_factory_name))||((__pyx_v_factory_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_factory_name)->tp_name), 0))) __PYX_ERR(1, 1846, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___get_factory(__pyx_v_self, ((PyObject*)__pyx_v_factory_name))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1845, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1840 + /* "dependency_injector/providers.pyx":1841 * return copied * * def __call__(self, factory_name, *args, **kwargs): # <<<<<<<<<<<<<< @@ -33934,7 +33934,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_4_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1847 +/* "dependency_injector/providers.pyx":1848 * return self.__get_factory(factory_name)(*args, **kwargs) * * def __getattr__(self, factory_name): # <<<<<<<<<<<<<< @@ -33968,7 +33968,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_6_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); - /* "dependency_injector/providers.pyx":1849 + /* "dependency_injector/providers.pyx":1850 * def __getattr__(self, factory_name): * """Return aggregated factory.""" * return self.__get_factory(factory_name) # <<<<<<<<<<<<<< @@ -33976,14 +33976,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_6_ * def __str__(self): */ __Pyx_XDECREF(__pyx_r); - if (!(likely(PyString_CheckExact(__pyx_v_factory_name))||((__pyx_v_factory_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_factory_name)->tp_name), 0))) __PYX_ERR(1, 1849, __pyx_L1_error) - __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___get_factory(__pyx_v_self, ((PyObject*)__pyx_v_factory_name))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1849, __pyx_L1_error) + if (!(likely(PyString_CheckExact(__pyx_v_factory_name))||((__pyx_v_factory_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_v_factory_name)->tp_name), 0))) __PYX_ERR(1, 1850, __pyx_L1_error) + __pyx_t_1 = ((PyObject *)((struct __pyx_vtabstruct_19dependency_injector_9providers_FactoryAggregate *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx___get_factory(__pyx_v_self, ((PyObject*)__pyx_v_factory_name))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1850, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1847 + /* "dependency_injector/providers.pyx":1848 * return self.__get_factory(factory_name)(*args, **kwargs) * * def __getattr__(self, factory_name): # <<<<<<<<<<<<<< @@ -34002,7 +34002,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_6_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1851 +/* "dependency_injector/providers.pyx":1852 * return self.__get_factory(factory_name) * * def __str__(self): # <<<<<<<<<<<<<< @@ -34037,7 +34037,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_8_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "dependency_injector/providers.pyx":1856 + /* "dependency_injector/providers.pyx":1857 * :rtype: str * """ * return represent_provider(provider=self, provides=self.factories) # <<<<<<<<<<<<<< @@ -34045,16 +34045,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_8_ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factories); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1856, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factories); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1856, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1851 + /* "dependency_injector/providers.pyx":1852 * return self.__get_factory(factory_name) * * def __str__(self): # <<<<<<<<<<<<<< @@ -34074,7 +34074,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_8_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1859 +/* "dependency_injector/providers.pyx":1860 * * @property * def factories(self): # <<<<<<<<<<<<<< @@ -34100,7 +34100,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_9f __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1861 + /* "dependency_injector/providers.pyx":1862 * def factories(self): * """Return dictionary of factories, read-only.""" * return self.__factories # <<<<<<<<<<<<<< @@ -34112,7 +34112,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_9f __pyx_r = __pyx_v_self->__pyx___factories; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1859 + /* "dependency_injector/providers.pyx":1860 * * @property * def factories(self): # <<<<<<<<<<<<<< @@ -34127,7 +34127,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_9f return __pyx_r; } -/* "dependency_injector/providers.pyx":1863 +/* "dependency_injector/providers.pyx":1864 * return self.__factories * * def override(self, _): # <<<<<<<<<<<<<< @@ -34163,26 +34163,26 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_10 int __pyx_clineno = 0; __Pyx_RefNannySetupContext("override", 0); - /* "dependency_injector/providers.pyx":1871 + /* "dependency_injector/providers.pyx":1872 * :rtype: :py:class:`OverridingContext` * """ * raise Error( # <<<<<<<<<<<<<< * '{0} providers could not be overridden'.format(self.__class__)) * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1871, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1872, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - /* "dependency_injector/providers.pyx":1872 + /* "dependency_injector/providers.pyx":1873 * """ * raise Error( * '{0} providers could not be overridden'.format(self.__class__)) # <<<<<<<<<<<<<< * * cdef Factory __get_factory(self, str factory_name): */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_providers_could_not_be_overri, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1872, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_providers_could_not_be_overri, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1872, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -34197,7 +34197,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_10 __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1872, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1873, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -34213,14 +34213,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_10 __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1871, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1872, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 1871, __pyx_L1_error) + __PYX_ERR(1, 1872, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1863 + /* "dependency_injector/providers.pyx":1864 * return self.__factories * * def override(self, _): # <<<<<<<<<<<<<< @@ -34243,7 +34243,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_10 return __pyx_r; } -/* "dependency_injector/providers.pyx":1874 +/* "dependency_injector/providers.pyx":1875 * '{0} providers could not be overridden'.format(self.__class__)) * * cdef Factory __get_factory(self, str factory_name): # <<<<<<<<<<<<<< @@ -34268,7 +34268,7 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get_factory", 0); - /* "dependency_injector/providers.pyx":1875 + /* "dependency_injector/providers.pyx":1876 * * cdef Factory __get_factory(self, str factory_name): * if factory_name not in self.__factories: # <<<<<<<<<<<<<< @@ -34277,33 +34277,33 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe */ if (unlikely(__pyx_v_self->__pyx___factories == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 1875, __pyx_L1_error) + __PYX_ERR(1, 1876, __pyx_L1_error) } - __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_v_factory_name, __pyx_v_self->__pyx___factories, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1875, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_v_factory_name, __pyx_v_self->__pyx___factories, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1876, __pyx_L1_error) __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":1876 + /* "dependency_injector/providers.pyx":1877 * cdef Factory __get_factory(self, str factory_name): * if factory_name not in self.__factories: * raise NoSuchProviderError( # <<<<<<<<<<<<<< * '{0} does not contain factory with name {1}'.format( * self, factory_name)) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_NoSuchProviderError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1876, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_NoSuchProviderError); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "dependency_injector/providers.pyx":1877 + /* "dependency_injector/providers.pyx":1878 * if factory_name not in self.__factories: * raise NoSuchProviderError( * '{0} does not contain factory with name {1}'.format( # <<<<<<<<<<<<<< * self, factory_name)) * return self.__factories[factory_name] */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_does_not_contain_factory_with, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1877, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_does_not_contain_factory_with, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "dependency_injector/providers.pyx":1878 + /* "dependency_injector/providers.pyx":1879 * raise NoSuchProviderError( * '{0} does not contain factory with name {1}'.format( * self, factory_name)) # <<<<<<<<<<<<<< @@ -34325,7 +34325,7 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), __pyx_v_factory_name}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1878, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -34333,13 +34333,13 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), __pyx_v_factory_name}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1878, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1877, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -34350,7 +34350,7 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe __Pyx_INCREF(__pyx_v_factory_name); __Pyx_GIVEREF(__pyx_v_factory_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_factory_name); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1877, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1878, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } @@ -34368,14 +34368,14 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1876, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1877, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 1876, __pyx_L1_error) + __PYX_ERR(1, 1877, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1875 + /* "dependency_injector/providers.pyx":1876 * * cdef Factory __get_factory(self, str factory_name): * if factory_name not in self.__factories: # <<<<<<<<<<<<<< @@ -34384,7 +34384,7 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe */ } - /* "dependency_injector/providers.pyx":1879 + /* "dependency_injector/providers.pyx":1880 * '{0} does not contain factory with name {1}'.format( * self, factory_name)) * return self.__factories[factory_name] # <<<<<<<<<<<<<< @@ -34394,16 +34394,16 @@ static struct __pyx_obj_19dependency_injector_9providers_Factory *__pyx_f_19depe __Pyx_XDECREF(((PyObject *)__pyx_r)); if (unlikely(__pyx_v_self->__pyx___factories == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 1879, __pyx_L1_error) + __PYX_ERR(1, 1880, __pyx_L1_error) } - __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___factories, __pyx_v_factory_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1879, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___factories, __pyx_v_factory_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1880, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_3))); __pyx_r = ((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1874 + /* "dependency_injector/providers.pyx":1875 * '{0} providers could not be overridden'.format(self.__class__)) * * cdef Factory __get_factory(self, str factory_name): # <<<<<<<<<<<<<< @@ -34744,7 +34744,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16FactoryAggregate_14 return __pyx_r; } -/* "dependency_injector/providers.pyx":1887 +/* "dependency_injector/providers.pyx":1888 * provided_type = None * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -34801,7 +34801,7 @@ static int __pyx_pw_19dependency_injector_9providers_13BaseSingleton_1__init__(P } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 1887, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 1888, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -34812,7 +34812,7 @@ static int __pyx_pw_19dependency_injector_9providers_13BaseSingleton_1__init__(P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1887, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1888, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -34849,19 +34849,19 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":1893 + /* "dependency_injector/providers.pyx":1894 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< * not issubclass(provides, self.__class__.provided_type)): * raise Error('{0} can provide only {1} instances'.format( */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1893, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1893, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1894, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1893, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1894, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { } else { @@ -34869,25 +34869,25 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st goto __pyx_L4_bool_binop_done; } - /* "dependency_injector/providers.pyx":1894 + /* "dependency_injector/providers.pyx":1895 * """ * 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)) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1894, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1894, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1895, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = PyObject_IsSubclass(__pyx_v_provides, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1894, __pyx_L1_error) + __pyx_t_4 = PyObject_IsSubclass(__pyx_v_provides, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1895, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; - /* "dependency_injector/providers.pyx":1893 + /* "dependency_injector/providers.pyx":1894 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< @@ -34896,30 +34896,30 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st */ if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":1895 + /* "dependency_injector/providers.pyx":1896 * 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)) * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1895, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_provide_only_1_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1895, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_provide_only_1_instances, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - /* "dependency_injector/providers.pyx":1896 + /* "dependency_injector/providers.pyx":1897 * not issubclass(provides, self.__class__.provided_type)): * raise Error('{0} can provide only {1} instances'.format( * self.__class__, self.__class__.provided_type)) # <<<<<<<<<<<<<< * * self.__instantiator = Factory(provides, *args, **kwargs) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1896, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1896, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1896, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_provided_type); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1897, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = NULL; @@ -34937,7 +34937,7 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; - __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1895, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -34947,7 +34947,7 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_8, __pyx_t_10}; - __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1895, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -34955,7 +34955,7 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st } else #endif { - __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1895, __pyx_L1_error) + __pyx_t_12 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_9); __pyx_t_9 = NULL; @@ -34966,7 +34966,7 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_10); __pyx_t_8 = 0; __pyx_t_10 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1895, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } @@ -34984,14 +34984,14 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1895, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1896, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 1895, __pyx_L1_error) + __PYX_ERR(1, 1896, __pyx_L1_error) - /* "dependency_injector/providers.pyx":1893 + /* "dependency_injector/providers.pyx":1894 * :type provides: type * """ * if (self.__class__.provided_type and # <<<<<<<<<<<<<< @@ -35000,22 +35000,22 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st */ } - /* "dependency_injector/providers.pyx":1898 + /* "dependency_injector/providers.pyx":1899 * self.__class__, self.__class__.provided_type)) * * self.__instantiator = Factory(provides, *args, **kwargs) # <<<<<<<<<<<<<< * * super(BaseSingleton, self).__init__() */ - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1898, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_provides); __Pyx_GIVEREF(__pyx_v_provides); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_provides); - __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1898, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory), __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1898, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory), __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1899, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GIVEREF(__pyx_t_2); @@ -35024,14 +35024,14 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st __pyx_v_self->__pyx___instantiator = ((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1900 + /* "dependency_injector/providers.pyx":1901 * self.__instantiator = Factory(provides, *args, **kwargs) * * super(BaseSingleton, self).__init__() # <<<<<<<<<<<<<< * * def __str__(self): */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1900, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); @@ -35039,10 +35039,10 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1900, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1900, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -35057,12 +35057,12 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st } __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1900, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1901, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1887 + /* "dependency_injector/providers.pyx":1888 * provided_type = None * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -35089,7 +35089,7 @@ static int __pyx_pf_19dependency_injector_9providers_13BaseSingleton___init__(st return __pyx_r; } -/* "dependency_injector/providers.pyx":1902 +/* "dependency_injector/providers.pyx":1903 * super(BaseSingleton, self).__init__() * * def __str__(self): # <<<<<<<<<<<<<< @@ -35124,7 +35124,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_2__st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "dependency_injector/providers.pyx":1907 + /* "dependency_injector/providers.pyx":1908 * :rtype: str * """ * return represent_provider(provider=self, # <<<<<<<<<<<<<< @@ -35133,31 +35133,31 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_2__st */ __Pyx_XDECREF(__pyx_r); - /* "dependency_injector/providers.pyx":1908 + /* "dependency_injector/providers.pyx":1909 * """ * return represent_provider(provider=self, * provides=self.__instantiator.cls) # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1908, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1909, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":1907 + /* "dependency_injector/providers.pyx":1908 * :rtype: str * """ * return represent_provider(provider=self, # <<<<<<<<<<<<<< * provides=self.__instantiator.cls) * */ - __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1907, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1908, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1902 + /* "dependency_injector/providers.pyx":1903 * super(BaseSingleton, self).__init__() * * def __str__(self): # <<<<<<<<<<<<<< @@ -35177,7 +35177,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_2__st return __pyx_r; } -/* "dependency_injector/providers.pyx":1910 +/* "dependency_injector/providers.pyx":1911 * provides=self.__instantiator.cls) * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -35217,16 +35217,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":1912 + /* "dependency_injector/providers.pyx":1913 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1912, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1912, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -35241,13 +35241,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1912, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1913 + /* "dependency_injector/providers.pyx":1914 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -35258,7 +35258,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":1914 + /* "dependency_injector/providers.pyx":1915 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -35270,7 +35270,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1913 + /* "dependency_injector/providers.pyx":1914 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -35279,19 +35279,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de */ } - /* "dependency_injector/providers.pyx":1916 + /* "dependency_injector/providers.pyx":1917 * return copied * * cls = self.cls # <<<<<<<<<<<<<< * if isinstance(cls, Provider): * cls = deepcopy(cls, memo) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1916, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1917, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_cls = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1917 + /* "dependency_injector/providers.pyx":1918 * * cls = self.cls * if isinstance(cls, Provider): # <<<<<<<<<<<<<< @@ -35302,22 +35302,22 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __pyx_t_5 = (__pyx_t_6 != 0); if (__pyx_t_5) { - /* "dependency_injector/providers.pyx":1918 + /* "dependency_injector/providers.pyx":1919 * cls = self.cls * if isinstance(cls, Provider): * cls = deepcopy(cls, memo) # <<<<<<<<<<<<<< * * copied = self.__class__(cls, */ - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1918, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1919, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_cls, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1918, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_cls, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1919, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF_SET(__pyx_v_cls, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1917 + /* "dependency_injector/providers.pyx":1918 * * cls = self.cls * if isinstance(cls, Provider): # <<<<<<<<<<<<<< @@ -35326,89 +35326,89 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de */ } - /* "dependency_injector/providers.pyx":1920 + /* "dependency_injector/providers.pyx":1921 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_cls); __Pyx_GIVEREF(__pyx_v_cls); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_cls); - /* "dependency_injector/providers.pyx":1921 + /* "dependency_injector/providers.pyx":1922 * * copied = self.__class__(cls, * *deepcopy(self.args, memo), # <<<<<<<<<<<<<< * **deepcopy(self.kwargs, memo)) * copied.set_attributes(**deepcopy(self.attributes, memo)) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1921, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1922, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1921, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1922, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1921, __pyx_L1_error) + __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1922, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1920 + /* "dependency_injector/providers.pyx":1921 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_3 = __Pyx_PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":1922 + /* "dependency_injector/providers.pyx":1923 * copied = self.__class__(cls, * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) # <<<<<<<<<<<<<< * copied.set_attributes(**deepcopy(self.attributes, memo)) * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1922, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1922, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1923, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1922, __pyx_L1_error) + __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(__pyx_t_8 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 1922, __pyx_L1_error) + __PYX_ERR(1, 1923, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_8))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1922, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1923, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - /* "dependency_injector/providers.pyx":1920 + /* "dependency_injector/providers.pyx":1921 * cls = deepcopy(cls, memo) * * copied = self.__class__(cls, # <<<<<<<<<<<<<< * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1920, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1921, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -35416,54 +35416,54 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __Pyx_DECREF_SET(__pyx_v_copied, __pyx_t_8); __pyx_t_8 = 0; - /* "dependency_injector/providers.pyx":1923 + /* "dependency_injector/providers.pyx":1924 * *deepcopy(self.args, memo), * **deepcopy(self.kwargs, memo)) * copied.set_attributes(**deepcopy(self.attributes, memo)) # <<<<<<<<<<<<<< * * self._copy_overridings(copied, memo) */ - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_copied, __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_copied, __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attributes); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_attributes); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1923, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1924, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 1923, __pyx_L1_error) + __PYX_ERR(1, 1924, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_1))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1923, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1924, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1925 + /* "dependency_injector/providers.pyx":1926 * copied.set_attributes(**deepcopy(self.attributes, memo)) * * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 1925, __pyx_L1_error) - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1925, __pyx_L1_error) + if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 1926, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 1926, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_BaseSingleton *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":1927 + /* "dependency_injector/providers.pyx":1928 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -35475,7 +35475,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1910 + /* "dependency_injector/providers.pyx":1911 * provides=self.__instantiator.cls) * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -35500,7 +35500,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4__de return __pyx_r; } -/* "dependency_injector/providers.pyx":1930 +/* "dependency_injector/providers.pyx":1931 * * @property * def cls(self): # <<<<<<<<<<<<<< @@ -35530,7 +35530,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_3cls_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1932 + /* "dependency_injector/providers.pyx":1933 * def cls(self): * """Return provided type.""" * return self.__instantiator.cls # <<<<<<<<<<<<<< @@ -35538,13 +35538,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_3cls_ * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1932, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_cls); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1933, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1930 + /* "dependency_injector/providers.pyx":1931 * * @property * def cls(self): # <<<<<<<<<<<<<< @@ -35563,7 +35563,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_3cls_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1935 +/* "dependency_injector/providers.pyx":1936 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -35593,7 +35593,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4args int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1937 + /* "dependency_injector/providers.pyx":1938 * def args(self): * """Return positional argument injections.""" * return self.__instantiator.args # <<<<<<<<<<<<<< @@ -35601,13 +35601,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4args * def add_args(self, *args): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1937, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1935 + /* "dependency_injector/providers.pyx":1936 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -35626,7 +35626,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_4args return __pyx_r; } -/* "dependency_injector/providers.pyx":1939 +/* "dependency_injector/providers.pyx":1940 * return self.__instantiator.args * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -35663,21 +35663,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6add_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_args", 0); - /* "dependency_injector/providers.pyx":1944 + /* "dependency_injector/providers.pyx":1945 * :return: Reference ``self`` * """ * self.__instantiator.add_args(*args) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1944, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1944, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1945 + /* "dependency_injector/providers.pyx":1946 * """ * self.__instantiator.add_args(*args) * return self # <<<<<<<<<<<<<< @@ -35689,7 +35689,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6add_ __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1939 + /* "dependency_injector/providers.pyx":1940 * return self.__instantiator.args * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -35709,7 +35709,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6add_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1947 +/* "dependency_injector/providers.pyx":1948 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -35746,21 +35746,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_8set_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_args", 0); - /* "dependency_injector/providers.pyx":1954 + /* "dependency_injector/providers.pyx":1955 * :return: Reference ``self`` * """ * self.__instantiator.set_args(*args) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1954, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1954, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1955, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1955 + /* "dependency_injector/providers.pyx":1956 * """ * self.__instantiator.set_args(*args) * return self # <<<<<<<<<<<<<< @@ -35772,7 +35772,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_8set_ __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1947 + /* "dependency_injector/providers.pyx":1948 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -35792,7 +35792,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_8set_ return __pyx_r; } -/* "dependency_injector/providers.pyx":1957 +/* "dependency_injector/providers.pyx":1958 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -35825,14 +35825,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10cle int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_args", 0); - /* "dependency_injector/providers.pyx":1962 + /* "dependency_injector/providers.pyx":1963 * :return: Reference ``self`` * """ * self.__instantiator.clear_args() # <<<<<<<<<<<<<< * return self * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1962, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -35846,12 +35846,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10cle } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1962, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1963 + /* "dependency_injector/providers.pyx":1964 * """ * self.__instantiator.clear_args() * return self # <<<<<<<<<<<<<< @@ -35863,7 +35863,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10cle __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1957 + /* "dependency_injector/providers.pyx":1958 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -35884,7 +35884,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10cle return __pyx_r; } -/* "dependency_injector/providers.pyx":1966 +/* "dependency_injector/providers.pyx":1967 * * @property * def kwargs(self): # <<<<<<<<<<<<<< @@ -35914,7 +35914,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6kwar int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1968 + /* "dependency_injector/providers.pyx":1969 * def kwargs(self): * """Return keyword argument injections.""" * return self.__instantiator.kwargs # <<<<<<<<<<<<<< @@ -35922,13 +35922,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6kwar * def add_kwargs(self, **kwargs): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1968, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1966 + /* "dependency_injector/providers.pyx":1967 * * @property * def kwargs(self): # <<<<<<<<<<<<<< @@ -35947,7 +35947,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_6kwar return __pyx_r; } -/* "dependency_injector/providers.pyx":1970 +/* "dependency_injector/providers.pyx":1971 * return self.__instantiator.kwargs * * def add_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -35990,21 +35990,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_12add int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_kwargs", 0); - /* "dependency_injector/providers.pyx":1975 + /* "dependency_injector/providers.pyx":1976 * :return: Reference ``self`` * """ * self.__instantiator.add_kwargs(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1975, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1975, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1976, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1976 + /* "dependency_injector/providers.pyx":1977 * """ * self.__instantiator.add_kwargs(**kwargs) * return self # <<<<<<<<<<<<<< @@ -36016,7 +36016,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_12add __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1970 + /* "dependency_injector/providers.pyx":1971 * return self.__instantiator.kwargs * * def add_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -36036,7 +36036,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_12add return __pyx_r; } -/* "dependency_injector/providers.pyx":1978 +/* "dependency_injector/providers.pyx":1979 * return self * * def set_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -36079,21 +36079,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_14set int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_kwargs", 0); - /* "dependency_injector/providers.pyx":1985 + /* "dependency_injector/providers.pyx":1986 * :return: Reference ``self`` * """ * self.__instantiator.set_kwargs(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1985, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1986, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1985, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1986, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":1986 + /* "dependency_injector/providers.pyx":1987 * """ * self.__instantiator.set_kwargs(**kwargs) * return self # <<<<<<<<<<<<<< @@ -36105,7 +36105,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_14set __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1978 + /* "dependency_injector/providers.pyx":1979 * return self * * def set_kwargs(self, **kwargs): # <<<<<<<<<<<<<< @@ -36125,7 +36125,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_14set return __pyx_r; } -/* "dependency_injector/providers.pyx":1988 +/* "dependency_injector/providers.pyx":1989 * return self * * def clear_kwargs(self): # <<<<<<<<<<<<<< @@ -36158,14 +36158,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_16cle int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_kwargs", 0); - /* "dependency_injector/providers.pyx":1993 + /* "dependency_injector/providers.pyx":1994 * :return: Reference ``self`` * """ * self.__instantiator.clear_kwargs() # <<<<<<<<<<<<<< * return self * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1993, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1994, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -36179,12 +36179,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_16cle } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1993, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1994, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":1994 + /* "dependency_injector/providers.pyx":1995 * """ * self.__instantiator.clear_kwargs() * return self # <<<<<<<<<<<<<< @@ -36196,7 +36196,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_16cle __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":1988 + /* "dependency_injector/providers.pyx":1989 * return self * * def clear_kwargs(self): # <<<<<<<<<<<<<< @@ -36217,7 +36217,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_16cle return __pyx_r; } -/* "dependency_injector/providers.pyx":1997 +/* "dependency_injector/providers.pyx":1998 * * @property * def attributes(self): # <<<<<<<<<<<<<< @@ -36247,7 +36247,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10att int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":1999 + /* "dependency_injector/providers.pyx":2000 * def attributes(self): * """Return attribute injections.""" * return self.__instantiator.attributes # <<<<<<<<<<<<<< @@ -36255,13 +36255,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10att * def add_attributes(self, **kwargs): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1999, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2000, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":1997 + /* "dependency_injector/providers.pyx":1998 * * @property * def attributes(self): # <<<<<<<<<<<<<< @@ -36280,7 +36280,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_10att return __pyx_r; } -/* "dependency_injector/providers.pyx":2001 +/* "dependency_injector/providers.pyx":2002 * return self.__instantiator.attributes * * def add_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -36323,21 +36323,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_18add int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_attributes", 0); - /* "dependency_injector/providers.pyx":2006 + /* "dependency_injector/providers.pyx":2007 * :return: Reference ``self`` * """ * self.__instantiator.add_attributes(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2006, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_add_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2006, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2007, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2007 + /* "dependency_injector/providers.pyx":2008 * """ * self.__instantiator.add_attributes(**kwargs) * return self # <<<<<<<<<<<<<< @@ -36349,7 +36349,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_18add __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2001 + /* "dependency_injector/providers.pyx":2002 * return self.__instantiator.attributes * * def add_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -36369,7 +36369,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_18add return __pyx_r; } -/* "dependency_injector/providers.pyx":2009 +/* "dependency_injector/providers.pyx":2010 * return self * * def set_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -36412,21 +36412,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_20set int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_attributes", 0); - /* "dependency_injector/providers.pyx":2016 + /* "dependency_injector/providers.pyx":2017 * :return: Reference ``self`` * """ * self.__instantiator.set_attributes(**kwargs) # <<<<<<<<<<<<<< * return self * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2016, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_set_attributes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2016, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2017, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2017 + /* "dependency_injector/providers.pyx":2018 * """ * self.__instantiator.set_attributes(**kwargs) * return self # <<<<<<<<<<<<<< @@ -36438,7 +36438,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_20set __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2009 + /* "dependency_injector/providers.pyx":2010 * return self * * def set_attributes(self, **kwargs): # <<<<<<<<<<<<<< @@ -36458,7 +36458,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_20set return __pyx_r; } -/* "dependency_injector/providers.pyx":2019 +/* "dependency_injector/providers.pyx":2020 * return self * * def clear_attributes(self): # <<<<<<<<<<<<<< @@ -36491,14 +36491,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_22cle int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_attributes", 0); - /* "dependency_injector/providers.pyx":2024 + /* "dependency_injector/providers.pyx":2025 * :return: Reference ``self`` * """ * self.__instantiator.clear_attributes() # <<<<<<<<<<<<<< * return self * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_attributes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2024, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx___instantiator), __pyx_n_s_clear_attributes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -36512,12 +36512,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_22cle } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2024, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2025, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2025 + /* "dependency_injector/providers.pyx":2026 * """ * self.__instantiator.clear_attributes() * return self # <<<<<<<<<<<<<< @@ -36529,7 +36529,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_22cle __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2019 + /* "dependency_injector/providers.pyx":2020 * return self * * def clear_attributes(self): # <<<<<<<<<<<<<< @@ -36550,7 +36550,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_22cle return __pyx_r; } -/* "dependency_injector/providers.pyx":2027 +/* "dependency_injector/providers.pyx":2028 * return self * * def reset(self): # <<<<<<<<<<<<<< @@ -36581,20 +36581,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_24res int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset", 0); - /* "dependency_injector/providers.pyx":2032 + /* "dependency_injector/providers.pyx":2033 * :rtype: None * """ * raise NotImplementedError() # <<<<<<<<<<<<<< * * */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_NotImplementedError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2032, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_NotImplementedError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2033, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2032, __pyx_L1_error) + __PYX_ERR(1, 2033, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2027 + /* "dependency_injector/providers.pyx":2028 * return self * * def reset(self): # <<<<<<<<<<<<<< @@ -36929,7 +36929,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_13BaseSingleton_28__s return __pyx_r; } -/* "dependency_injector/providers.pyx":2067 +/* "dependency_injector/providers.pyx":2068 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -36986,7 +36986,7 @@ static int __pyx_pw_19dependency_injector_9providers_9Singleton_1__init__(PyObje } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2067, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2068, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -36997,7 +36997,7 @@ static int __pyx_pw_19dependency_injector_9providers_9Singleton_1__init__(PyObje } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2067, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2068, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -37025,7 +37025,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Singleton___init__(struct int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2073 + /* "dependency_injector/providers.pyx":2074 * :type provides: type * """ * self.__storage = None # <<<<<<<<<<<<<< @@ -37038,14 +37038,14 @@ static int __pyx_pf_19dependency_injector_9providers_9Singleton___init__(struct __Pyx_DECREF(__pyx_v_self->__pyx___storage); __pyx_v_self->__pyx___storage = Py_None; - /* "dependency_injector/providers.pyx":2074 + /* "dependency_injector/providers.pyx":2075 * """ * self.__storage = None * super(Singleton, self).__init__(provides, *args, **kwargs) # <<<<<<<<<<<<<< * * def reset(self): */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Singleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Singleton)); @@ -37053,27 +37053,27 @@ static int __pyx_pf_19dependency_injector_9providers_9Singleton___init__(struct __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_provides); __Pyx_GIVEREF(__pyx_v_provides); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_provides); - __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2074, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2075, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2067 + /* "dependency_injector/providers.pyx":2068 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -37095,7 +37095,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Singleton___init__(struct return __pyx_r; } -/* "dependency_injector/providers.pyx":2076 +/* "dependency_injector/providers.pyx":2077 * super(Singleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -37122,7 +37122,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Singleton_2reset(str __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("reset", 0); - /* "dependency_injector/providers.pyx":2081 + /* "dependency_injector/providers.pyx":2082 * :rtype: None * """ * self.__storage = None # <<<<<<<<<<<<<< @@ -37135,7 +37135,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Singleton_2reset(str __Pyx_DECREF(__pyx_v_self->__pyx___storage); __pyx_v_self->__pyx___storage = Py_None; - /* "dependency_injector/providers.pyx":2076 + /* "dependency_injector/providers.pyx":2077 * super(Singleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -37150,7 +37150,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Singleton_2reset(str return __pyx_r; } -/* "dependency_injector/providers.pyx":2083 +/* "dependency_injector/providers.pyx":2084 * self.__storage = None * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -37183,7 +37183,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_9Singleton_5_provide)) { __Pyx_XDECREF(__pyx_r); @@ -37203,7 +37203,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -37211,13 +37211,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -37228,7 +37228,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -37251,7 +37251,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st #endif } - /* "dependency_injector/providers.pyx":2085 + /* "dependency_injector/providers.pyx":2086 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * if self.__storage is None: # <<<<<<<<<<<<<< @@ -37262,7 +37262,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st __pyx_t_8 = (__pyx_t_7 != 0); if (__pyx_t_8) { - /* "dependency_injector/providers.pyx":2086 + /* "dependency_injector/providers.pyx":2087 * """Return single instance.""" * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, # <<<<<<<<<<<<<< @@ -37272,18 +37272,18 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx___instantiator); __Pyx_INCREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2087 + /* "dependency_injector/providers.pyx":2088 * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, * args, kwargs) # <<<<<<<<<<<<<< * return self.__storage * */ - __pyx_t_2 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_1), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2086, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_1), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2087, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2086 + /* "dependency_injector/providers.pyx":2087 * """Return single instance.""" * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, # <<<<<<<<<<<<<< @@ -37296,7 +37296,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st __pyx_v_self->__pyx___storage = __pyx_t_2; __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2085 + /* "dependency_injector/providers.pyx":2086 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * if self.__storage is None: # <<<<<<<<<<<<<< @@ -37305,7 +37305,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st */ } - /* "dependency_injector/providers.pyx":2088 + /* "dependency_injector/providers.pyx":2089 * self.__storage = __factory_call(self.__instantiator, * args, kwargs) * return self.__storage # <<<<<<<<<<<<<< @@ -37317,7 +37317,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Singleton__provide(st __pyx_r = __pyx_v_self->__pyx___storage; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2083 + /* "dependency_injector/providers.pyx":2084 * self.__storage = None * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -37375,11 +37375,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_9Singleton_5_provide( case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2083, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2084, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2083, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2084, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -37392,14 +37392,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_9Singleton_5_provide( } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2083, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2084, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Singleton._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2083, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2083, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2084, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2084, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_9Singleton_4_provide(((struct __pyx_obj_19dependency_injector_9providers_Singleton *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -37420,7 +37420,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Singleton_4_provide( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_9Singleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2083, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_9Singleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2084, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -38091,7 +38091,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_18DelegatedSingleton_ return __pyx_r; } -/* "dependency_injector/providers.pyx":2122 +/* "dependency_injector/providers.pyx":2123 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -38148,7 +38148,7 @@ static int __pyx_pw_19dependency_injector_9providers_19ThreadSafeSingleton_1__in } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2122, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2123, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -38159,7 +38159,7 @@ static int __pyx_pw_19dependency_injector_9providers_19ThreadSafeSingleton_1__in } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2122, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2123, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -38187,7 +38187,7 @@ static int __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton___ini int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2128 + /* "dependency_injector/providers.pyx":2129 * :type provides: type * """ * self.__storage = None # <<<<<<<<<<<<<< @@ -38200,16 +38200,16 @@ static int __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton___ini __Pyx_DECREF(__pyx_v_self->__pyx___storage); __pyx_v_self->__pyx___storage = Py_None; - /* "dependency_injector/providers.pyx":2129 + /* "dependency_injector/providers.pyx":2130 * """ * self.__storage = None * self.__storage_lock = self.__class__.storage_lock # <<<<<<<<<<<<<< * super(ThreadSafeSingleton, self).__init__(provides, *args, **kwargs) * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2129, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_storage_lock); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2129, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_storage_lock); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2130, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_2); @@ -38218,14 +38218,14 @@ static int __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton___ini __pyx_v_self->__pyx___storage_lock = __pyx_t_2; __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2130 + /* "dependency_injector/providers.pyx":2131 * self.__storage = None * self.__storage_lock = self.__class__.storage_lock * super(ThreadSafeSingleton, self).__init__(provides, *args, **kwargs) # <<<<<<<<<<<<<< * * def reset(self): */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton)); @@ -38233,27 +38233,27 @@ static int __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton___ini __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_provides); __Pyx_GIVEREF(__pyx_v_provides); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_provides); - __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2130, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2131, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2122 + /* "dependency_injector/providers.pyx":2123 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -38275,7 +38275,7 @@ static int __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton___ini return __pyx_r; } -/* "dependency_injector/providers.pyx":2132 +/* "dependency_injector/providers.pyx":2133 * super(ThreadSafeSingleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -38302,7 +38302,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("reset", 0); - /* "dependency_injector/providers.pyx":2137 + /* "dependency_injector/providers.pyx":2138 * :rtype: None * """ * self.__storage = None # <<<<<<<<<<<<<< @@ -38315,7 +38315,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton __Pyx_DECREF(__pyx_v_self->__pyx___storage); __pyx_v_self->__pyx___storage = Py_None; - /* "dependency_injector/providers.pyx":2132 + /* "dependency_injector/providers.pyx":2133 * super(ThreadSafeSingleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -38330,7 +38330,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton return __pyx_r; } -/* "dependency_injector/providers.pyx":2139 +/* "dependency_injector/providers.pyx":2140 * self.__storage = None * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -38368,7 +38368,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_19ThreadSafeSingleton_5_provide)) { __Pyx_XDECREF(__pyx_r); @@ -38388,7 +38388,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -38396,13 +38396,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -38413,7 +38413,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -38436,7 +38436,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ #endif } - /* "dependency_injector/providers.pyx":2141 + /* "dependency_injector/providers.pyx":2142 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * with self.__storage_lock: # <<<<<<<<<<<<<< @@ -38444,9 +38444,9 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ * self.__storage = __factory_call(self.__instantiator, */ /*with:*/ { - __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->__pyx___storage_lock, __pyx_n_s_exit); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2141, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->__pyx___storage_lock, __pyx_n_s_exit); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); - __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->__pyx___storage_lock, __pyx_n_s_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2141, __pyx_L3_error) + __pyx_t_2 = __Pyx_PyObject_LookupSpecial(__pyx_v_self->__pyx___storage_lock, __pyx_n_s_enter); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2142, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -38460,7 +38460,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2141, __pyx_L3_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2142, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38474,7 +38474,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "dependency_injector/providers.pyx":2142 + /* "dependency_injector/providers.pyx":2143 * """Return single instance.""" * with self.__storage_lock: * if self.__storage is None: # <<<<<<<<<<<<<< @@ -38485,7 +38485,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { - /* "dependency_injector/providers.pyx":2143 + /* "dependency_injector/providers.pyx":2144 * with self.__storage_lock: * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, # <<<<<<<<<<<<<< @@ -38495,18 +38495,18 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __pyx_t_1 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx___instantiator); __Pyx_INCREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2144 + /* "dependency_injector/providers.pyx":2145 * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, * args, kwargs) # <<<<<<<<<<<<<< * return self.__storage * */ - __pyx_t_2 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_1), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2143, __pyx_L7_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_1), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2144, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2143 + /* "dependency_injector/providers.pyx":2144 * with self.__storage_lock: * if self.__storage is None: * self.__storage = __factory_call(self.__instantiator, # <<<<<<<<<<<<<< @@ -38519,7 +38519,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __pyx_v_self->__pyx___storage = __pyx_t_2; __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2142 + /* "dependency_injector/providers.pyx":2143 * """Return single instance.""" * with self.__storage_lock: * if self.__storage is None: # <<<<<<<<<<<<<< @@ -38528,7 +38528,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ */ } - /* "dependency_injector/providers.pyx":2141 + /* "dependency_injector/providers.pyx":2142 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * with self.__storage_lock: # <<<<<<<<<<<<<< @@ -38548,20 +38548,20 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /*except:*/ { __Pyx_AddTraceback("dependency_injector.providers.ThreadSafeSingleton._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_3) < 0) __PYX_ERR(1, 2141, __pyx_L9_except_error) + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_3) < 0) __PYX_ERR(1, 2142, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2141, __pyx_L9_except_error) + __pyx_t_6 = PyTuple_Pack(3, __pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2142, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 2141, __pyx_L9_except_error) + if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 2142, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - if (__pyx_t_12 < 0) __PYX_ERR(1, 2141, __pyx_L9_except_error) + if (__pyx_t_12 < 0) __PYX_ERR(1, 2142, __pyx_L9_except_error) __pyx_t_11 = ((!(__pyx_t_12 != 0)) != 0); if (__pyx_t_11) { __Pyx_GIVEREF(__pyx_t_2); @@ -38569,7 +38569,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_1, __pyx_t_3); __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_3 = 0; - __PYX_ERR(1, 2141, __pyx_L9_except_error) + __PYX_ERR(1, 2142, __pyx_L9_except_error) } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -38595,7 +38595,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ if (__pyx_t_7) { __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_tuple__2, NULL); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2141, __pyx_L1_error) + if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2142, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } @@ -38610,7 +38610,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __pyx_L17:; } - /* "dependency_injector/providers.pyx":2145 + /* "dependency_injector/providers.pyx":2146 * self.__storage = __factory_call(self.__instantiator, * args, kwargs) * return self.__storage # <<<<<<<<<<<<<< @@ -38622,7 +38622,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton_ __pyx_r = __pyx_v_self->__pyx___storage; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2139 + /* "dependency_injector/providers.pyx":2140 * self.__storage = None * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -38680,11 +38680,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_19ThreadSafeSingleton case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2139, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2140, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2139, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2140, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -38697,14 +38697,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_19ThreadSafeSingleton } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2139, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2140, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.ThreadSafeSingleton._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2139, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2139, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2140, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2140, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton_4_provide(((struct __pyx_obj_19dependency_injector_9providers_ThreadSafeSingleton *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -38725,7 +38725,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19ThreadSafeSingleton int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2139, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -39416,7 +39416,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_28DelegatedThreadSafe return __pyx_r; } -/* "dependency_injector/providers.pyx":2189 +/* "dependency_injector/providers.pyx":2190 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -39473,7 +39473,7 @@ static int __pyx_pw_19dependency_injector_9providers_20ThreadLocalSingleton_1__i } if (unlikely(kw_args > 0)) { const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2189, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 2190, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) < 1) { goto __pyx_L5_argtuple_error; @@ -39484,7 +39484,7 @@ static int __pyx_pw_19dependency_injector_9providers_20ThreadLocalSingleton_1__i } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2189, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2190, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0; __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; @@ -39512,16 +39512,16 @@ static int __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton___in int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2195 + /* "dependency_injector/providers.pyx":2196 * :type provides: type * """ * self.__storage = threading.local() # <<<<<<<<<<<<<< * super(ThreadLocalSingleton, self).__init__(provides, *args, **kwargs) * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2195, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_local); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2195, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_local); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -39536,7 +39536,7 @@ static int __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton___in } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2195, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2196, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GIVEREF(__pyx_t_1); @@ -39545,14 +39545,14 @@ static int __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton___in __pyx_v_self->__pyx___storage = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2196 + /* "dependency_injector/providers.pyx":2197 * """ * self.__storage = threading.local() * super(ThreadLocalSingleton, self).__init__(provides, *args, **kwargs) # <<<<<<<<<<<<<< * * def reset(self): */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadLocalSingleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadLocalSingleton)); @@ -39560,27 +39560,27 @@ static int __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton___in __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_provides); __Pyx_GIVEREF(__pyx_v_provides); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_provides); - __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2196, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2189 + /* "dependency_injector/providers.pyx":2190 * """ * * def __init__(self, provides, *args, **kwargs): # <<<<<<<<<<<<<< @@ -39602,7 +39602,7 @@ static int __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton___in return __pyx_r; } -/* "dependency_injector/providers.pyx":2198 +/* "dependency_injector/providers.pyx":2199 * super(ThreadLocalSingleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -39632,16 +39632,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleto int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset", 0); - /* "dependency_injector/providers.pyx":2203 + /* "dependency_injector/providers.pyx":2204 * :rtype: None * """ * del self.__storage.instance # <<<<<<<<<<<<<< * * cpdef object _provide(self, tuple args, dict kwargs): */ - if (__Pyx_PyObject_DelAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance) < 0) __PYX_ERR(1, 2203, __pyx_L1_error) + if (__Pyx_PyObject_DelAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance) < 0) __PYX_ERR(1, 2204, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2198 + /* "dependency_injector/providers.pyx":2199 * super(ThreadLocalSingleton, self).__init__(provides, *args, **kwargs) * * def reset(self): # <<<<<<<<<<<<<< @@ -39661,7 +39661,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleto return __pyx_r; } -/* "dependency_injector/providers.pyx":2205 +/* "dependency_injector/providers.pyx":2206 * del self.__storage.instance * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -39699,7 +39699,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_20ThreadLocalSingleton_5_provide)) { __Pyx_XDECREF(__pyx_r); @@ -39719,7 +39719,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -39727,13 +39727,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -39744,7 +39744,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -39767,7 +39767,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton #endif } - /* "dependency_injector/providers.pyx":2209 + /* "dependency_injector/providers.pyx":2210 * cdef object instance * * try: # <<<<<<<<<<<<<< @@ -39784,19 +39784,19 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { - /* "dependency_injector/providers.pyx":2210 + /* "dependency_injector/providers.pyx":2211 * * try: * instance = self.__storage.instance # <<<<<<<<<<<<<< * except AttributeError: * instance = __factory_call(self.__instantiator, args, kwargs) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2210, __pyx_L6_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2211, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_instance = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2209 + /* "dependency_injector/providers.pyx":2210 * cdef object instance * * try: # <<<<<<<<<<<<<< @@ -39815,7 +39815,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2211 + /* "dependency_injector/providers.pyx":2212 * try: * instance = self.__storage.instance * except AttributeError: # <<<<<<<<<<<<<< @@ -39825,12 +39825,12 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError); if (__pyx_t_5) { __Pyx_AddTraceback("dependency_injector.providers.ThreadLocalSingleton._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(1, 2211, __pyx_L8_except_error) + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(1, 2212, __pyx_L8_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_3); - /* "dependency_injector/providers.pyx":2212 + /* "dependency_injector/providers.pyx":2213 * instance = self.__storage.instance * except AttributeError: * instance = __factory_call(self.__instantiator, args, kwargs) # <<<<<<<<<<<<<< @@ -39839,20 +39839,20 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton */ __pyx_t_6 = ((PyObject *)__pyx_v_self->__pyx_base.__pyx___instantiator); __Pyx_INCREF(__pyx_t_6); - __pyx_t_4 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_6), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2212, __pyx_L8_except_error) + __pyx_t_4 = __pyx_f_19dependency_injector_9providers___factory_call(((struct __pyx_obj_19dependency_injector_9providers_Factory *)__pyx_t_6), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2213, __pyx_L8_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_instance, __pyx_t_4); __pyx_t_4 = 0; - /* "dependency_injector/providers.pyx":2213 + /* "dependency_injector/providers.pyx":2214 * except AttributeError: * instance = __factory_call(self.__instantiator, args, kwargs) * self.__storage.instance = instance # <<<<<<<<<<<<<< * finally: * return instance */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance, __pyx_v_instance) < 0) __PYX_ERR(1, 2213, __pyx_L8_except_error) + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self->__pyx___storage, __pyx_n_s_instance, __pyx_v_instance) < 0) __PYX_ERR(1, 2214, __pyx_L8_except_error) __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -39861,7 +39861,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton goto __pyx_L8_except_error; __pyx_L8_except_error:; - /* "dependency_injector/providers.pyx":2209 + /* "dependency_injector/providers.pyx":2210 * cdef object instance * * try: # <<<<<<<<<<<<<< @@ -39882,7 +39882,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton } } - /* "dependency_injector/providers.pyx":2215 + /* "dependency_injector/providers.pyx":2216 * self.__storage.instance = instance * finally: * return instance # <<<<<<<<<<<<<< @@ -39916,7 +39916,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton __Pyx_XGOTREF(__pyx_t_12); { __Pyx_XDECREF(__pyx_r); - if (unlikely(!__pyx_v_instance)) { __Pyx_RaiseUnboundLocalError("instance"); __PYX_ERR(1, 2215, __pyx_L15_error) } + if (unlikely(!__pyx_v_instance)) { __Pyx_RaiseUnboundLocalError("instance"); __PYX_ERR(1, 2216, __pyx_L15_error) } __Pyx_INCREF(__pyx_v_instance); __pyx_r = __pyx_v_instance; goto __pyx_L14_return; @@ -39948,7 +39948,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton } } - /* "dependency_injector/providers.pyx":2205 + /* "dependency_injector/providers.pyx":2206 * del self.__storage.instance * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -40007,11 +40007,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_20ThreadLocalSingleto case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2205, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2206, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2205, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2206, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -40024,14 +40024,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_20ThreadLocalSingleto } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2205, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2206, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.ThreadLocalSingleton._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2205, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2205, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2206, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2206, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleton_4_provide(((struct __pyx_obj_19dependency_injector_9providers_ThreadLocalSingleton *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -40052,7 +40052,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_20ThreadLocalSingleto int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2205, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -40723,7 +40723,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_29DelegatedThreadLoca return __pyx_r; } -/* "dependency_injector/providers.pyx":2250 +/* "dependency_injector/providers.pyx":2251 * """ * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< @@ -40776,7 +40776,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); - /* "dependency_injector/providers.pyx":2255 + /* "dependency_injector/providers.pyx":2256 * Callable interface implementation. * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -40787,16 +40787,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":2256 + /* "dependency_injector/providers.pyx":2257 * """ * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) # <<<<<<<<<<<<<< * return self.__last_overriding(*args, **kwargs) * */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2256, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2256, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -40810,7 +40810,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2256, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -40826,14 +40826,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2256, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2257, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2256, __pyx_L1_error) + __PYX_ERR(1, 2257, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2255 + /* "dependency_injector/providers.pyx":2256 * Callable interface implementation. * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -40842,7 +40842,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ */ } - /* "dependency_injector/providers.pyx":2257 + /* "dependency_injector/providers.pyx":2258 * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) * return self.__last_overriding(*args, **kwargs) # <<<<<<<<<<<<<< @@ -40850,13 +40850,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ * def override(self, provider): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2257, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2250 + /* "dependency_injector/providers.pyx":2251 * """ * * def __call__(self, *args, **kwargs): # <<<<<<<<<<<<<< @@ -40879,7 +40879,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton__ return __pyx_r; } -/* "dependency_injector/providers.pyx":2259 +/* "dependency_injector/providers.pyx":2260 * return self.__last_overriding(*args, **kwargs) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -40918,7 +40918,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 int __pyx_clineno = 0; __Pyx_RefNannySetupContext("override", 0); - /* "dependency_injector/providers.pyx":2270 + /* "dependency_injector/providers.pyx":2271 * :rtype: :py:class:`OverridingContext` * """ * if not isinstance(provider, BaseSingleton): # <<<<<<<<<<<<<< @@ -40929,24 +40929,24 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":2271 + /* "dependency_injector/providers.pyx":2272 * """ * if not isinstance(provider, BaseSingleton): * raise Error('{0} must be overridden only by ' # <<<<<<<<<<<<<< * '{1} providers'.format(self, BaseSingleton)) * return super(AbstractSingleton, self).override(provider) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2271, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - /* "dependency_injector/providers.pyx":2272 + /* "dependency_injector/providers.pyx":2273 * if not isinstance(provider, BaseSingleton): * raise Error('{0} must be overridden only by ' * '{1} providers'.format(self, BaseSingleton)) # <<<<<<<<<<<<<< * return super(AbstractSingleton, self).override(provider) * */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_only_by_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2272, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_only_by_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; @@ -40963,7 +40963,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2272, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2273, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else @@ -40971,13 +40971,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, ((PyObject *)__pyx_v_self), ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2272, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2273, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { - __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2272, __pyx_L1_error) + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -40988,7 +40988,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2272, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2273, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } @@ -41006,14 +41006,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2271, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2271, __pyx_L1_error) + __PYX_ERR(1, 2272, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2270 + /* "dependency_injector/providers.pyx":2271 * :rtype: :py:class:`OverridingContext` * """ * if not isinstance(provider, BaseSingleton): # <<<<<<<<<<<<<< @@ -41022,7 +41022,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 */ } - /* "dependency_injector/providers.pyx":2273 + /* "dependency_injector/providers.pyx":2274 * raise Error('{0} must be overridden only by ' * '{1} providers'.format(self, BaseSingleton)) * return super(AbstractSingleton, self).override(provider) # <<<<<<<<<<<<<< @@ -41030,7 +41030,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 * def reset(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2273, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_AbstractSingleton)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_AbstractSingleton)); @@ -41038,10 +41038,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2273, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2273, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_override); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -41056,14 +41056,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_provider) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_provider); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2273, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2274, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2259 + /* "dependency_injector/providers.pyx":2260 * return self.__last_overriding(*args, **kwargs) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -41087,7 +41087,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_2 return __pyx_r; } -/* "dependency_injector/providers.pyx":2275 +/* "dependency_injector/providers.pyx":2276 * return super(AbstractSingleton, self).override(provider) * * def reset(self): # <<<<<<<<<<<<<< @@ -41124,7 +41124,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 int __pyx_clineno = 0; __Pyx_RefNannySetupContext("reset", 0); - /* "dependency_injector/providers.pyx":2280 + /* "dependency_injector/providers.pyx":2281 * :rtype: None * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -41135,16 +41135,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":2281 + /* "dependency_injector/providers.pyx":2282 * """ * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) # <<<<<<<<<<<<<< * return self.__last_overriding.reset() * */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2281, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2281, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_must_be_overridden_before_cal, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -41158,7 +41158,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_6, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2281, __pyx_L1_error) + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -41174,14 +41174,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2281, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2282, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2281, __pyx_L1_error) + __PYX_ERR(1, 2282, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2280 + /* "dependency_injector/providers.pyx":2281 * :rtype: None * """ * if self.__last_overriding is None: # <<<<<<<<<<<<<< @@ -41190,7 +41190,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 */ } - /* "dependency_injector/providers.pyx":2282 + /* "dependency_injector/providers.pyx":2283 * if self.__last_overriding is None: * raise Error('{0} must be overridden before calling'.format(self)) * return self.__last_overriding.reset() # <<<<<<<<<<<<<< @@ -41198,7 +41198,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_n_s_reset); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2282, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->__pyx_base.__pyx_base.__pyx___last_overriding), __pyx_n_s_reset); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -41212,14 +41212,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_4 } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2282, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2283, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2275 + /* "dependency_injector/providers.pyx":2276 * return super(AbstractSingleton, self).override(provider) * * def reset(self): # <<<<<<<<<<<<<< @@ -41559,7 +41559,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17AbstractSingleton_8 return __pyx_r; } -/* "dependency_injector/providers.pyx":2295 +/* "dependency_injector/providers.pyx":2296 * """ * * def __init__(self, singleton): # <<<<<<<<<<<<<< @@ -41600,7 +41600,7 @@ static int __pyx_pw_19dependency_injector_9providers_17SingletonDelegate_1__init else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2295, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2296, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; @@ -41611,7 +41611,7 @@ static int __pyx_pw_19dependency_injector_9providers_17SingletonDelegate_1__init } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2295, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2296, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.SingletonDelegate.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -41642,7 +41642,7 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2301 + /* "dependency_injector/providers.pyx":2302 * :type singleton: py:class:`BaseSingleton` * """ * if isinstance(singleton, BaseSingleton) is False: # <<<<<<<<<<<<<< @@ -41653,26 +41653,26 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ __pyx_t_2 = ((__pyx_t_1 == 0) != 0); if (unlikely(__pyx_t_2)) { - /* "dependency_injector/providers.pyx":2302 + /* "dependency_injector/providers.pyx":2303 * """ * if isinstance(singleton, BaseSingleton) is False: * raise Error('{0} can wrap only {1} providers'.format( # <<<<<<<<<<<<<< * self.__class__, BaseSingleton)) * super(SingletonDelegate, self).__init__(singleton) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2302, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_wrap_only_1_providers, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2302, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_can_wrap_only_1_providers, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - /* "dependency_injector/providers.pyx":2303 + /* "dependency_injector/providers.pyx":2304 * if isinstance(singleton, BaseSingleton) is False: * raise Error('{0} can wrap only {1} providers'.format( * self.__class__, BaseSingleton)) # <<<<<<<<<<<<<< * super(SingletonDelegate, self).__init__(singleton) * */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2303, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; @@ -41689,7 +41689,7 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)}; - __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2302, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; @@ -41698,14 +41698,14 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_7, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)}; - __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2302, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2302, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -41716,7 +41716,7 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, ((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton)); __pyx_t_7 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2302, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } @@ -41734,14 +41734,14 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2302, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2303, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2302, __pyx_L1_error) + __PYX_ERR(1, 2303, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2301 + /* "dependency_injector/providers.pyx":2302 * :type singleton: py:class:`BaseSingleton` * """ * if isinstance(singleton, BaseSingleton) is False: # <<<<<<<<<<<<<< @@ -41750,14 +41750,14 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ */ } - /* "dependency_injector/providers.pyx":2304 + /* "dependency_injector/providers.pyx":2305 * raise Error('{0} can wrap only {1} providers'.format( * self.__class__, BaseSingleton)) * super(SingletonDelegate, self).__init__(singleton) # <<<<<<<<<<<<<< * * */ - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2304, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_SingletonDelegate)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_SingletonDelegate)); @@ -41765,10 +41765,10 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2304, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2304, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -41783,12 +41783,12 @@ static int __pyx_pf_19dependency_injector_9providers_17SingletonDelegate___init_ } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_singleton) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_singleton); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2304, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2295 + /* "dependency_injector/providers.pyx":2296 * """ * * def __init__(self, singleton): # <<<<<<<<<<<<<< @@ -42131,7 +42131,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_17SingletonDelegate_4 return __pyx_r; } -/* "dependency_injector/providers.pyx":2337 +/* "dependency_injector/providers.pyx":2338 * """ * * def __init__(self, *args): # <<<<<<<<<<<<<< @@ -42172,14 +42172,14 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2339 + /* "dependency_injector/providers.pyx":2340 * def __init__(self, *args): * """Initializer.""" * self.__args = tuple() # <<<<<<<<<<<<<< * self.__args_len = 0 * self.set_args(*args) */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2339, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2340, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___args); @@ -42187,7 +42187,7 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx __pyx_v_self->__pyx___args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2340 + /* "dependency_injector/providers.pyx":2341 * """Initializer.""" * self.__args = tuple() * self.__args_len = 0 # <<<<<<<<<<<<<< @@ -42196,28 +42196,28 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx */ __pyx_v_self->__pyx___args_len = 0; - /* "dependency_injector/providers.pyx":2341 + /* "dependency_injector/providers.pyx":2342 * self.__args = tuple() * self.__args_len = 0 * self.set_args(*args) # <<<<<<<<<<<<<< * super(List, self).__init__() * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2341, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2341, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2342 + /* "dependency_injector/providers.pyx":2343 * self.__args_len = 0 * self.set_args(*args) * super(List, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2342, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_List)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_List)); @@ -42225,10 +42225,10 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2342, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2342, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -42243,12 +42243,12 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx } __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2342, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2343, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2337 + /* "dependency_injector/providers.pyx":2338 * """ * * def __init__(self, *args): # <<<<<<<<<<<<<< @@ -42270,7 +42270,7 @@ static int __pyx_pf_19dependency_injector_9providers_4List___init__(struct __pyx return __pyx_r; } -/* "dependency_injector/providers.pyx":2344 +/* "dependency_injector/providers.pyx":2345 * super(List, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -42308,16 +42308,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":2346 + /* "dependency_injector/providers.pyx":2347 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2346, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2346, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -42332,13 +42332,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2346, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2347, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2347 + /* "dependency_injector/providers.pyx":2348 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -42349,7 +42349,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":2348 + /* "dependency_injector/providers.pyx":2349 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -42361,7 +42361,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2347 + /* "dependency_injector/providers.pyx":2348 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -42370,45 +42370,45 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s */ } - /* "dependency_injector/providers.pyx":2350 + /* "dependency_injector/providers.pyx":2351 * return copied * * copied = self.__class__(*deepcopy(self.args, memo)) # <<<<<<<<<<<<<< * self._copy_overridings(copied, memo) * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2350, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2350, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2350, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2351, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2350, __pyx_L1_error) + __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2350, __pyx_L1_error) + __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2350, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_copied, __pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2351 + /* "dependency_injector/providers.pyx":2352 * * copied = self.__class__(*deepcopy(self.args, memo)) * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 2351, __pyx_L1_error) - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2351, __pyx_L1_error) + if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 2352, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2352, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_List *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":2353 + /* "dependency_injector/providers.pyx":2354 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -42420,7 +42420,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2344 + /* "dependency_injector/providers.pyx":2345 * super(List, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -42443,7 +42443,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_2__deepcopy__(s return __pyx_r; } -/* "dependency_injector/providers.pyx":2355 +/* "dependency_injector/providers.pyx":2356 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -42478,7 +42478,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4__str__(struct int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); - /* "dependency_injector/providers.pyx":2360 + /* "dependency_injector/providers.pyx":2361 * :rtype: str * """ * return represent_provider(provider=self, provides=list(self.args)) # <<<<<<<<<<<<<< @@ -42486,19 +42486,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4__str__(struct * @property */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2360, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2360, __pyx_L1_error) + __pyx_t_2 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2360, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(((PyObject *)__pyx_v_self), __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2355 + /* "dependency_injector/providers.pyx":2356 * return copied * * def __str__(self): # <<<<<<<<<<<<<< @@ -42518,7 +42518,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4__str__(struct return __pyx_r; } -/* "dependency_injector/providers.pyx":2363 +/* "dependency_injector/providers.pyx":2364 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -42555,19 +42555,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":2369 + /* "dependency_injector/providers.pyx":2370 * cdef list args * * args = list() # <<<<<<<<<<<<<< * for index in range(self.__args_len): * arg = self.__args[index] */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2369, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2370, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2370 + /* "dependency_injector/providers.pyx":2371 * * args = list() * for index in range(self.__args_len): # <<<<<<<<<<<<<< @@ -42579,7 +42579,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { __pyx_v_index = __pyx_t_4; - /* "dependency_injector/providers.pyx":2371 + /* "dependency_injector/providers.pyx":2372 * args = list() * for index in range(self.__args_len): * arg = self.__args[index] # <<<<<<<<<<<<<< @@ -42588,15 +42588,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s */ if (unlikely(__pyx_v_self->__pyx___args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 2371, __pyx_L1_error) + __PYX_ERR(1, 2372, __pyx_L1_error) } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->__pyx___args, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2371, __pyx_L1_error) + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_self->__pyx___args, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2372, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_PositionalInjection))))) __PYX_ERR(1, 2371, __pyx_L1_error) + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_19dependency_injector_9providers_PositionalInjection))))) __PYX_ERR(1, 2372, __pyx_L1_error) __Pyx_XDECREF_SET(__pyx_v_arg, ((struct __pyx_obj_19dependency_injector_9providers_PositionalInjection *)__pyx_t_1)); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2372 + /* "dependency_injector/providers.pyx":2373 * for index in range(self.__args_len): * arg = self.__args[index] * args.append(arg.__value) # <<<<<<<<<<<<<< @@ -42605,11 +42605,11 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s */ __pyx_t_1 = __pyx_v_arg->__pyx_base.__pyx___value; __Pyx_INCREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_args, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 2372, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_args, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 2373, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - /* "dependency_injector/providers.pyx":2373 + /* "dependency_injector/providers.pyx":2374 * arg = self.__args[index] * args.append(arg.__value) * return tuple(args) # <<<<<<<<<<<<<< @@ -42617,13 +42617,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s * def add_args(self, *args): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_AsTuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2373, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2374, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2363 + /* "dependency_injector/providers.pyx":2364 * * @property * def args(self): # <<<<<<<<<<<<<< @@ -42644,7 +42644,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_4args___get__(s return __pyx_r; } -/* "dependency_injector/providers.pyx":2375 +/* "dependency_injector/providers.pyx":2376 * return tuple(args) * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -42682,16 +42682,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_6add_args(struc int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add_args", 0); - /* "dependency_injector/providers.pyx":2380 + /* "dependency_injector/providers.pyx":2381 * :return: Reference ``self`` * """ * self.__args += parse_positional_injections(args) # <<<<<<<<<<<<<< * self.__args_len = len(self.__args) * return self */ - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2380, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_self->__pyx___args, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2380, __pyx_L1_error) + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_self->__pyx___args, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_2); @@ -42700,7 +42700,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_6add_args(struc __pyx_v_self->__pyx___args = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2381 + /* "dependency_injector/providers.pyx":2382 * """ * self.__args += parse_positional_injections(args) * self.__args_len = len(self.__args) # <<<<<<<<<<<<<< @@ -42711,13 +42711,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_6add_args(struc __Pyx_INCREF(__pyx_t_2); if (unlikely(__pyx_t_2 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 2381, __pyx_L1_error) + __PYX_ERR(1, 2382, __pyx_L1_error) } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2381, __pyx_L1_error) + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_t_2); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2382, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_self->__pyx___args_len = __pyx_t_3; - /* "dependency_injector/providers.pyx":2382 + /* "dependency_injector/providers.pyx":2383 * self.__args += parse_positional_injections(args) * self.__args_len = len(self.__args) * return self # <<<<<<<<<<<<<< @@ -42729,7 +42729,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_6add_args(struc __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2375 + /* "dependency_injector/providers.pyx":2376 * return tuple(args) * * def add_args(self, *args): # <<<<<<<<<<<<<< @@ -42749,7 +42749,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_6add_args(struc return __pyx_r; } -/* "dependency_injector/providers.pyx":2384 +/* "dependency_injector/providers.pyx":2385 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -42786,14 +42786,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_8set_args(struc int __pyx_clineno = 0; __Pyx_RefNannySetupContext("set_args", 0); - /* "dependency_injector/providers.pyx":2391 + /* "dependency_injector/providers.pyx":2392 * :return: Reference ``self`` * """ * self.__args = parse_positional_injections(args) # <<<<<<<<<<<<<< * self.__args_len = len(self.__args) * return self */ - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2391, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2392, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___args); @@ -42801,7 +42801,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_8set_args(struc __pyx_v_self->__pyx___args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2392 + /* "dependency_injector/providers.pyx":2393 * """ * self.__args = parse_positional_injections(args) * self.__args_len = len(self.__args) # <<<<<<<<<<<<<< @@ -42812,13 +42812,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_8set_args(struc __Pyx_INCREF(__pyx_t_1); if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 2392, __pyx_L1_error) + __PYX_ERR(1, 2393, __pyx_L1_error) } - __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2392, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2393, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->__pyx___args_len = __pyx_t_2; - /* "dependency_injector/providers.pyx":2393 + /* "dependency_injector/providers.pyx":2394 * self.__args = parse_positional_injections(args) * self.__args_len = len(self.__args) * return self # <<<<<<<<<<<<<< @@ -42830,7 +42830,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_8set_args(struc __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2384 + /* "dependency_injector/providers.pyx":2385 * return self * * def set_args(self, *args): # <<<<<<<<<<<<<< @@ -42849,7 +42849,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_8set_args(struc return __pyx_r; } -/* "dependency_injector/providers.pyx":2395 +/* "dependency_injector/providers.pyx":2396 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -42881,14 +42881,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_10clear_args(st int __pyx_clineno = 0; __Pyx_RefNannySetupContext("clear_args", 0); - /* "dependency_injector/providers.pyx":2400 + /* "dependency_injector/providers.pyx":2401 * :return: Reference ``self`` * """ * self.__args = tuple() # <<<<<<<<<<<<<< * self.__args_len = len(self.__args) * return self */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2400, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)(&PyTuple_Type))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->__pyx___args); @@ -42896,7 +42896,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_10clear_args(st __pyx_v_self->__pyx___args = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2401 + /* "dependency_injector/providers.pyx":2402 * """ * self.__args = tuple() * self.__args_len = len(self.__args) # <<<<<<<<<<<<<< @@ -42907,13 +42907,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_10clear_args(st __Pyx_INCREF(__pyx_t_1); if (unlikely(__pyx_t_1 == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 2401, __pyx_L1_error) + __PYX_ERR(1, 2402, __pyx_L1_error) } - __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2401, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2402, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_self->__pyx___args_len = __pyx_t_2; - /* "dependency_injector/providers.pyx":2402 + /* "dependency_injector/providers.pyx":2403 * self.__args = tuple() * self.__args_len = len(self.__args) * return self # <<<<<<<<<<<<<< @@ -42925,7 +42925,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_10clear_args(st __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; - /* "dependency_injector/providers.pyx":2395 + /* "dependency_injector/providers.pyx":2396 * return self * * def clear_args(self): # <<<<<<<<<<<<<< @@ -42944,7 +42944,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_10clear_args(st return __pyx_r; } -/* "dependency_injector/providers.pyx":2404 +/* "dependency_injector/providers.pyx":2405 * return self * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -42975,7 +42975,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_4List_13_provide)) { __Pyx_XDECREF(__pyx_r); @@ -42995,7 +42995,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -43003,13 +43003,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -43020,7 +43020,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -43043,7 +43043,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct #endif } - /* "dependency_injector/providers.pyx":2406 + /* "dependency_injector/providers.pyx":2407 * cpdef object _provide(self, tuple args, dict kwargs): * """Return result of provided callable's call.""" * return list(__provide_positional_args(args, self.__args, self.__args_len)) # <<<<<<<<<<<<<< @@ -43053,17 +43053,17 @@ static PyObject *__pyx_f_19dependency_injector_9providers_4List__provide(struct __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_v_self->__pyx___args; __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = __pyx_f_19dependency_injector_9providers___provide_positional_args(__pyx_v_args, ((PyObject*)__pyx_t_1), __pyx_v_self->__pyx___args_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2406, __pyx_L1_error) + __pyx_t_2 = __pyx_f_19dependency_injector_9providers___provide_positional_args(__pyx_v_args, ((PyObject*)__pyx_t_1), __pyx_v_self->__pyx___args_len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = PySequence_List(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2406, __pyx_L1_error) + __pyx_t_1 = PySequence_List(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2407, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2404 + /* "dependency_injector/providers.pyx":2405 * return self * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -43121,11 +43121,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_4List_13_provide(PyOb case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2404, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2405, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2404, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2405, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -43138,14 +43138,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_4List_13_provide(PyOb } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2404, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2405, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.List._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2404, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2404, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2405, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2405, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_4List_12_provide(((struct __pyx_obj_19dependency_injector_9providers_List *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -43166,7 +43166,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_12_provide(stru int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_4List__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2404, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_4List__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -43505,7 +43505,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_4List_16__setstate_cy return __pyx_r; } -/* "dependency_injector/providers.pyx":2416 +/* "dependency_injector/providers.pyx":2417 * """ * * def __init__(self, container_cls, container=None, **overriding_providers): # <<<<<<<<<<<<<< @@ -43559,7 +43559,7 @@ static int __pyx_pw_19dependency_injector_9providers_9Container_1__init__(PyObje } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_overriding_providers, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2416, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_overriding_providers, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2417, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -43575,7 +43575,7 @@ static int __pyx_pw_19dependency_injector_9providers_9Container_1__init__(PyObje } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2416, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2417, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_overriding_providers); __pyx_v_overriding_providers = 0; __Pyx_AddTraceback("dependency_injector.providers.Container.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -43604,7 +43604,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __Pyx_RefNannySetupContext("__init__", 0); __Pyx_INCREF(__pyx_v_container); - /* "dependency_injector/providers.pyx":2418 + /* "dependency_injector/providers.pyx":2419 * def __init__(self, container_cls, container=None, **overriding_providers): * """Initialize provider.""" * self.container_cls = container_cls # <<<<<<<<<<<<<< @@ -43617,7 +43617,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __Pyx_DECREF(__pyx_v_self->container_cls); __pyx_v_self->container_cls = __pyx_v_container_cls; - /* "dependency_injector/providers.pyx":2419 + /* "dependency_injector/providers.pyx":2420 * """Initialize provider.""" * self.container_cls = container_cls * self.overriding_providers = overriding_providers # <<<<<<<<<<<<<< @@ -43630,7 +43630,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __Pyx_DECREF(__pyx_v_self->overriding_providers); __pyx_v_self->overriding_providers = __pyx_v_overriding_providers; - /* "dependency_injector/providers.pyx":2421 + /* "dependency_injector/providers.pyx":2422 * self.overriding_providers = overriding_providers * * if container is None: # <<<<<<<<<<<<<< @@ -43641,7 +43641,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "dependency_injector/providers.pyx":2422 + /* "dependency_injector/providers.pyx":2423 * * if container is None: * container = container_cls() # <<<<<<<<<<<<<< @@ -43661,27 +43661,27 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2422, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2423, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_container, __pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2423 + /* "dependency_injector/providers.pyx":2424 * if container is None: * container = container_cls() * container.override_providers(**overriding_providers) # <<<<<<<<<<<<<< * self.container = container * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_container, __pyx_n_s_override_providers_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2423, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_container, __pyx_n_s_override_providers_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_v_overriding_providers); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2423, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_v_overriding_providers); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2424, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dependency_injector/providers.pyx":2421 + /* "dependency_injector/providers.pyx":2422 * self.overriding_providers = overriding_providers * * if container is None: # <<<<<<<<<<<<<< @@ -43690,7 +43690,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct */ } - /* "dependency_injector/providers.pyx":2424 + /* "dependency_injector/providers.pyx":2425 * container = container_cls() * container.override_providers(**overriding_providers) * self.container = container # <<<<<<<<<<<<<< @@ -43703,14 +43703,14 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __Pyx_DECREF(__pyx_v_self->container); __pyx_v_self->container = __pyx_v_container; - /* "dependency_injector/providers.pyx":2426 + /* "dependency_injector/providers.pyx":2427 * self.container = container * * super(Container, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2426, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Container)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Container)); @@ -43718,10 +43718,10 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2426, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2426, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -43736,12 +43736,12 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2426, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dependency_injector/providers.pyx":2416 + /* "dependency_injector/providers.pyx":2417 * """ * * def __init__(self, container_cls, container=None, **overriding_providers): # <<<<<<<<<<<<<< @@ -43764,7 +43764,7 @@ static int __pyx_pf_19dependency_injector_9providers_9Container___init__(struct return __pyx_r; } -/* "dependency_injector/providers.pyx":2428 +/* "dependency_injector/providers.pyx":2429 * super(Container, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -43803,16 +43803,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":2430 + /* "dependency_injector/providers.pyx":2431 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2430, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2430, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -43827,13 +43827,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2430, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2431, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2431 + /* "dependency_injector/providers.pyx":2432 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -43844,7 +43844,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":2432 + /* "dependency_injector/providers.pyx":2433 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -43856,7 +43856,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2431 + /* "dependency_injector/providers.pyx":2432 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -43865,17 +43865,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop */ } - /* "dependency_injector/providers.pyx":2434 + /* "dependency_injector/providers.pyx":2435 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * self.container_cls, * deepcopy(self.container, memo), */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2434, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2436 + /* "dependency_injector/providers.pyx":2437 * copied = self.__class__( * self.container_cls, * deepcopy(self.container, memo), # <<<<<<<<<<<<<< @@ -43884,21 +43884,21 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop */ __pyx_t_2 = __pyx_v_self->container; __Pyx_INCREF(__pyx_t_2); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2436, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2437, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2436, __pyx_L1_error) + __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2437, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2434 + /* "dependency_injector/providers.pyx":2435 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * self.container_cls, * deepcopy(self.container, memo), */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2434, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_self->container_cls); __Pyx_GIVEREF(__pyx_v_self->container_cls); @@ -43907,7 +43907,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2437 + /* "dependency_injector/providers.pyx":2438 * self.container_cls, * deepcopy(self.container, memo), * **deepcopy(self.overriding_providers, memo), # <<<<<<<<<<<<<< @@ -43916,34 +43916,34 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop */ __pyx_t_4 = __pyx_v_self->overriding_providers; __Pyx_INCREF(__pyx_t_4); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2437, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2438, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2437, __pyx_L1_error) + __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_8 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 2437, __pyx_L1_error) + __PYX_ERR(1, 2438, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_8))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2437, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2434, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - /* "dependency_injector/providers.pyx":2434 + /* "dependency_injector/providers.pyx":2435 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * self.container_cls, * deepcopy(self.container, memo), */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2434, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -43951,7 +43951,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop __Pyx_DECREF_SET(__pyx_v_copied, __pyx_t_8); __pyx_t_8 = 0; - /* "dependency_injector/providers.pyx":2440 + /* "dependency_injector/providers.pyx":2441 * ) * * return copied # <<<<<<<<<<<<<< @@ -43963,7 +43963,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2428 + /* "dependency_injector/providers.pyx":2429 * super(Container, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -43987,7 +43987,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_2__deepcop return __pyx_r; } -/* "dependency_injector/providers.pyx":2442 +/* "dependency_injector/providers.pyx":2443 * return copied * * def __getattr__(self, name): # <<<<<<<<<<<<<< @@ -44026,14 +44026,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); - /* "dependency_injector/providers.pyx":2444 + /* "dependency_injector/providers.pyx":2445 * def __getattr__(self, name): * """Return dependency provider.""" * if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<< * raise AttributeError( * '\'{cls}\' object has no attribute ' */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2444, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -44047,17 +44047,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2444, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2444, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2444, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -44071,70 +44071,70 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2444, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2444, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2445, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":2447 + /* "dependency_injector/providers.pyx":2448 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=name)) * return getattr(self.container, name) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2447, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2447, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2447, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2447, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 2447, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2448 + /* "dependency_injector/providers.pyx":2449 * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=name)) # <<<<<<<<<<<<<< * return getattr(self.container, name) * */ - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_name) < 0) __PYX_ERR(1, 2447, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_name) < 0) __PYX_ERR(1, 2448, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2447 + /* "dependency_injector/providers.pyx":2448 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=name)) * return getattr(self.container, name) */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2447, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2448, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2445 + /* "dependency_injector/providers.pyx":2446 * """Return dependency provider.""" * if name.startswith('__') and name.endswith('__'): * raise AttributeError( # <<<<<<<<<<<<<< * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2445, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2446, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2445, __pyx_L1_error) + __PYX_ERR(1, 2446, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2444 + /* "dependency_injector/providers.pyx":2445 * def __getattr__(self, name): * """Return dependency provider.""" * if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<< @@ -44143,7 +44143,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr */ } - /* "dependency_injector/providers.pyx":2449 + /* "dependency_injector/providers.pyx":2450 * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=name)) * return getattr(self.container, name) # <<<<<<<<<<<<<< @@ -44153,14 +44153,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __pyx_v_self->container; __Pyx_INCREF(__pyx_t_3); - __pyx_t_6 = __Pyx_GetAttr(__pyx_t_3, __pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2449, __pyx_L1_error) + __pyx_t_6 = __Pyx_GetAttr(__pyx_t_3, __pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2442 + /* "dependency_injector/providers.pyx":2443 * return copied * * def __getattr__(self, name): # <<<<<<<<<<<<<< @@ -44182,7 +44182,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_4__getattr return __pyx_r; } -/* "dependency_injector/providers.pyx":2451 +/* "dependency_injector/providers.pyx":2452 * return getattr(self.container, name) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -44217,16 +44217,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_6override( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("override", 0); - /* "dependency_injector/providers.pyx":2453 + /* "dependency_injector/providers.pyx":2454 * def override(self, provider): * """Override provider with another provider.""" * raise Error('Provider {0} can not be overridden'.format(self)) # <<<<<<<<<<<<<< * * cpdef object _provide(self, tuple args, dict kwargs): */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2453, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Provider_0_can_not_be_overridden, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2453, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Provider_0_can_not_be_overridden, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { @@ -44240,7 +44240,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_6override( } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, ((PyObject *)__pyx_v_self)) : __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_self)); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2453, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -44256,14 +44256,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_6override( __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2453, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2453, __pyx_L1_error) + __PYX_ERR(1, 2454, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2451 + /* "dependency_injector/providers.pyx":2452 * return getattr(self.container, name) * * def override(self, provider): # <<<<<<<<<<<<<< @@ -44285,7 +44285,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_6override( return __pyx_r; } -/* "dependency_injector/providers.pyx":2455 +/* "dependency_injector/providers.pyx":2456 * raise Error('Provider {0} can not be overridden'.format(self)) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -44316,7 +44316,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_9Container_9_provide)) { __Pyx_XDECREF(__pyx_r); @@ -44336,7 +44336,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -44344,13 +44344,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -44361,7 +44361,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -44384,7 +44384,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st #endif } - /* "dependency_injector/providers.pyx":2457 + /* "dependency_injector/providers.pyx":2458 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * return self.container # <<<<<<<<<<<<<< @@ -44396,7 +44396,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_9Container__provide(st __pyx_r = __pyx_v_self->container; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2455 + /* "dependency_injector/providers.pyx":2456 * raise Error('Provider {0} can not be overridden'.format(self)) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -44454,11 +44454,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_9Container_9_provide( case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2455, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2456, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2455, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2456, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -44471,14 +44471,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_9Container_9_provide( } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2455, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2456, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Container._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2455, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2455, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2456, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2456, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_9Container_8_provide(((struct __pyx_obj_19dependency_injector_9providers_Container *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -44499,7 +44499,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_8_provide( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_9Container__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2455, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_9Container__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2456, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -44853,7 +44853,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Container_12__setsta return __pyx_r; } -/* "dependency_injector/providers.pyx":2491 +/* "dependency_injector/providers.pyx":2492 * """ * * def __init__(self, selector, **providers): # <<<<<<<<<<<<<< @@ -44897,7 +44897,7 @@ static int __pyx_pw_19dependency_injector_9providers_8Selector_1__init__(PyObjec else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_providers, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2491, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_providers, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2492, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; @@ -44908,7 +44908,7 @@ static int __pyx_pw_19dependency_injector_9providers_8Selector_1__init__(PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2491, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2492, __pyx_L3_error) __pyx_L3_error:; __Pyx_DECREF(__pyx_v_providers); __pyx_v_providers = 0; __Pyx_AddTraceback("dependency_injector.providers.Selector.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); @@ -44934,7 +44934,7 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2493 + /* "dependency_injector/providers.pyx":2494 * def __init__(self, selector, **providers): * """Initialize provider.""" * self.__selector = selector # <<<<<<<<<<<<<< @@ -44947,7 +44947,7 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ __Pyx_DECREF(__pyx_v_self->__pyx___selector); __pyx_v_self->__pyx___selector = __pyx_v_selector; - /* "dependency_injector/providers.pyx":2494 + /* "dependency_injector/providers.pyx":2495 * """Initialize provider.""" * self.__selector = selector * self.__providers = providers # <<<<<<<<<<<<<< @@ -44960,14 +44960,14 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ __Pyx_DECREF(__pyx_v_self->__pyx___providers); __pyx_v_self->__pyx___providers = __pyx_v_providers; - /* "dependency_injector/providers.pyx":2495 + /* "dependency_injector/providers.pyx":2496 * self.__selector = selector * self.__providers = providers * super(Selector, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2495, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Selector)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_Selector)); @@ -44975,10 +44975,10 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_2, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2495, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2495, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_init); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -44993,12 +44993,12 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2495, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2496, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2491 + /* "dependency_injector/providers.pyx":2492 * """ * * def __init__(self, selector, **providers): # <<<<<<<<<<<<<< @@ -45020,7 +45020,7 @@ static int __pyx_pf_19dependency_injector_9providers_8Selector___init__(struct _ return __pyx_r; } -/* "dependency_injector/providers.pyx":2497 +/* "dependency_injector/providers.pyx":2498 * super(Selector, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -45059,16 +45059,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":2499 + /* "dependency_injector/providers.pyx":2500 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2499, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2499, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -45083,13 +45083,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2499, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2500, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2500 + /* "dependency_injector/providers.pyx":2501 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -45100,7 +45100,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":2501 + /* "dependency_injector/providers.pyx":2502 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -45112,7 +45112,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2500 + /* "dependency_injector/providers.pyx":2501 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -45121,17 +45121,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy */ } - /* "dependency_injector/providers.pyx":2503 + /* "dependency_injector/providers.pyx":2504 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * deepcopy(self.__selector, memo), * **deepcopy(self.__providers, memo), */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2503, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2504 + /* "dependency_injector/providers.pyx":2505 * * copied = self.__class__( * deepcopy(self.__selector, memo), # <<<<<<<<<<<<<< @@ -45140,27 +45140,27 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy */ __pyx_t_2 = __pyx_v_self->__pyx___selector; __Pyx_INCREF(__pyx_t_2); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2504, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2505, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2504, __pyx_L1_error) + __pyx_t_3 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_2, 0, &__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2503 + /* "dependency_injector/providers.pyx":2504 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * deepcopy(self.__selector, memo), * **deepcopy(self.__providers, memo), */ - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2503, __pyx_L1_error) + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2505 + /* "dependency_injector/providers.pyx":2506 * copied = self.__class__( * deepcopy(self.__selector, memo), * **deepcopy(self.__providers, memo), # <<<<<<<<<<<<<< @@ -45169,34 +45169,34 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy */ __pyx_t_4 = __pyx_v_self->__pyx___providers; __Pyx_INCREF(__pyx_t_4); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2505, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2506, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2505, __pyx_L1_error) + __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_4, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_8 == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 2505, __pyx_L1_error) + __PYX_ERR(1, 2506, __pyx_L1_error) } if (likely(PyDict_CheckExact(__pyx_t_8))) { - __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2505, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2506, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { - __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2503, __pyx_L1_error) + __pyx_t_3 = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } - /* "dependency_injector/providers.pyx":2503 + /* "dependency_injector/providers.pyx":2504 * return copied * * copied = self.__class__( # <<<<<<<<<<<<<< * deepcopy(self.__selector, memo), * **deepcopy(self.__providers, memo), */ - __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2503, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2504, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -45204,18 +45204,18 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy __Pyx_DECREF_SET(__pyx_v_copied, __pyx_t_8); __pyx_t_8 = 0; - /* "dependency_injector/providers.pyx":2507 + /* "dependency_injector/providers.pyx":2508 * **deepcopy(self.__providers, memo), * ) * self._copy_overridings(copied, memo) # <<<<<<<<<<<<<< * * return copied */ - if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 2507, __pyx_L1_error) - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2507, __pyx_L1_error) + if (!(likely(((__pyx_v_copied) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_copied, __pyx_ptype_19dependency_injector_9providers_Provider))))) __PYX_ERR(1, 2508, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2508, __pyx_L1_error) ((struct __pyx_vtabstruct_19dependency_injector_9providers_Selector *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base._copy_overridings(((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_self), ((struct __pyx_obj_19dependency_injector_9providers_Provider *)__pyx_v_copied), ((PyObject*)__pyx_v_memo), 0); - /* "dependency_injector/providers.pyx":2509 + /* "dependency_injector/providers.pyx":2510 * self._copy_overridings(copied, memo) * * return copied # <<<<<<<<<<<<<< @@ -45227,7 +45227,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2497 + /* "dependency_injector/providers.pyx":2498 * super(Selector, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -45251,7 +45251,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_2__deepcopy return __pyx_r; } -/* "dependency_injector/providers.pyx":2511 +/* "dependency_injector/providers.pyx":2512 * return copied * * def __getattr__(self, name): # <<<<<<<<<<<<<< @@ -45290,14 +45290,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getattr__", 0); - /* "dependency_injector/providers.pyx":2513 + /* "dependency_injector/providers.pyx":2514 * def __getattr__(self, name): * """Return provider.""" * if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<< * raise AttributeError( * '\'{cls}\' object has no attribute ' */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2513, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -45311,17 +45311,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2513, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2513, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2513, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { @@ -45335,70 +45335,70 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_n_s__3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_n_s__3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2513, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2513, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2514, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":2516 + /* "dependency_injector/providers.pyx":2517 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=name)) * if name not in self.__providers: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2516, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_cls_object_has_no_attribute_att, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2516, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2516, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2516, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 2516, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_cls, __pyx_t_6) < 0) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2517 + /* "dependency_injector/providers.pyx":2518 * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=name)) # <<<<<<<<<<<<<< * if name not in self.__providers: * raise AttributeError('Selector has no "{0}" provider'.format(name)) */ - if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_name) < 0) __PYX_ERR(1, 2516, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_attribute_name, __pyx_v_name) < 0) __PYX_ERR(1, 2517, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2516 + /* "dependency_injector/providers.pyx":2517 * raise AttributeError( * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, # <<<<<<<<<<<<<< * attribute_name=name)) * if name not in self.__providers: */ - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2516, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2517, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2514 + /* "dependency_injector/providers.pyx":2515 * """Return provider.""" * if name.startswith('__') and name.endswith('__'): * raise AttributeError( # <<<<<<<<<<<<<< * '\'{cls}\' object has no attribute ' * '\'{attribute_name}\''.format(cls=self.__class__.__name__, */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2514, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2515, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __PYX_ERR(1, 2514, __pyx_L1_error) + __PYX_ERR(1, 2515, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2513 + /* "dependency_injector/providers.pyx":2514 * def __getattr__(self, name): * """Return provider.""" * if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<< @@ -45407,7 +45407,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ */ } - /* "dependency_injector/providers.pyx":2518 + /* "dependency_injector/providers.pyx":2519 * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=name)) * if name not in self.__providers: # <<<<<<<<<<<<<< @@ -45416,20 +45416,20 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ */ if (unlikely(__pyx_v_self->__pyx___providers == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 2518, __pyx_L1_error) + __PYX_ERR(1, 2519, __pyx_L1_error) } - __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_v_name, __pyx_v_self->__pyx___providers, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2518, __pyx_L1_error) + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_v_name, __pyx_v_self->__pyx___providers, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2519, __pyx_L1_error) __pyx_t_5 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_5)) { - /* "dependency_injector/providers.pyx":2519 + /* "dependency_injector/providers.pyx":2520 * attribute_name=name)) * if name not in self.__providers: * raise AttributeError('Selector has no "{0}" provider'.format(name)) # <<<<<<<<<<<<<< * * return self.__providers[name] */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Selector_has_no_0_provider, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2519, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Selector_has_no_0_provider, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -45443,17 +45443,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_2, __pyx_v_name) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_name); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2519, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2519, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_AttributeError, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2520, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __PYX_ERR(1, 2519, __pyx_L1_error) + __PYX_ERR(1, 2520, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2518 + /* "dependency_injector/providers.pyx":2519 * '\'{attribute_name}\''.format(cls=self.__class__.__name__, * attribute_name=name)) * if name not in self.__providers: # <<<<<<<<<<<<<< @@ -45462,7 +45462,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ */ } - /* "dependency_injector/providers.pyx":2521 + /* "dependency_injector/providers.pyx":2522 * raise AttributeError('Selector has no "{0}" provider'.format(name)) * * return self.__providers[name] # <<<<<<<<<<<<<< @@ -45472,15 +45472,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_self->__pyx___providers == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 2521, __pyx_L1_error) + __PYX_ERR(1, 2522, __pyx_L1_error) } - __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___providers, __pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2521, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___providers, __pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_r = __pyx_t_6; __pyx_t_6 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2511 + /* "dependency_injector/providers.pyx":2512 * return copied * * def __getattr__(self, name): # <<<<<<<<<<<<<< @@ -45502,7 +45502,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_4__getattr_ return __pyx_r; } -/* "dependency_injector/providers.pyx":2523 +/* "dependency_injector/providers.pyx":2524 * return self.__providers[name] * * def __str__(self): # <<<<<<<<<<<<<< @@ -45528,7 +45528,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_8Selector_7__str__(Py } static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ -/* "dependency_injector/providers.pyx":2533 +/* "dependency_injector/providers.pyx":2534 * selector=self.__selector, * providers=', '.join(( * '{0}={1}'.format(name, provider) # <<<<<<<<<<<<<< @@ -45548,7 +45548,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_7__str___ge if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_19dependency_injector_9providers___pyx_scope_struct_3_genexpr *)Py_None); __Pyx_INCREF(Py_None); - __PYX_ERR(1, 2533, __pyx_L1_error) + __PYX_ERR(1, 2534, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } @@ -45556,7 +45556,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_7__str___ge __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); { - __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_19dependency_injector_9providers_8Selector_7__str___2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_dependency_injector_providers); if (unlikely(!gen)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_19dependency_injector_9providers_8Selector_7__str___2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_str___locals_genexpr, __pyx_n_s_dependency_injector_providers); if (unlikely(!gen)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; @@ -45598,29 +45598,29 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g return NULL; } __pyx_L3_first_run:; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2533, __pyx_L1_error) + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2534, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2534 + /* "dependency_injector/providers.pyx":2535 * providers=', '.join(( * '{0}={1}'.format(name, provider) * for name, provider in self.__providers.items() # <<<<<<<<<<<<<< * )), * address=hex(id(self)), */ - if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(1, 2534, __pyx_L1_error) } + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(1, 2535, __pyx_L1_error) } if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->__pyx___providers == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); - __PYX_ERR(1, 2534, __pyx_L1_error) + __PYX_ERR(1, 2535, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_Items(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->__pyx___providers); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self->__pyx___providers); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2535, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -45628,17 +45628,17 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2535, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2535, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -45648,7 +45648,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 2534, __pyx_L1_error) + else __PYX_ERR(1, 2535, __pyx_L1_error) } break; } @@ -45660,7 +45660,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 2534, __pyx_L1_error) + __PYX_ERR(1, 2535, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -45673,15 +45673,15 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2534, __pyx_L1_error) + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2535, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; @@ -45689,7 +45689,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_GOTREF(__pyx_t_5); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2534, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2535, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L7_unpacking_done; @@ -45697,7 +45697,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 2534, __pyx_L1_error) + __PYX_ERR(1, 2535, __pyx_L1_error) __pyx_L7_unpacking_done:; } __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_name); @@ -45709,14 +45709,14 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2533 + /* "dependency_injector/providers.pyx":2534 * selector=self.__selector, * providers=', '.join(( * '{0}={1}'.format(name, provider) # <<<<<<<<<<<<<< * for name, provider in self.__providers.items() * )), */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_0_1, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_5 = NULL; __pyx_t_9 = 0; @@ -45733,7 +45733,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_provider}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else @@ -45741,13 +45741,13 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_provider}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -45758,7 +45758,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_INCREF(__pyx_cur_scope->__pyx_v_provider); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_provider); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_9, __pyx_cur_scope->__pyx_v_provider); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -45781,9 +45781,9 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; - if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2533, __pyx_L1_error) + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2534, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2534 + /* "dependency_injector/providers.pyx":2535 * providers=', '.join(( * '{0}={1}'.format(name, provider) * for name, provider in self.__providers.items() # <<<<<<<<<<<<<< @@ -45794,7 +45794,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); - /* "dependency_injector/providers.pyx":2533 + /* "dependency_injector/providers.pyx":2534 * selector=self.__selector, * providers=', '.join(( * '{0}={1}'.format(name, provider) # <<<<<<<<<<<<<< @@ -45823,7 +45823,7 @@ static PyObject *__pyx_gb_19dependency_injector_9providers_8Selector_7__str___2g return __pyx_r; } -/* "dependency_injector/providers.pyx":2523 +/* "dependency_injector/providers.pyx":2524 * return self.__providers[name] * * def __str__(self): # <<<<<<<<<<<<<< @@ -45848,7 +45848,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_19dependency_injector_9providers___pyx_scope_struct_2___str__ *)Py_None); __Pyx_INCREF(Py_None); - __PYX_ERR(1, 2523, __pyx_L1_error) + __PYX_ERR(1, 2524, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } @@ -45856,7 +45856,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); - /* "dependency_injector/providers.pyx":2529 + /* "dependency_injector/providers.pyx":2530 * """ * * return '<{provider}({selector}, {providers}) at {address}>'.format( # <<<<<<<<<<<<<< @@ -45864,29 +45864,29 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st * selector=self.__selector, */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_provider_selector_providers_at, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2529, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_provider_selector_providers_at, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2530 + /* "dependency_injector/providers.pyx":2531 * * return '<{provider}({selector}, {providers}) at {address}>'.format( * provider='.'.join(( self.__class__.__module__, self.__class__.__name__)), # <<<<<<<<<<<<<< * selector=self.__selector, * providers=', '.join(( */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); @@ -45894,67 +45894,67 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); __pyx_t_4 = 0; __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2530, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provider, __pyx_t_5) < 0) __PYX_ERR(1, 2530, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provider, __pyx_t_5) < 0) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":2531 + /* "dependency_injector/providers.pyx":2532 * return '<{provider}({selector}, {providers}) at {address}>'.format( * provider='.'.join(( self.__class__.__module__, self.__class__.__name__)), * selector=self.__selector, # <<<<<<<<<<<<<< * providers=', '.join(( * '{0}={1}'.format(name, provider) */ - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_selector, __pyx_cur_scope->__pyx_v_self->__pyx___selector) < 0) __PYX_ERR(1, 2530, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_selector, __pyx_cur_scope->__pyx_v_self->__pyx___selector) < 0) __PYX_ERR(1, 2531, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2533 + /* "dependency_injector/providers.pyx":2534 * selector=self.__selector, * providers=', '.join(( * '{0}={1}'.format(name, provider) # <<<<<<<<<<<<<< * for name, provider in self.__providers.items() * )), */ - __pyx_t_5 = __pyx_pf_19dependency_injector_9providers_8Selector_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2533, __pyx_L1_error) + __pyx_t_5 = __pyx_pf_19dependency_injector_9providers_8Selector_7__str___genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2534, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - /* "dependency_injector/providers.pyx":2532 + /* "dependency_injector/providers.pyx":2533 * provider='.'.join(( self.__class__.__module__, self.__class__.__name__)), * selector=self.__selector, * providers=', '.join(( # <<<<<<<<<<<<<< * '{0}={1}'.format(name, provider) * for name, provider in self.__providers.items() */ - __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2532, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__7, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2533, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_providers, __pyx_t_3) < 0) __PYX_ERR(1, 2530, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_providers, __pyx_t_3) < 0) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2536 + /* "dependency_injector/providers.pyx":2537 * for name, provider in self.__providers.items() * )), * address=hex(id(self)), # <<<<<<<<<<<<<< * ) * */ - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_cur_scope->__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2536, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_cur_scope->__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_hex, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2536, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_hex, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2537, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_address, __pyx_t_5) < 0) __PYX_ERR(1, 2530, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_address, __pyx_t_5) < 0) __PYX_ERR(1, 2531, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":2529 + /* "dependency_injector/providers.pyx":2530 * """ * * return '<{provider}({selector}, {providers}) at {address}>'.format( # <<<<<<<<<<<<<< * provider='.'.join(( self.__class__.__module__, self.__class__.__name__)), * selector=self.__selector, */ - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2529, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2530, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -45962,7 +45962,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st __pyx_t_5 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2523 + /* "dependency_injector/providers.pyx":2524 * return self.__providers[name] * * def __str__(self): # <<<<<<<<<<<<<< @@ -45986,7 +45986,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_6__str__(st return __pyx_r; } -/* "dependency_injector/providers.pyx":2540 +/* "dependency_injector/providers.pyx":2541 * * @property * def providers(self): # <<<<<<<<<<<<<< @@ -46016,7 +46016,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_9providers_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); - /* "dependency_injector/providers.pyx":2542 + /* "dependency_injector/providers.pyx":2543 * def providers(self): * """Return providers.""" * return dict(self.__providers) # <<<<<<<<<<<<<< @@ -46026,15 +46026,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_9providers_ __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_self->__pyx___providers == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); - __PYX_ERR(1, 2542, __pyx_L1_error) + __PYX_ERR(1, 2543, __pyx_L1_error) } - __pyx_t_1 = PyDict_Copy(__pyx_v_self->__pyx___providers); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2542, __pyx_L1_error) + __pyx_t_1 = PyDict_Copy(__pyx_v_self->__pyx___providers); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2543, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2540 + /* "dependency_injector/providers.pyx":2541 * * @property * def providers(self): # <<<<<<<<<<<<<< @@ -46053,7 +46053,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_9providers_ return __pyx_r; } -/* "dependency_injector/providers.pyx":2544 +/* "dependency_injector/providers.pyx":2545 * return dict(self.__providers) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -46087,7 +46087,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { PY_UINT64_T __pyx_type_dict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_provide); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)(void*)__pyx_pw_19dependency_injector_9providers_8Selector_9_provide)) { __Pyx_XDECREF(__pyx_r); @@ -46107,7 +46107,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else @@ -46115,13 +46115,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_args, __pyx_v_kwargs}; - __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else #endif { - __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -46132,7 +46132,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str __Pyx_INCREF(__pyx_v_kwargs); __Pyx_GIVEREF(__pyx_v_kwargs); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_kwargs); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } @@ -46155,7 +46155,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str #endif } - /* "dependency_injector/providers.pyx":2546 + /* "dependency_injector/providers.pyx":2547 * cpdef object _provide(self, tuple args, dict kwargs): * """Return single instance.""" * selector_value = self.__selector() # <<<<<<<<<<<<<< @@ -46175,13 +46175,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2546, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2547, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_selector_value = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2548 + /* "dependency_injector/providers.pyx":2549 * selector_value = self.__selector() * * if selector_value is None: # <<<<<<<<<<<<<< @@ -46192,14 +46192,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str __pyx_t_8 = (__pyx_t_7 != 0); if (unlikely(__pyx_t_8)) { - /* "dependency_injector/providers.pyx":2549 + /* "dependency_injector/providers.pyx":2550 * * if selector_value is None: * raise Error('Selector value is undefined') # <<<<<<<<<<<<<< * * if selector_value not in self.__providers: */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2549, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -46213,14 +46213,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_s_Selector_value_is_undefined) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_s_Selector_value_is_undefined); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2549, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2550, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2549, __pyx_L1_error) + __PYX_ERR(1, 2550, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2548 + /* "dependency_injector/providers.pyx":2549 * selector_value = self.__selector() * * if selector_value is None: # <<<<<<<<<<<<<< @@ -46229,7 +46229,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str */ } - /* "dependency_injector/providers.pyx":2551 + /* "dependency_injector/providers.pyx":2552 * raise Error('Selector value is undefined') * * if selector_value not in self.__providers: # <<<<<<<<<<<<<< @@ -46238,22 +46238,22 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str */ if (unlikely(__pyx_v_self->__pyx___providers == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 2551, __pyx_L1_error) + __PYX_ERR(1, 2552, __pyx_L1_error) } - __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_v_selector_value, __pyx_v_self->__pyx___providers, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 2551, __pyx_L1_error) + __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_v_selector_value, __pyx_v_self->__pyx___providers, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 2552, __pyx_L1_error) __pyx_t_7 = (__pyx_t_8 != 0); if (unlikely(__pyx_t_7)) { - /* "dependency_injector/providers.pyx":2552 + /* "dependency_injector/providers.pyx":2553 * * if selector_value not in self.__providers: * raise Error('Selector has no "{0}" provider'.format(selector_value)) # <<<<<<<<<<<<<< * * return self.__providers[selector_value](*args, **kwargs) */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2552, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Selector_has_no_0_provider, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2552, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Selector_has_no_0_provider, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { @@ -46267,7 +46267,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, __pyx_v_selector_value) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_selector_value); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2552, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -46283,14 +46283,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_6, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2552, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2553, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __PYX_ERR(1, 2552, __pyx_L1_error) + __PYX_ERR(1, 2553, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2551 + /* "dependency_injector/providers.pyx":2552 * raise Error('Selector value is undefined') * * if selector_value not in self.__providers: # <<<<<<<<<<<<<< @@ -46299,7 +46299,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str */ } - /* "dependency_injector/providers.pyx":2554 + /* "dependency_injector/providers.pyx":2555 * raise Error('Selector has no "{0}" provider'.format(selector_value)) * * return self.__providers[selector_value](*args, **kwargs) # <<<<<<<<<<<<<< @@ -46309,26 +46309,26 @@ static PyObject *__pyx_f_19dependency_injector_9providers_8Selector__provide(str __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_self->__pyx___providers == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 2554, __pyx_L1_error) + __PYX_ERR(1, 2555, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___providers, __pyx_v_selector_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2554, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->__pyx___providers, __pyx_v_selector_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); - __PYX_ERR(1, 2554, __pyx_L1_error) + __PYX_ERR(1, 2555, __pyx_L1_error) } if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); - __PYX_ERR(1, 2554, __pyx_L1_error) + __PYX_ERR(1, 2555, __pyx_L1_error) } - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2554, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_v_args, __pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2555, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2544 + /* "dependency_injector/providers.pyx":2545 * return dict(self.__providers) * * cpdef object _provide(self, tuple args, dict kwargs): # <<<<<<<<<<<<<< @@ -46387,11 +46387,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_8Selector_9_provide(P case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2544, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, 1); __PYX_ERR(1, 2545, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2544, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_provide") < 0)) __PYX_ERR(1, 2545, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -46404,14 +46404,14 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_8Selector_9_provide(P } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2544, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("_provide", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2545, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.Selector._provide", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2544, __pyx_L1_error) - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2545, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2545, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_8Selector_8_provide(((struct __pyx_obj_19dependency_injector_9providers_Selector *)__pyx_v_self), __pyx_v_args, __pyx_v_kwargs); /* function exit code */ @@ -46432,7 +46432,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8Selector_8_provide(s int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_provide", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_8Selector__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2544, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_8Selector__provide(__pyx_v_self, __pyx_v_args, __pyx_v_kwargs, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2545, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -47086,7 +47086,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_9Injection_2__setstat return __pyx_r; } -/* "dependency_injector/providers.pyx":2564 +/* "dependency_injector/providers.pyx":2565 * """Positional injection class.""" * * def __init__(self, value): # <<<<<<<<<<<<<< @@ -47127,7 +47127,7 @@ static int __pyx_pw_19dependency_injector_9providers_19PositionalInjection_1__in else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2564, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2565, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; @@ -47138,7 +47138,7 @@ static int __pyx_pw_19dependency_injector_9providers_19PositionalInjection_1__in } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2564, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2565, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.PositionalInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -47164,7 +47164,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2566 + /* "dependency_injector/providers.pyx":2567 * def __init__(self, value): * """Initializer.""" * self.__value = value # <<<<<<<<<<<<<< @@ -47177,7 +47177,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini __Pyx_DECREF(__pyx_v_self->__pyx_base.__pyx___value); __pyx_v_self->__pyx_base.__pyx___value = __pyx_v_value; - /* "dependency_injector/providers.pyx":2567 + /* "dependency_injector/providers.pyx":2568 * """Initializer.""" * self.__value = value * self.__is_provider = is_provider(value) # <<<<<<<<<<<<<< @@ -47186,7 +47186,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini */ __pyx_v_self->__pyx_base.__pyx___is_provider = ((int)__pyx_f_19dependency_injector_9providers_is_provider(__pyx_v_value, 0)); - /* "dependency_injector/providers.pyx":2568 + /* "dependency_injector/providers.pyx":2569 * self.__value = value * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) # <<<<<<<<<<<<<< @@ -47195,7 +47195,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini */ __pyx_v_self->__pyx_base.__pyx___is_delegated = ((int)__pyx_f_19dependency_injector_9providers_is_delegated(__pyx_v_value, 0)); - /* "dependency_injector/providers.pyx":2569 + /* "dependency_injector/providers.pyx":2570 * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and # <<<<<<<<<<<<<< @@ -47209,7 +47209,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini goto __pyx_L3_bool_binop_done; } - /* "dependency_injector/providers.pyx":2570 + /* "dependency_injector/providers.pyx":2571 * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and * self.__is_delegated == 0) # <<<<<<<<<<<<<< @@ -47220,7 +47220,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini __pyx_t_1 = __pyx_t_2; __pyx_L3_bool_binop_done:; - /* "dependency_injector/providers.pyx":2569 + /* "dependency_injector/providers.pyx":2570 * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and # <<<<<<<<<<<<<< @@ -47229,14 +47229,14 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini */ __pyx_v_self->__pyx_base.__pyx___call = ((int)__pyx_t_1); - /* "dependency_injector/providers.pyx":2571 + /* "dependency_injector/providers.pyx":2572 * self.__call = (self.__is_provider == 1 and * self.__is_delegated == 0) * super(PositionalInjection, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2571, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_PositionalInjection)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_PositionalInjection)); @@ -47244,10 +47244,10 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2571, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2571, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -47262,12 +47262,12 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2571, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2572, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2564 + /* "dependency_injector/providers.pyx":2565 * """Positional injection class.""" * * def __init__(self, value): # <<<<<<<<<<<<<< @@ -47289,7 +47289,7 @@ static int __pyx_pf_19dependency_injector_9providers_19PositionalInjection___ini return __pyx_r; } -/* "dependency_injector/providers.pyx":2573 +/* "dependency_injector/providers.pyx":2574 * super(PositionalInjection, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -47327,16 +47327,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":2575 + /* "dependency_injector/providers.pyx":2576 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2575, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2575, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -47351,13 +47351,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2575, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2576 + /* "dependency_injector/providers.pyx":2577 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -47368,7 +47368,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":2577 + /* "dependency_injector/providers.pyx":2578 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -47380,7 +47380,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2576 + /* "dependency_injector/providers.pyx":2577 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -47389,7 +47389,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection */ } - /* "dependency_injector/providers.pyx":2578 + /* "dependency_injector/providers.pyx":2579 * if copied is not None: * return copied * return self.__class__(deepcopy(self.__value, memo)) # <<<<<<<<<<<<<< @@ -47397,14 +47397,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection * def get_value(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2578, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_v_self->__pyx_base.__pyx___value; __Pyx_INCREF(__pyx_t_3); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2578, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2579, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2578, __pyx_L1_error) + __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -47420,14 +47420,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2578, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2579, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2573 + /* "dependency_injector/providers.pyx":2574 * super(PositionalInjection, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -47450,7 +47450,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection return __pyx_r; } -/* "dependency_injector/providers.pyx":2580 +/* "dependency_injector/providers.pyx":2581 * return self.__class__(deepcopy(self.__value, memo)) * * def get_value(self): # <<<<<<<<<<<<<< @@ -47481,7 +47481,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_value", 0); - /* "dependency_injector/providers.pyx":2582 + /* "dependency_injector/providers.pyx":2583 * def get_value(self): * """Return injection value.""" * return __get_value(self) # <<<<<<<<<<<<<< @@ -47489,13 +47489,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection * def get_original_value(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_value(((struct __pyx_obj_19dependency_injector_9providers_Injection *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2582, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_value(((struct __pyx_obj_19dependency_injector_9providers_Injection *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2583, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2580 + /* "dependency_injector/providers.pyx":2581 * return self.__class__(deepcopy(self.__value, memo)) * * def get_value(self): # <<<<<<<<<<<<<< @@ -47514,7 +47514,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection return __pyx_r; } -/* "dependency_injector/providers.pyx":2584 +/* "dependency_injector/providers.pyx":2585 * return __get_value(self) * * def get_original_value(self): # <<<<<<<<<<<<<< @@ -47541,7 +47541,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_original_value", 0); - /* "dependency_injector/providers.pyx":2586 + /* "dependency_injector/providers.pyx":2587 * def get_original_value(self): * """Return original value.""" * return self.__value # <<<<<<<<<<<<<< @@ -47553,7 +47553,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection __pyx_r = __pyx_v_self->__pyx_base.__pyx___value; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2584 + /* "dependency_injector/providers.pyx":2585 * return __get_value(self) * * def get_original_value(self): # <<<<<<<<<<<<<< @@ -47878,7 +47878,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_19PositionalInjection return __pyx_r; } -/* "dependency_injector/providers.pyx":2592 +/* "dependency_injector/providers.pyx":2593 * """Keyword injection class.""" * * def __init__(self, name, value): # <<<<<<<<<<<<<< @@ -47924,11 +47924,11 @@ static int __pyx_pw_19dependency_injector_9providers_14NamedInjection_1__init__( case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 2592, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 2593, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2592, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 2593, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -47941,7 +47941,7 @@ static int __pyx_pw_19dependency_injector_9providers_14NamedInjection_1__init__( } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2592, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2593, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.NamedInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -47967,7 +47967,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); - /* "dependency_injector/providers.pyx":2594 + /* "dependency_injector/providers.pyx":2595 * def __init__(self, name, value): * """Initializer.""" * self.__name = name # <<<<<<<<<<<<<< @@ -47980,7 +47980,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s __Pyx_DECREF(__pyx_v_self->__pyx___name); __pyx_v_self->__pyx___name = __pyx_v_name; - /* "dependency_injector/providers.pyx":2595 + /* "dependency_injector/providers.pyx":2596 * """Initializer.""" * self.__name = name * self.__value = value # <<<<<<<<<<<<<< @@ -47993,7 +47993,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s __Pyx_DECREF(__pyx_v_self->__pyx_base.__pyx___value); __pyx_v_self->__pyx_base.__pyx___value = __pyx_v_value; - /* "dependency_injector/providers.pyx":2596 + /* "dependency_injector/providers.pyx":2597 * self.__name = name * self.__value = value * self.__is_provider = is_provider(value) # <<<<<<<<<<<<<< @@ -48002,7 +48002,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s */ __pyx_v_self->__pyx_base.__pyx___is_provider = ((int)__pyx_f_19dependency_injector_9providers_is_provider(__pyx_v_value, 0)); - /* "dependency_injector/providers.pyx":2597 + /* "dependency_injector/providers.pyx":2598 * self.__value = value * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) # <<<<<<<<<<<<<< @@ -48011,7 +48011,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s */ __pyx_v_self->__pyx_base.__pyx___is_delegated = ((int)__pyx_f_19dependency_injector_9providers_is_delegated(__pyx_v_value, 0)); - /* "dependency_injector/providers.pyx":2598 + /* "dependency_injector/providers.pyx":2599 * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and # <<<<<<<<<<<<<< @@ -48025,7 +48025,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s goto __pyx_L3_bool_binop_done; } - /* "dependency_injector/providers.pyx":2599 + /* "dependency_injector/providers.pyx":2600 * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and * self.__is_delegated == 0) # <<<<<<<<<<<<<< @@ -48036,7 +48036,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s __pyx_t_1 = __pyx_t_2; __pyx_L3_bool_binop_done:; - /* "dependency_injector/providers.pyx":2598 + /* "dependency_injector/providers.pyx":2599 * self.__is_provider = is_provider(value) * self.__is_delegated = is_delegated(value) * self.__call = (self.__is_provider == 1 and # <<<<<<<<<<<<<< @@ -48045,14 +48045,14 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s */ __pyx_v_self->__pyx_base.__pyx___call = ((int)__pyx_t_1); - /* "dependency_injector/providers.pyx":2600 + /* "dependency_injector/providers.pyx":2601 * self.__call = (self.__is_provider == 1 and * self.__is_delegated == 0) * super(NamedInjection, self).__init__() # <<<<<<<<<<<<<< * * def __deepcopy__(self, memo): */ - __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2600, __pyx_L1_error) + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_NamedInjection)); __Pyx_GIVEREF(((PyObject *)__pyx_ptype_19dependency_injector_9providers_NamedInjection)); @@ -48060,10 +48060,10 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s __Pyx_INCREF(((PyObject *)__pyx_v_self)); __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_self)); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2600, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_super, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2600, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -48078,12 +48078,12 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2600, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2601, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2592 + /* "dependency_injector/providers.pyx":2593 * """Keyword injection class.""" * * def __init__(self, name, value): # <<<<<<<<<<<<<< @@ -48105,7 +48105,7 @@ static int __pyx_pf_19dependency_injector_9providers_14NamedInjection___init__(s return __pyx_r; } -/* "dependency_injector/providers.pyx":2602 +/* "dependency_injector/providers.pyx":2603 * super(NamedInjection, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -48146,16 +48146,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__deepcopy__", 0); - /* "dependency_injector/providers.pyx":2604 + /* "dependency_injector/providers.pyx":2605 * def __deepcopy__(self, memo): * """Create and return full copy of provider.""" * copied = memo.get(id(self)) # <<<<<<<<<<<<<< * if copied is not None: * return copied */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2604, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_memo, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2604, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -48170,13 +48170,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2604, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_copied = __pyx_t_1; __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2605 + /* "dependency_injector/providers.pyx":2606 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -48187,7 +48187,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { - /* "dependency_injector/providers.pyx":2606 + /* "dependency_injector/providers.pyx":2607 * copied = memo.get(id(self)) * if copied is not None: * return copied # <<<<<<<<<<<<<< @@ -48199,7 +48199,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d __pyx_r = __pyx_v_copied; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2605 + /* "dependency_injector/providers.pyx":2606 * """Create and return full copy of provider.""" * copied = memo.get(id(self)) * if copied is not None: # <<<<<<<<<<<<<< @@ -48208,7 +48208,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d */ } - /* "dependency_injector/providers.pyx":2607 + /* "dependency_injector/providers.pyx":2608 * if copied is not None: * return copied * return self.__class__(deepcopy(self.__name, memo), # <<<<<<<<<<<<<< @@ -48216,18 +48216,18 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_v_self->__pyx___name; __Pyx_INCREF(__pyx_t_3); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2607, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2608, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_4 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2608 + /* "dependency_injector/providers.pyx":2609 * return copied * return self.__class__(deepcopy(self.__name, memo), * deepcopy(self.__value, memo)) # <<<<<<<<<<<<<< @@ -48236,10 +48236,10 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d */ __pyx_t_3 = __pyx_v_self->__pyx_base.__pyx___value; __Pyx_INCREF(__pyx_t_3); - if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2608, __pyx_L1_error) + if (!(likely(PyDict_CheckExact(__pyx_v_memo))||((__pyx_v_memo) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "dict", Py_TYPE(__pyx_v_memo)->tp_name), 0))) __PYX_ERR(1, 2609, __pyx_L1_error) __pyx_t_7.__pyx_n = 1; __pyx_t_7.memo = ((PyObject*)__pyx_v_memo); - __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2608, __pyx_L1_error) + __pyx_t_8 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_t_3, 0, &__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -48257,7 +48257,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_8}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -48267,7 +48267,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_t_4, __pyx_t_8}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -48275,7 +48275,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d } else #endif { - __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -48286,7 +48286,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_8); __pyx_t_4 = 0; __pyx_t_8 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2607, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2608, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } @@ -48295,7 +48295,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2602 + /* "dependency_injector/providers.pyx":2603 * super(NamedInjection, self).__init__() * * def __deepcopy__(self, memo): # <<<<<<<<<<<<<< @@ -48320,7 +48320,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_2__d return __pyx_r; } -/* "dependency_injector/providers.pyx":2610 +/* "dependency_injector/providers.pyx":2611 * deepcopy(self.__value, memo)) * * def get_name(self): # <<<<<<<<<<<<<< @@ -48351,7 +48351,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_4get int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_name", 0); - /* "dependency_injector/providers.pyx":2612 + /* "dependency_injector/providers.pyx":2613 * def get_name(self): * """Return injection value.""" * return __get_name(self) # <<<<<<<<<<<<<< @@ -48359,13 +48359,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_4get * def get_value(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_name(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2612, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_name(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2613, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2610 + /* "dependency_injector/providers.pyx":2611 * deepcopy(self.__value, memo)) * * def get_name(self): # <<<<<<<<<<<<<< @@ -48384,7 +48384,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_4get return __pyx_r; } -/* "dependency_injector/providers.pyx":2614 +/* "dependency_injector/providers.pyx":2615 * return __get_name(self) * * def get_value(self): # <<<<<<<<<<<<<< @@ -48415,7 +48415,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_6get int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_value", 0); - /* "dependency_injector/providers.pyx":2616 + /* "dependency_injector/providers.pyx":2617 * def get_value(self): * """Return injection value.""" * return __get_value(self) # <<<<<<<<<<<<<< @@ -48423,13 +48423,13 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_6get * def get_original_value(self): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_value(((struct __pyx_obj_19dependency_injector_9providers_Injection *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2616, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers___get_value(((struct __pyx_obj_19dependency_injector_9providers_Injection *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2617, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2614 + /* "dependency_injector/providers.pyx":2615 * return __get_name(self) * * def get_value(self): # <<<<<<<<<<<<<< @@ -48448,7 +48448,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_6get return __pyx_r; } -/* "dependency_injector/providers.pyx":2618 +/* "dependency_injector/providers.pyx":2619 * return __get_value(self) * * def get_original_value(self): # <<<<<<<<<<<<<< @@ -48475,7 +48475,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_8get __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_original_value", 0); - /* "dependency_injector/providers.pyx":2620 + /* "dependency_injector/providers.pyx":2621 * def get_original_value(self): * """Return original value.""" * return self.__value # <<<<<<<<<<<<<< @@ -48487,7 +48487,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_8get __pyx_r = __pyx_v_self->__pyx_base.__pyx___value; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2618 + /* "dependency_injector/providers.pyx":2619 * return __get_value(self) * * def get_original_value(self): # <<<<<<<<<<<<<< @@ -48826,7 +48826,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14NamedInjection_12__ return __pyx_r; } -/* "dependency_injector/providers.pyx":2625 +/* "dependency_injector/providers.pyx":2626 * @cython.boundscheck(False) * @cython.wraparound(False) * cpdef tuple parse_positional_injections(tuple args): # <<<<<<<<<<<<<< @@ -48854,19 +48854,19 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_positional_injec int __pyx_clineno = 0; __Pyx_RefNannySetupContext("parse_positional_injections", 0); - /* "dependency_injector/providers.pyx":2627 + /* "dependency_injector/providers.pyx":2628 * cpdef tuple parse_positional_injections(tuple args): * """Parse positional injections.""" * cdef list injections = list() # <<<<<<<<<<<<<< * cdef int args_len = len(args) * */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2627, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_injections = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2628 + /* "dependency_injector/providers.pyx":2629 * """Parse positional injections.""" * cdef list injections = list() * cdef int args_len = len(args) # <<<<<<<<<<<<<< @@ -48875,12 +48875,12 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_positional_injec */ if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); - __PYX_ERR(1, 2628, __pyx_L1_error) + __PYX_ERR(1, 2629, __pyx_L1_error) } - __pyx_t_2 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2628, __pyx_L1_error) + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 2629, __pyx_L1_error) __pyx_v_args_len = __pyx_t_2; - /* "dependency_injector/providers.pyx":2634 + /* "dependency_injector/providers.pyx":2635 * cdef PositionalInjection injection * * for index in range(args_len): # <<<<<<<<<<<<<< @@ -48892,7 +48892,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_positional_injec for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { __pyx_v_index = __pyx_t_5; - /* "dependency_injector/providers.pyx":2635 + /* "dependency_injector/providers.pyx":2636 * * for index in range(args_len): * arg = args[index] # <<<<<<<<<<<<<< @@ -48901,36 +48901,36 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_positional_injec */ if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(1, 2635, __pyx_L1_error) + __PYX_ERR(1, 2636, __pyx_L1_error) } __pyx_t_1 = PyTuple_GET_ITEM(__pyx_v_args, __pyx_v_index); __Pyx_INCREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2636 + /* "dependency_injector/providers.pyx":2637 * for index in range(args_len): * arg = args[index] * injection = PositionalInjection(arg) # <<<<<<<<<<<<<< * injections.append(injection) * */ - __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_19dependency_injector_9providers_PositionalInjection), __pyx_v_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2636, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_19dependency_injector_9providers_PositionalInjection), __pyx_v_arg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2637, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XDECREF_SET(__pyx_v_injection, ((struct __pyx_obj_19dependency_injector_9providers_PositionalInjection *)__pyx_t_1)); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2637 + /* "dependency_injector/providers.pyx":2638 * arg = args[index] * injection = PositionalInjection(arg) * injections.append(injection) # <<<<<<<<<<<<<< * * return tuple(injections) */ - __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 2637, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 2638, __pyx_L1_error) } - /* "dependency_injector/providers.pyx":2639 + /* "dependency_injector/providers.pyx":2640 * injections.append(injection) * * return tuple(injections) # <<<<<<<<<<<<<< @@ -48938,13 +48938,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_positional_injec * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2639, __pyx_L1_error) + __pyx_t_1 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2640, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2625 + /* "dependency_injector/providers.pyx":2626 * @cython.boundscheck(False) * @cython.wraparound(False) * cpdef tuple parse_positional_injections(tuple args): # <<<<<<<<<<<<<< @@ -48976,7 +48976,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_7parse_positional_inj PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("parse_positional_injections (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2625, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) __PYX_ERR(1, 2626, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_6parse_positional_injections(__pyx_self, ((PyObject*)__pyx_v_args)); /* function exit code */ @@ -48997,7 +48997,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_6parse_positional_inj int __pyx_clineno = 0; __Pyx_RefNannySetupContext("parse_positional_injections", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2625, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49014,7 +49014,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_6parse_positional_inj return __pyx_r; } -/* "dependency_injector/providers.pyx":2644 +/* "dependency_injector/providers.pyx":2645 * @cython.boundscheck(False) * @cython.wraparound(False) * cpdef tuple parse_named_injections(dict kwargs): # <<<<<<<<<<<<<< @@ -49044,19 +49044,19 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections int __pyx_clineno = 0; __Pyx_RefNannySetupContext("parse_named_injections", 0); - /* "dependency_injector/providers.pyx":2646 + /* "dependency_injector/providers.pyx":2647 * cpdef tuple parse_named_injections(dict kwargs): * """Parse named injections.""" * cdef list injections = list() # <<<<<<<<<<<<<< * * cdef object name */ - __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2646, __pyx_L1_error) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2647, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_injections = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2652 + /* "dependency_injector/providers.pyx":2653 * cdef NamedInjection injection * * for name, arg in kwargs.items(): # <<<<<<<<<<<<<< @@ -49065,17 +49065,17 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections */ if (unlikely(__pyx_v_kwargs == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); - __PYX_ERR(1, 2652, __pyx_L1_error) + __PYX_ERR(1, 2653, __pyx_L1_error) } - __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; __pyx_t_4 = NULL; } else { - __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2653, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -49083,17 +49083,17 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2653, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 2653, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -49103,7 +49103,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 2652, __pyx_L1_error) + else __PYX_ERR(1, 2653, __pyx_L1_error) } break; } @@ -49115,7 +49115,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 2652, __pyx_L1_error) + __PYX_ERR(1, 2653, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -49128,15 +49128,15 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2652, __pyx_L1_error) + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2653, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; @@ -49144,7 +49144,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections __Pyx_GOTREF(__pyx_t_5); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2652, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2653, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; @@ -49152,7 +49152,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 2652, __pyx_L1_error) + __PYX_ERR(1, 2653, __pyx_L1_error) __pyx_L6_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); @@ -49160,14 +49160,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2653 + /* "dependency_injector/providers.pyx":2654 * * for name, arg in kwargs.items(): * injection = NamedInjection(name, arg) # <<<<<<<<<<<<<< * injections.append(injection) * */ - __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2653, __pyx_L1_error) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); @@ -49175,22 +49175,22 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg); - __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_NamedInjection), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2653, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_9providers_NamedInjection), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_injection, ((struct __pyx_obj_19dependency_injector_9providers_NamedInjection *)__pyx_t_6)); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2654 + /* "dependency_injector/providers.pyx":2655 * for name, arg in kwargs.items(): * injection = NamedInjection(name, arg) * injections.append(injection) # <<<<<<<<<<<<<< * * return tuple(injections) */ - __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 2654, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 2655, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2652 + /* "dependency_injector/providers.pyx":2653 * cdef NamedInjection injection * * for name, arg in kwargs.items(): # <<<<<<<<<<<<<< @@ -49200,7 +49200,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2656 + /* "dependency_injector/providers.pyx":2657 * injections.append(injection) * * return tuple(injections) # <<<<<<<<<<<<<< @@ -49208,13 +49208,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_parse_named_injections * */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2656, __pyx_L1_error) + __pyx_t_2 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2657, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_r = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2644 + /* "dependency_injector/providers.pyx":2645 * @cython.boundscheck(False) * @cython.wraparound(False) * cpdef tuple parse_named_injections(dict kwargs): # <<<<<<<<<<<<<< @@ -49251,7 +49251,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_9parse_named_injectio PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("parse_named_injections (wrapper)", 0); - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2644, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kwargs), (&PyDict_Type), 1, "kwargs", 1))) __PYX_ERR(1, 2645, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_8parse_named_injections(__pyx_self, ((PyObject*)__pyx_v_kwargs)); /* function exit code */ @@ -49272,7 +49272,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8parse_named_injectio int __pyx_clineno = 0; __Pyx_RefNannySetupContext("parse_named_injections", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2644, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49289,7 +49289,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_8parse_named_injectio return __pyx_r; } -/* "dependency_injector/providers.pyx":2659 +/* "dependency_injector/providers.pyx":2660 * * * cpdef bint is_provider(object instance): # <<<<<<<<<<<<<< @@ -49310,7 +49310,7 @@ static int __pyx_f_19dependency_injector_9providers_is_provider(PyObject *__pyx_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_provider", 0); - /* "dependency_injector/providers.pyx":2667 + /* "dependency_injector/providers.pyx":2668 * :rtype: bool * """ * return (not isinstance(instance, CLASS_TYPES) and # <<<<<<<<<<<<<< @@ -49319,7 +49319,7 @@ static int __pyx_f_19dependency_injector_9providers_is_provider(PyObject *__pyx_ */ __pyx_t_2 = __pyx_v_19dependency_injector_9providers_CLASS_TYPES; __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = PyObject_IsInstance(__pyx_v_instance, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 2667, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_instance, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 2668, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_4) { @@ -49328,14 +49328,14 @@ static int __pyx_f_19dependency_injector_9providers_is_provider(PyObject *__pyx_ goto __pyx_L3_bool_binop_done; } - /* "dependency_injector/providers.pyx":2668 + /* "dependency_injector/providers.pyx":2669 * """ * return (not isinstance(instance, CLASS_TYPES) and * getattr(instance, '__IS_PROVIDER__', False) is True) # <<<<<<<<<<<<<< * * */ - __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_instance, __pyx_n_s_IS_PROVIDER, Py_False); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2668, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_instance, __pyx_n_s_IS_PROVIDER, Py_False); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2669, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_t_2 == Py_True); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -49345,7 +49345,7 @@ static int __pyx_f_19dependency_injector_9providers_is_provider(PyObject *__pyx_ __pyx_r = __pyx_t_1; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2659 + /* "dependency_injector/providers.pyx":2660 * * * cpdef bint is_provider(object instance): # <<<<<<<<<<<<<< @@ -49386,7 +49386,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_10is_provider(CYTHON_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_provider", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_19dependency_injector_9providers_is_provider(__pyx_v_instance, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2659, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_19dependency_injector_9providers_is_provider(__pyx_v_instance, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2660, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49403,7 +49403,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_10is_provider(CYTHON_ return __pyx_r; } -/* "dependency_injector/providers.pyx":2671 +/* "dependency_injector/providers.pyx":2672 * * * cpdef object ensure_is_provider(object instance): # <<<<<<<<<<<<<< @@ -49427,7 +49427,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ensure_is_provider", 0); - /* "dependency_injector/providers.pyx":2682 + /* "dependency_injector/providers.pyx":2683 * :rtype: :py:class:`dependency_injector.providers.Provider` * """ * if not is_provider(instance): # <<<<<<<<<<<<<< @@ -49437,26 +49437,26 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO __pyx_t_1 = ((!(__pyx_f_19dependency_injector_9providers_is_provider(__pyx_v_instance, 0) != 0)) != 0); if (unlikely(__pyx_t_1)) { - /* "dependency_injector/providers.pyx":2683 + /* "dependency_injector/providers.pyx":2684 * """ * if not is_provider(instance): * raise Error('Expected provider instance, ' # <<<<<<<<<<<<<< * 'got {0}'.format(str(instance))) * return instance */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2683, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Error); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - /* "dependency_injector/providers.pyx":2684 + /* "dependency_injector/providers.pyx":2685 * if not is_provider(instance): * raise Error('Expected provider instance, ' * 'got {0}'.format(str(instance))) # <<<<<<<<<<<<<< * return instance * */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Expected_provider_instance_got_0, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2684, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_Expected_provider_instance_got_0, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_instance); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2684, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyString_Type)), __pyx_v_instance); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { @@ -49471,7 +49471,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2684, __pyx_L1_error) + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2685, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -49487,14 +49487,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2683, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2684, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __PYX_ERR(1, 2683, __pyx_L1_error) + __PYX_ERR(1, 2684, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2682 + /* "dependency_injector/providers.pyx":2683 * :rtype: :py:class:`dependency_injector.providers.Provider` * """ * if not is_provider(instance): # <<<<<<<<<<<<<< @@ -49503,7 +49503,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO */ } - /* "dependency_injector/providers.pyx":2685 + /* "dependency_injector/providers.pyx":2686 * raise Error('Expected provider instance, ' * 'got {0}'.format(str(instance))) * return instance # <<<<<<<<<<<<<< @@ -49515,7 +49515,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_ensure_is_provider(PyO __pyx_r = __pyx_v_instance; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2671 + /* "dependency_injector/providers.pyx":2672 * * * cpdef object ensure_is_provider(object instance): # <<<<<<<<<<<<<< @@ -49562,7 +49562,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_12ensure_is_provider( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("ensure_is_provider", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_ensure_is_provider(__pyx_v_instance, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2671, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_ensure_is_provider(__pyx_v_instance, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2672, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49579,7 +49579,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_12ensure_is_provider( return __pyx_r; } -/* "dependency_injector/providers.pyx":2688 +/* "dependency_injector/providers.pyx":2689 * * * cpdef bint is_delegated(object instance): # <<<<<<<<<<<<<< @@ -49600,7 +49600,7 @@ static int __pyx_f_19dependency_injector_9providers_is_delegated(PyObject *__pyx int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_delegated", 0); - /* "dependency_injector/providers.pyx":2696 + /* "dependency_injector/providers.pyx":2697 * :rtype: bool * """ * return (not isinstance(instance, CLASS_TYPES) and # <<<<<<<<<<<<<< @@ -49609,7 +49609,7 @@ static int __pyx_f_19dependency_injector_9providers_is_delegated(PyObject *__pyx */ __pyx_t_2 = __pyx_v_19dependency_injector_9providers_CLASS_TYPES; __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = PyObject_IsInstance(__pyx_v_instance, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 2696, __pyx_L1_error) + __pyx_t_3 = PyObject_IsInstance(__pyx_v_instance, __pyx_t_2); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 2697, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_4) { @@ -49618,14 +49618,14 @@ static int __pyx_f_19dependency_injector_9providers_is_delegated(PyObject *__pyx goto __pyx_L3_bool_binop_done; } - /* "dependency_injector/providers.pyx":2697 + /* "dependency_injector/providers.pyx":2698 * """ * return (not isinstance(instance, CLASS_TYPES) and * getattr(instance, '__IS_DELEGATED__', False) is True) # <<<<<<<<<<<<<< * * */ - __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_instance, __pyx_n_s_IS_DELEGATED, Py_False); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2697, __pyx_L1_error) + __pyx_t_2 = __Pyx_GetAttr3(__pyx_v_instance, __pyx_n_s_IS_DELEGATED, Py_False); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2698, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = (__pyx_t_2 == Py_True); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -49635,7 +49635,7 @@ static int __pyx_f_19dependency_injector_9providers_is_delegated(PyObject *__pyx __pyx_r = __pyx_t_1; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2688 + /* "dependency_injector/providers.pyx":2689 * * * cpdef bint is_delegated(object instance): # <<<<<<<<<<<<<< @@ -49676,7 +49676,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14is_delegated(CYTHON int __pyx_clineno = 0; __Pyx_RefNannySetupContext("is_delegated", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_19dependency_injector_9providers_is_delegated(__pyx_v_instance, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2688, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_19dependency_injector_9providers_is_delegated(__pyx_v_instance, 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2689, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49693,7 +49693,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_14is_delegated(CYTHON return __pyx_r; } -/* "dependency_injector/providers.pyx":2700 +/* "dependency_injector/providers.pyx":2701 * * * cpdef str represent_provider(object provider, object provides): # <<<<<<<<<<<<<< @@ -49716,7 +49716,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_represent_provider(PyO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("represent_provider", 0); - /* "dependency_injector/providers.pyx":2712 + /* "dependency_injector/providers.pyx":2713 * :rtype: str * """ * return '<{provider}({provides}) at {address}>'.format( # <<<<<<<<<<<<<< @@ -49724,45 +49724,45 @@ static PyObject *__pyx_f_19dependency_injector_9providers_represent_provider(PyO * provider.__class__.__name__)), */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_provider_provides_at_address, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2712, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_provider_provides_at_address, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2713, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - /* "dependency_injector/providers.pyx":2713 + /* "dependency_injector/providers.pyx":2714 * """ * return '<{provider}({provides}) at {address}>'.format( * provider='.'.join((provider.__class__.__module__, # <<<<<<<<<<<<<< * provider.__class__.__name__)), * provides=repr(provides) if provides is not None else '', */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2713, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_provider, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2713, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_provider, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2713, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2714 + /* "dependency_injector/providers.pyx":2715 * 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))) */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_provider, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2714, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_provider, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2714, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2713 + /* "dependency_injector/providers.pyx":2714 * """ * return '<{provider}({provides}) at {address}>'.format( * provider='.'.join((provider.__class__.__module__, # <<<<<<<<<<<<<< * provider.__class__.__name__)), * provides=repr(provides) if provides is not None else '', */ - __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2713, __pyx_L1_error) + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); @@ -49770,13 +49770,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_represent_provider(PyO PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); __pyx_t_4 = 0; __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2713, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provider, __pyx_t_5) < 0) __PYX_ERR(1, 2713, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provider, __pyx_t_5) < 0) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":2715 + /* "dependency_injector/providers.pyx":2716 * provider='.'.join((provider.__class__.__module__, * provider.__class__.__name__)), * provides=repr(provides) if provides is not None else '', # <<<<<<<<<<<<<< @@ -49785,7 +49785,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_represent_provider(PyO */ __pyx_t_6 = (__pyx_v_provides != Py_None); if ((__pyx_t_6 != 0)) { - __pyx_t_3 = PyObject_Repr(__pyx_v_provides); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2715, __pyx_L1_error) + __pyx_t_3 = PyObject_Repr(__pyx_v_provides); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2716, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_t_3; __pyx_t_3 = 0; @@ -49793,41 +49793,41 @@ static PyObject *__pyx_f_19dependency_injector_9providers_represent_provider(PyO __Pyx_INCREF(__pyx_kp_s__8); __pyx_t_5 = __pyx_kp_s__8; } - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provides, __pyx_t_5) < 0) __PYX_ERR(1, 2713, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_provides, __pyx_t_5) < 0) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "dependency_injector/providers.pyx":2716 + /* "dependency_injector/providers.pyx":2717 * provider.__class__.__name__)), * provides=repr(provides) if provides is not None else '', * address=hex(id(provider))) # <<<<<<<<<<<<<< * * */ - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_v_provider); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2716, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_v_provider); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_hex, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2716, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_hex, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2717, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_address, __pyx_t_3) < 0) __PYX_ERR(1, 2713, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_address, __pyx_t_3) < 0) __PYX_ERR(1, 2714, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2712 + /* "dependency_injector/providers.pyx":2713 * :rtype: str * """ * return '<{provider}({provides}) at {address}>'.format( # <<<<<<<<<<<<<< * provider='.'.join((provider.__class__.__module__, * provider.__class__.__name__)), */ - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2712, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2713, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 2712, __pyx_L1_error) + if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 2713, __pyx_L1_error) __pyx_r = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2700 + /* "dependency_injector/providers.pyx":2701 * * * cpdef str represent_provider(object provider, object provides): # <<<<<<<<<<<<<< @@ -49885,11 +49885,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_17represent_provider( case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_provides)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("represent_provider", 1, 2, 2, 1); __PYX_ERR(1, 2700, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("represent_provider", 1, 2, 2, 1); __PYX_ERR(1, 2701, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "represent_provider") < 0)) __PYX_ERR(1, 2700, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "represent_provider") < 0)) __PYX_ERR(1, 2701, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -49902,7 +49902,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_17represent_provider( } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("represent_provider", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2700, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("represent_provider", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2701, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.represent_provider", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -49924,7 +49924,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16represent_provider( int __pyx_clineno = 0; __Pyx_RefNannySetupContext("represent_provider", 0); __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(__pyx_v_provider, __pyx_v_provides, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2700, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_represent_provider(__pyx_v_provider, __pyx_v_provides, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2701, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -49941,7 +49941,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_16represent_provider( return __pyx_r; } -/* "dependency_injector/providers.pyx":2719 +/* "dependency_injector/providers.pyx":2720 * * * cpdef object deepcopy(object instance, dict memo=None): # <<<<<<<<<<<<<< @@ -49972,7 +49972,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p } __Pyx_INCREF(__pyx_v_memo); - /* "dependency_injector/providers.pyx":2721 + /* "dependency_injector/providers.pyx":2722 * cpdef object deepcopy(object instance, dict memo=None): * """Return full copy of provider or container with providers.""" * if memo is None: # <<<<<<<<<<<<<< @@ -49983,19 +49983,19 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { - /* "dependency_injector/providers.pyx":2722 + /* "dependency_injector/providers.pyx":2723 * """Return full copy of provider or container with providers.""" * if memo is None: * memo = dict() # <<<<<<<<<<<<<< * * __add_sys_streams(memo) */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2722, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2723, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_memo, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2721 + /* "dependency_injector/providers.pyx":2722 * cpdef object deepcopy(object instance, dict memo=None): * """Return full copy of provider or container with providers.""" * if memo is None: # <<<<<<<<<<<<<< @@ -50004,14 +50004,14 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p */ } - /* "dependency_injector/providers.pyx":2724 + /* "dependency_injector/providers.pyx":2725 * memo = dict() * * __add_sys_streams(memo) # <<<<<<<<<<<<<< * * return copy.deepcopy(instance, memo) */ - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_add_sys_streams); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2724, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_add_sys_streams); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { @@ -50025,12 +50025,12 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_v_memo) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_memo); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2724, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2725, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dependency_injector/providers.pyx":2726 + /* "dependency_injector/providers.pyx":2727 * __add_sys_streams(memo) * * return copy.deepcopy(instance, memo) # <<<<<<<<<<<<<< @@ -50038,9 +50038,9 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p * def __add_sys_streams(memo): */ __Pyx_XDECREF(__pyx_r); - __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2726, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_deepcopy); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2726, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_deepcopy); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -50058,7 +50058,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_instance, __pyx_v_memo}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2726, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_3); } else @@ -50066,13 +50066,13 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_v_instance, __pyx_v_memo}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2726, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_3); } else #endif { - __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2726, __pyx_L1_error) + __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -50083,7 +50083,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p __Pyx_INCREF(__pyx_v_memo); __Pyx_GIVEREF(__pyx_v_memo); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_memo); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2726, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2727, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } @@ -50092,7 +50092,7 @@ static PyObject *__pyx_f_19dependency_injector_9providers_deepcopy(PyObject *__p __pyx_t_3 = 0; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2719 + /* "dependency_injector/providers.pyx":2720 * * * cpdef object deepcopy(object instance, dict memo=None): # <<<<<<<<<<<<<< @@ -50155,7 +50155,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_19deepcopy(PyObject * } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "deepcopy") < 0)) __PYX_ERR(1, 2719, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "deepcopy") < 0)) __PYX_ERR(1, 2720, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { @@ -50171,13 +50171,13 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_19deepcopy(PyObject * } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("deepcopy", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2719, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("deepcopy", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2720, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.deepcopy", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_memo), (&PyDict_Type), 1, "memo", 1))) __PYX_ERR(1, 2719, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_memo), (&PyDict_Type), 1, "memo", 1))) __PYX_ERR(1, 2720, __pyx_L1_error) __pyx_r = __pyx_pf_19dependency_injector_9providers_18deepcopy(__pyx_self, __pyx_v_instance, __pyx_v_memo); /* function exit code */ @@ -50201,7 +50201,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_18deepcopy(CYTHON_UNU __Pyx_XDECREF(__pyx_r); __pyx_t_2.__pyx_n = 1; __pyx_t_2.memo = __pyx_v_memo; - __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_instance, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2719, __pyx_L1_error) + __pyx_t_1 = __pyx_f_19dependency_injector_9providers_deepcopy(__pyx_v_instance, 0, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; @@ -50218,7 +50218,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_18deepcopy(CYTHON_UNU return __pyx_r; } -/* "dependency_injector/providers.pyx":2728 +/* "dependency_injector/providers.pyx":2729 * return copy.deepcopy(instance, memo) * * def __add_sys_streams(memo): # <<<<<<<<<<<<<< @@ -50252,79 +50252,79 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_20__add_sys_streams(C int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__add_sys_streams", 0); - /* "dependency_injector/providers.pyx":2734 + /* "dependency_injector/providers.pyx":2735 * objects graph. * """ * memo[id(sys.stdin)] = sys.stdin # <<<<<<<<<<<<<< * memo[id(sys.stdout)] = sys.stdout * memo[id(sys.stderr)] = sys.stderr */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2734, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stdin); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2734, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stdin); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2734, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stdin); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2734, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stdin); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2734, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, __pyx_t_2) < 0)) __PYX_ERR(1, 2734, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, __pyx_t_2) < 0)) __PYX_ERR(1, 2735, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2735 + /* "dependency_injector/providers.pyx":2736 * """ * memo[id(sys.stdin)] = sys.stdin * memo[id(sys.stdout)] = sys.stdout # <<<<<<<<<<<<<< * memo[id(sys.stderr)] = sys.stderr * */ - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2735, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stdout); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2735, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stdout); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2735, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stdout); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2735, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stdout); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2735, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_2, __pyx_t_1) < 0)) __PYX_ERR(1, 2735, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_2, __pyx_t_1) < 0)) __PYX_ERR(1, 2736, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2736 + /* "dependency_injector/providers.pyx":2737 * memo[id(sys.stdin)] = sys.stdin * memo[id(sys.stdout)] = sys.stdout * memo[id(sys.stderr)] = sys.stderr # <<<<<<<<<<<<<< * * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2736, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2736, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2736, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2736, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2736, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, __pyx_t_2) < 0)) __PYX_ERR(1, 2736, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_memo, __pyx_t_1, __pyx_t_2) < 0)) __PYX_ERR(1, 2737, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2728 + /* "dependency_injector/providers.pyx":2729 * return copy.deepcopy(instance, memo) * * def __add_sys_streams(memo): # <<<<<<<<<<<<<< @@ -50347,7 +50347,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_20__add_sys_streams(C return __pyx_r; } -/* "dependency_injector/providers.pyx":2739 +/* "dependency_injector/providers.pyx":2740 * * * def merge_dicts(dict1, dict2): # <<<<<<<<<<<<<< @@ -50391,11 +50391,11 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_23merge_dicts(PyObjec case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dict2)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("merge_dicts", 1, 2, 2, 1); __PYX_ERR(1, 2739, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("merge_dicts", 1, 2, 2, 1); __PYX_ERR(1, 2740, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "merge_dicts") < 0)) __PYX_ERR(1, 2739, __pyx_L3_error) + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "merge_dicts") < 0)) __PYX_ERR(1, 2740, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; @@ -50408,7 +50408,7 @@ static PyObject *__pyx_pw_19dependency_injector_9providers_23merge_dicts(PyObjec } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("merge_dicts", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2739, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("merge_dicts", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2740, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("dependency_injector.providers.merge_dicts", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -50445,14 +50445,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ int __pyx_clineno = 0; __Pyx_RefNannySetupContext("merge_dicts", 0); - /* "dependency_injector/providers.pyx":2751 + /* "dependency_injector/providers.pyx":2752 * :rtype: dict * """ * for key, value in dict1.items(): # <<<<<<<<<<<<<< * if key in dict2: * if isinstance(value, dict) and isinstance(dict2[key], dict): */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dict1, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dict1, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { @@ -50466,16 +50466,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2751, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0; __pyx_t_5 = NULL; } else { - __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2752, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { @@ -50483,17 +50483,17 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 2752, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(1, 2752, __pyx_L1_error) #else - __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } @@ -50503,7 +50503,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 2751, __pyx_L1_error) + else __PYX_ERR(1, 2752, __pyx_L1_error) } break; } @@ -50515,7 +50515,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 2751, __pyx_L1_error) + __PYX_ERR(1, 2752, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { @@ -50528,15 +50528,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2751, __pyx_L1_error) + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; @@ -50544,7 +50544,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __Pyx_GOTREF(__pyx_t_3); index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2751, __pyx_L1_error) + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(1, 2752, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; @@ -50552,7 +50552,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 2751, __pyx_L1_error) + __PYX_ERR(1, 2752, __pyx_L1_error) __pyx_L6_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_3); @@ -50560,18 +50560,18 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); __pyx_t_6 = 0; - /* "dependency_injector/providers.pyx":2752 + /* "dependency_injector/providers.pyx":2753 * """ * for key, value in dict1.items(): * if key in dict2: # <<<<<<<<<<<<<< * if isinstance(value, dict) and isinstance(dict2[key], dict): * dict2[key] = merge_dicts(value, dict2[key]) */ - __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_dict2, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(1, 2752, __pyx_L1_error) + __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_v_key, __pyx_v_dict2, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(1, 2753, __pyx_L1_error) __pyx_t_10 = (__pyx_t_9 != 0); if (__pyx_t_10) { - /* "dependency_injector/providers.pyx":2753 + /* "dependency_injector/providers.pyx":2754 * for key, value in dict1.items(): * if key in dict2: * if isinstance(value, dict) and isinstance(dict2[key], dict): # <<<<<<<<<<<<<< @@ -50585,7 +50585,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __pyx_t_10 = __pyx_t_11; goto __pyx_L9_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_dict2, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2753, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_dict2, __pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = PyDict_Check(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -50594,16 +50594,16 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __pyx_L9_bool_binop_done:; if (__pyx_t_10) { - /* "dependency_injector/providers.pyx":2754 + /* "dependency_injector/providers.pyx":2755 * if key in dict2: * if isinstance(value, dict) and isinstance(dict2[key], dict): * dict2[key] = merge_dicts(value, dict2[key]) # <<<<<<<<<<<<<< * result = dict1.copy() * result.update(dict2) */ - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2754, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_merge_dicts); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_dict2, __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2754, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_dict2, __pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = NULL; __pyx_t_12 = 0; @@ -50620,7 +50620,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_value, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2754, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -50629,14 +50629,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_value, __pyx_t_3}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2754, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { - __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 2754, __pyx_L1_error) + __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL; @@ -50647,15 +50647,15 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2754, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(PyObject_SetItem(__pyx_v_dict2, __pyx_v_key, __pyx_t_1) < 0)) __PYX_ERR(1, 2754, __pyx_L1_error) + if (unlikely(PyObject_SetItem(__pyx_v_dict2, __pyx_v_key, __pyx_t_1) < 0)) __PYX_ERR(1, 2755, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "dependency_injector/providers.pyx":2753 + /* "dependency_injector/providers.pyx":2754 * for key, value in dict1.items(): * if key in dict2: * if isinstance(value, dict) and isinstance(dict2[key], dict): # <<<<<<<<<<<<<< @@ -50664,7 +50664,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ */ } - /* "dependency_injector/providers.pyx":2752 + /* "dependency_injector/providers.pyx":2753 * """ * for key, value in dict1.items(): * if key in dict2: # <<<<<<<<<<<<<< @@ -50673,7 +50673,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ */ } - /* "dependency_injector/providers.pyx":2751 + /* "dependency_injector/providers.pyx":2752 * :rtype: dict * """ * for key, value in dict1.items(): # <<<<<<<<<<<<<< @@ -50683,14 +50683,14 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2755 + /* "dependency_injector/providers.pyx":2756 * if isinstance(value, dict) and isinstance(dict2[key], dict): * dict2[key] = merge_dicts(value, dict2[key]) * result = dict1.copy() # <<<<<<<<<<<<<< * result.update(dict2) * return result */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dict1, __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2755, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dict1, __pyx_n_s_copy); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { @@ -50704,19 +50704,19 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ } __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2755, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2756, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_result = __pyx_t_2; __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2756 + /* "dependency_injector/providers.pyx":2757 * dict2[key] = merge_dicts(value, dict2[key]) * result = dict1.copy() * result.update(dict2) # <<<<<<<<<<<<<< * return result */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_update); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2756, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result, __pyx_n_s_update); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { @@ -50730,12 +50730,12 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ } __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_v_dict2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_dict2); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2756, __pyx_L1_error) + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dependency_injector/providers.pyx":2757 + /* "dependency_injector/providers.pyx":2758 * result = dict1.copy() * result.update(dict2) * return result # <<<<<<<<<<<<<< @@ -50745,7 +50745,7 @@ static PyObject *__pyx_pf_19dependency_injector_9providers_22merge_dicts(CYTHON_ __pyx_r = __pyx_v_result; goto __pyx_L0; - /* "dependency_injector/providers.pyx":2739 + /* "dependency_injector/providers.pyx":2740 * * * def merge_dicts(dict1, dict2): # <<<<<<<<<<<<<< @@ -70407,7 +70407,7 @@ static PyTypeObject __pyx_type_19dependency_injector_9providers_Configuration = 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - "Configuration provider provides configuration options to the other providers.\n\n .. code-block:: python\n config = Configuration('config')\n print(config.section1.option1()) # None\n print(config.section1.option2()) # None\n config.from_dict(\n {\n 'section1': {\n 'option1': 1,\n 'option2': 2,\n },\n },\n )\n print(config.section1.option1()) # 1\n print(config.section1.option2()) # 2\n ", /*tp_doc*/ + "Configuration provider provides configuration options to the other providers.\n\n .. code-block:: python\n\n config = Configuration('config')\n print(config.section1.option1()) # None\n print(config.section1.option2()) # None\n config.from_dict(\n {\n 'section1': {\n 'option1': 1,\n 'option2': 2,\n },\n },\n )\n print(config.section1.option1()) # 1\n print(config.section1.option2()) # 2\n ", /*tp_doc*/ __pyx_tp_traverse_19dependency_injector_9providers_Configuration, /*tp_traverse*/ __pyx_tp_clear_19dependency_injector_9providers_Configuration, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -73765,7 +73765,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(1, 274, __pyx_L1_error) __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 426, __pyx_L1_error) __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(1, 584, __pyx_L1_error) - __pyx_builtin_hex = __Pyx_GetBuiltinName(__pyx_n_s_hex); if (!__pyx_builtin_hex) __PYX_ERR(1, 2536, __pyx_L1_error) + __pyx_builtin_hex = __Pyx_GetBuiltinName(__pyx_n_s_hex); if (!__pyx_builtin_hex) __PYX_ERR(1, 2537, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; @@ -73867,29 +73867,29 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__18); __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dependency_injector_provider, __pyx_n_s_parse_ini_file, 78, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 78, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2728 + /* "dependency_injector/providers.pyx":2729 * return copy.deepcopy(instance, memo) * * def __add_sys_streams(memo): # <<<<<<<<<<<<<< * """Add system streams to memo dictionary. * */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_memo); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 2728, __pyx_L1_error) + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_n_s_memo); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 2729, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); - __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dependency_injector_provider, __pyx_n_s_add_sys_streams, 2728, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(1, 2728, __pyx_L1_error) + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dependency_injector_provider, __pyx_n_s_add_sys_streams, 2729, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(1, 2729, __pyx_L1_error) - /* "dependency_injector/providers.pyx":2739 + /* "dependency_injector/providers.pyx":2740 * * * def merge_dicts(dict1, dict2): # <<<<<<<<<<<<<< * """Merge dictionaries recursively. * */ - __pyx_tuple__22 = PyTuple_Pack(5, __pyx_n_s_dict1, __pyx_n_s_dict2, __pyx_n_s_key, __pyx_n_s_value, __pyx_n_s_result); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2739, __pyx_L1_error) + __pyx_tuple__22 = PyTuple_Pack(5, __pyx_n_s_dict1, __pyx_n_s_dict2, __pyx_n_s_key, __pyx_n_s_value, __pyx_n_s_result); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2740, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); - __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dependency_injector_provider, __pyx_n_s_merge_dicts, 2739, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(1, 2739, __pyx_L1_error) + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_dependency_injector_provider, __pyx_n_s_merge_dicts, 2740, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(1, 2740, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle_Provider(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< @@ -74620,7 +74620,7 @@ static int __Pyx_modinit_type_init_code(void) { __pyx_vtable_19dependency_injector_9providers_Factory.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_vtable_19dependency_injector_9providers_Factory.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_7Factory__provide; __pyx_type_19dependency_injector_9providers_Factory.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1493, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1494, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_Factory.tp_print = 0; #endif @@ -74629,7 +74629,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Factory, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1493, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Factory, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1494, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_7Factory___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_7Factory___init__.doc = __pyx_doc_19dependency_injector_9providers_7Factory___init__; @@ -74639,7 +74639,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Factory, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1493, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Factory, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1494, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_7Factory_4__str__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_7Factory_4__str__.doc = __pyx_doc_19dependency_injector_9providers_7Factory_4__str__; @@ -74647,29 +74647,29 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Factory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1493, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Factory, (PyObject *)&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1493, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1493, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Factory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1494, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Factory, (PyObject *)&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1494, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Factory) < 0) __PYX_ERR(1, 1494, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_Factory = &__pyx_type_19dependency_injector_9providers_Factory; __pyx_vtabptr_19dependency_injector_9providers_DelegatedFactory = &__pyx_vtable_19dependency_injector_9providers_DelegatedFactory; __pyx_vtable_19dependency_injector_9providers_DelegatedFactory.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Factory; __pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_base = __pyx_ptype_19dependency_injector_9providers_Factory; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1710, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1711, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_dictoffset && __pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1710, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedFactory, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1710, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1710, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedFactory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1711, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedFactory, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1711, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedFactory) < 0) __PYX_ERR(1, 1711, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_DelegatedFactory = &__pyx_type_19dependency_injector_9providers_DelegatedFactory; __pyx_vtabptr_19dependency_injector_9providers_AbstractFactory = &__pyx_vtable_19dependency_injector_9providers_AbstractFactory; __pyx_vtable_19dependency_injector_9providers_AbstractFactory.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Factory; __pyx_vtable_19dependency_injector_9providers_AbstractFactory.__pyx_base.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_15AbstractFactory__provide; __pyx_type_19dependency_injector_9providers_AbstractFactory.tp_base = __pyx_ptype_19dependency_injector_9providers_Factory; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1732, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1733, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_AbstractFactory.tp_print = 0; #endif @@ -74678,7 +74678,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractFactory, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1732, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractFactory, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1733, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_15AbstractFactory___call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_15AbstractFactory___call__.doc = __pyx_doc_19dependency_injector_9providers_15AbstractFactory___call__; @@ -74686,14 +74686,14 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_AbstractFactory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1732, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AbstractFactory, (PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1732, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1732, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_AbstractFactory.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1733, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AbstractFactory, (PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1733, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_AbstractFactory) < 0) __PYX_ERR(1, 1733, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_AbstractFactory = &__pyx_type_19dependency_injector_9providers_AbstractFactory; __pyx_vtabptr_19dependency_injector_9providers_FactoryDelegate = &__pyx_vtable_19dependency_injector_9providers_FactoryDelegate; __pyx_vtable_19dependency_injector_9providers_FactoryDelegate.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Delegate; __pyx_type_19dependency_injector_9providers_FactoryDelegate.tp_base = __pyx_ptype_19dependency_injector_9providers_Delegate; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1773, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1774, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_FactoryDelegate.tp_print = 0; #endif @@ -74702,7 +74702,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryDelegate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1773, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryDelegate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1774, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_15FactoryDelegate___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_15FactoryDelegate___init__.doc = __pyx_doc_19dependency_injector_9providers_15FactoryDelegate___init__; @@ -74710,21 +74710,21 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_FactoryDelegate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1773, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FactoryDelegate, (PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1773, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1773, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_FactoryDelegate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1774, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FactoryDelegate, (PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1774, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_FactoryDelegate) < 0) __PYX_ERR(1, 1774, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_FactoryDelegate = &__pyx_type_19dependency_injector_9providers_FactoryDelegate; __pyx_vtabptr_19dependency_injector_9providers_FactoryAggregate = &__pyx_vtable_19dependency_injector_9providers_FactoryAggregate; __pyx_vtable_19dependency_injector_9providers_FactoryAggregate.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_vtable_19dependency_injector_9providers_FactoryAggregate.__pyx___get_factory = (struct __pyx_obj_19dependency_injector_9providers_Factory *(*)(struct __pyx_obj_19dependency_injector_9providers_FactoryAggregate *, PyObject *))__pyx_f_19dependency_injector_9providers_16FactoryAggregate___get_factory; __pyx_type_19dependency_injector_9providers_FactoryAggregate.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1795, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1796, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_FactoryAggregate.tp_print = 0; #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1795, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1796, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate___init__.doc = __pyx_doc_19dependency_injector_9providers_16FactoryAggregate___init__; @@ -74734,7 +74734,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1795, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1796, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_4__call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_4__call__.doc = __pyx_doc_19dependency_injector_9providers_16FactoryAggregate_4__call__; @@ -74744,7 +74744,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1795, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1796, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_6__getattr__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_6__getattr__.doc = __pyx_doc_19dependency_injector_9providers_16FactoryAggregate_6__getattr__; @@ -74754,7 +74754,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1795, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1796, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_8__str__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_16FactoryAggregate_8__str__.doc = __pyx_doc_19dependency_injector_9providers_16FactoryAggregate_8__str__; @@ -74762,14 +74762,14 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_FactoryAggregate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1795, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FactoryAggregate, (PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1795, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1795, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_FactoryAggregate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1796, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FactoryAggregate, (PyObject *)&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1796, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_FactoryAggregate) < 0) __PYX_ERR(1, 1796, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_FactoryAggregate = &__pyx_type_19dependency_injector_9providers_FactoryAggregate; __pyx_vtabptr_19dependency_injector_9providers_BaseSingleton = &__pyx_vtable_19dependency_injector_9providers_BaseSingleton; __pyx_vtable_19dependency_injector_9providers_BaseSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_type_19dependency_injector_9providers_BaseSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1882, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1883, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_BaseSingleton.tp_print = 0; #endif @@ -74778,7 +74778,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1882, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1883, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_13BaseSingleton___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_13BaseSingleton___init__.doc = __pyx_doc_19dependency_injector_9providers_13BaseSingleton___init__; @@ -74788,7 +74788,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1882, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 1883, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_13BaseSingleton_2__str__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_13BaseSingleton_2__str__.doc = __pyx_doc_19dependency_injector_9providers_13BaseSingleton_2__str__; @@ -74796,15 +74796,15 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_BaseSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1882, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_BaseSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1882, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1882, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_BaseSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1883, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_BaseSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1883, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_BaseSingleton) < 0) __PYX_ERR(1, 1883, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_BaseSingleton = &__pyx_type_19dependency_injector_9providers_BaseSingleton; __pyx_vtabptr_19dependency_injector_9providers_Singleton = &__pyx_vtable_19dependency_injector_9providers_Singleton; __pyx_vtable_19dependency_injector_9providers_Singleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_BaseSingleton; __pyx_vtable_19dependency_injector_9providers_Singleton.__pyx_base.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_9Singleton__provide; __pyx_type_19dependency_injector_9providers_Singleton.tp_base = __pyx_ptype_19dependency_injector_9providers_BaseSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2035, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2036, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_Singleton.tp_print = 0; #endif @@ -74813,7 +74813,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Singleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2035, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Singleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2036, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_9Singleton___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_9Singleton___init__.doc = __pyx_doc_19dependency_injector_9providers_9Singleton___init__; @@ -74821,29 +74821,29 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Singleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2035, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Singleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2035, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2035, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Singleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2036, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Singleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2036, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Singleton) < 0) __PYX_ERR(1, 2036, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_Singleton = &__pyx_type_19dependency_injector_9providers_Singleton; __pyx_vtabptr_19dependency_injector_9providers_DelegatedSingleton = &__pyx_vtable_19dependency_injector_9providers_DelegatedSingleton; __pyx_vtable_19dependency_injector_9providers_DelegatedSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Singleton; __pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_Singleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2091, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2092, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_dictoffset && __pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2091, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2091, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2091, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2092, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2092, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedSingleton) < 0) __PYX_ERR(1, 2092, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_DelegatedSingleton = &__pyx_type_19dependency_injector_9providers_DelegatedSingleton; __pyx_vtabptr_19dependency_injector_9providers_ThreadSafeSingleton = &__pyx_vtable_19dependency_injector_9providers_ThreadSafeSingleton; __pyx_vtable_19dependency_injector_9providers_ThreadSafeSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_BaseSingleton; __pyx_vtable_19dependency_injector_9providers_ThreadSafeSingleton.__pyx_base.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_19ThreadSafeSingleton__provide; __pyx_type_19dependency_injector_9providers_ThreadSafeSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_BaseSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2113, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2114, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_ThreadSafeSingleton.tp_print = 0; #endif @@ -74852,7 +74852,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2113, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2114, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_19ThreadSafeSingleton___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_19ThreadSafeSingleton___init__.doc = __pyx_doc_19dependency_injector_9providers_19ThreadSafeSingleton___init__; @@ -74860,29 +74860,29 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2113, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ThreadSafeSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2113, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2113, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2114, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ThreadSafeSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2114, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton) < 0) __PYX_ERR(1, 2114, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton = &__pyx_type_19dependency_injector_9providers_ThreadSafeSingleton; __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadSafeSingleton = &__pyx_vtable_19dependency_injector_9providers_DelegatedThreadSafeSingleton; __pyx_vtable_19dependency_injector_9providers_DelegatedThreadSafeSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_ThreadSafeSingleton; __pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2148, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2149, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_dictoffset && __pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2148, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedThreadSafeSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2148, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2148, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2149, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedThreadSafeSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2149, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton) < 0) __PYX_ERR(1, 2149, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_DelegatedThreadSafeSingleton = &__pyx_type_19dependency_injector_9providers_DelegatedThreadSafeSingleton; __pyx_vtabptr_19dependency_injector_9providers_ThreadLocalSingleton = &__pyx_vtable_19dependency_injector_9providers_ThreadLocalSingleton; __pyx_vtable_19dependency_injector_9providers_ThreadLocalSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_BaseSingleton; __pyx_vtable_19dependency_injector_9providers_ThreadLocalSingleton.__pyx_base.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_20ThreadLocalSingleton__provide; __pyx_type_19dependency_injector_9providers_ThreadLocalSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_BaseSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2170, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2171, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_ThreadLocalSingleton.tp_print = 0; #endif @@ -74891,7 +74891,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2170, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2171, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_20ThreadLocalSingleton___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_20ThreadLocalSingleton___init__.doc = __pyx_doc_19dependency_injector_9providers_20ThreadLocalSingleton___init__; @@ -74899,28 +74899,28 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2170, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ThreadLocalSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2170, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2170, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2171, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ThreadLocalSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2171, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton) < 0) __PYX_ERR(1, 2171, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_ThreadLocalSingleton = &__pyx_type_19dependency_injector_9providers_ThreadLocalSingleton; __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadLocalSingleton = &__pyx_vtable_19dependency_injector_9providers_DelegatedThreadLocalSingleton; __pyx_vtable_19dependency_injector_9providers_DelegatedThreadLocalSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_ThreadLocalSingleton; __pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_ThreadLocalSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2218, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2219, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_dictoffset && __pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2218, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedThreadLocalSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2218, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2218, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2219, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DelegatedThreadLocalSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2219, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton) < 0) __PYX_ERR(1, 2219, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_DelegatedThreadLocalSingleton = &__pyx_type_19dependency_injector_9providers_DelegatedThreadLocalSingleton; __pyx_vtabptr_19dependency_injector_9providers_AbstractSingleton = &__pyx_vtable_19dependency_injector_9providers_AbstractSingleton; __pyx_vtable_19dependency_injector_9providers_AbstractSingleton.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_BaseSingleton; __pyx_type_19dependency_injector_9providers_AbstractSingleton.tp_base = __pyx_ptype_19dependency_injector_9providers_BaseSingleton; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2240, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2241, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_AbstractSingleton.tp_print = 0; #endif @@ -74929,7 +74929,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractSingleton, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2240, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractSingleton, "__call__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2241, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_17AbstractSingleton___call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_17AbstractSingleton___call__.doc = __pyx_doc_19dependency_injector_9providers_17AbstractSingleton___call__; @@ -74937,14 +74937,14 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_AbstractSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2240, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AbstractSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2240, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2240, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_AbstractSingleton.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2241, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_AbstractSingleton, (PyObject *)&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2241, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_AbstractSingleton) < 0) __PYX_ERR(1, 2241, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_AbstractSingleton = &__pyx_type_19dependency_injector_9providers_AbstractSingleton; __pyx_vtabptr_19dependency_injector_9providers_SingletonDelegate = &__pyx_vtable_19dependency_injector_9providers_SingletonDelegate; __pyx_vtable_19dependency_injector_9providers_SingletonDelegate.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Delegate; __pyx_type_19dependency_injector_9providers_SingletonDelegate.tp_base = __pyx_ptype_19dependency_injector_9providers_Delegate; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2285, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2286, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_SingletonDelegate.tp_print = 0; #endif @@ -74953,7 +74953,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_SingletonDelegate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2285, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_SingletonDelegate, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2286, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_17SingletonDelegate___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_17SingletonDelegate___init__.doc = __pyx_doc_19dependency_injector_9providers_17SingletonDelegate___init__; @@ -74961,15 +74961,15 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_SingletonDelegate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2285, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SingletonDelegate, (PyObject *)&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2285, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2285, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_SingletonDelegate.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2286, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SingletonDelegate, (PyObject *)&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2286, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_SingletonDelegate) < 0) __PYX_ERR(1, 2286, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_SingletonDelegate = &__pyx_type_19dependency_injector_9providers_SingletonDelegate; __pyx_vtabptr_19dependency_injector_9providers_List = &__pyx_vtable_19dependency_injector_9providers_List; __pyx_vtable_19dependency_injector_9providers_List.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_vtable_19dependency_injector_9providers_List.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_4List__provide; __pyx_type_19dependency_injector_9providers_List.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2307, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2308, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_List.tp_print = 0; #endif @@ -74978,7 +74978,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_List, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2307, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_List, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2308, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_4List___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_4List___init__.doc = __pyx_doc_19dependency_injector_9providers_4List___init__; @@ -74988,7 +74988,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_List, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2307, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_List, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2308, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_4List_4__str__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_4List_4__str__.doc = __pyx_doc_19dependency_injector_9providers_4List_4__str__; @@ -74996,21 +74996,21 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_List.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2307, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_List, (PyObject *)&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2307, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2307, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_List.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2308, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_List, (PyObject *)&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2308, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_List) < 0) __PYX_ERR(1, 2308, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_List = &__pyx_type_19dependency_injector_9providers_List; __pyx_vtabptr_19dependency_injector_9providers_Container = &__pyx_vtable_19dependency_injector_9providers_Container; __pyx_vtable_19dependency_injector_9providers_Container.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_vtable_19dependency_injector_9providers_Container.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_9Container__provide; __pyx_type_19dependency_injector_9providers_Container.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2409, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2410, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_Container.tp_print = 0; #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Container, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2409, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Container, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2410, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_9Container___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_9Container___init__.doc = __pyx_doc_19dependency_injector_9providers_9Container___init__; @@ -75020,7 +75020,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Container, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2409, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Container, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2410, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_9Container_4__getattr__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_9Container_4__getattr__.doc = __pyx_doc_19dependency_injector_9providers_9Container_4__getattr__; @@ -75028,21 +75028,21 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Container.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2409, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Container, (PyObject *)&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2409, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2409, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Container.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2410, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Container, (PyObject *)&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2410, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Container) < 0) __PYX_ERR(1, 2410, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_Container = &__pyx_type_19dependency_injector_9providers_Container; __pyx_vtabptr_19dependency_injector_9providers_Selector = &__pyx_vtable_19dependency_injector_9providers_Selector; __pyx_vtable_19dependency_injector_9providers_Selector.__pyx_base = *__pyx_vtabptr_19dependency_injector_9providers_Provider; __pyx_vtable_19dependency_injector_9providers_Selector.__pyx_base._provide = (PyObject *(*)(struct __pyx_obj_19dependency_injector_9providers_Provider *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_19dependency_injector_9providers_8Selector__provide; __pyx_type_19dependency_injector_9providers_Selector.tp_base = __pyx_ptype_19dependency_injector_9providers_Provider; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2460, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2461, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_Selector.tp_print = 0; #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2460, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2461, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_8Selector___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_8Selector___init__.doc = __pyx_doc_19dependency_injector_9providers_8Selector___init__; @@ -75052,7 +75052,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2460, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__getattr__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2461, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_8Selector_4__getattr__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_8Selector_4__getattr__.doc = __pyx_doc_19dependency_injector_9providers_8Selector_4__getattr__; @@ -75062,7 +75062,7 @@ static int __Pyx_modinit_type_init_code(void) { #endif #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2460, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_Selector, "__str__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2461, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_8Selector_6__str__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_8Selector_6__str__.doc = __pyx_doc_19dependency_injector_9providers_8Selector_6__str__; @@ -75070,22 +75070,22 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Selector.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2460, __pyx_L1_error) - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Selector, (PyObject *)&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2460, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2460, __pyx_L1_error) + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_9providers_Selector.tp_dict, __pyx_vtabptr_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2461, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Selector, (PyObject *)&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2461, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Selector) < 0) __PYX_ERR(1, 2461, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_Selector = &__pyx_type_19dependency_injector_9providers_Selector; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2557, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2558, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_Injection.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_19dependency_injector_9providers_Injection.tp_dictoffset && __pyx_type_19dependency_injector_9providers_Injection.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_19dependency_injector_9providers_Injection.tp_getattro = __Pyx_PyObject_GenericGetAttr; } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Injection, (PyObject *)&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2557, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2557, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Injection, (PyObject *)&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2558, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_Injection) < 0) __PYX_ERR(1, 2558, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_Injection = &__pyx_type_19dependency_injector_9providers_Injection; __pyx_type_19dependency_injector_9providers_PositionalInjection.tp_base = __pyx_ptype_19dependency_injector_9providers_Injection; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2561, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2562, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_PositionalInjection.tp_print = 0; #endif @@ -75094,7 +75094,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_PositionalInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2561, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_PositionalInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2562, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_19PositionalInjection___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_19PositionalInjection___init__.doc = __pyx_doc_19dependency_injector_9providers_19PositionalInjection___init__; @@ -75102,11 +75102,11 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PositionalInjection, (PyObject *)&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2561, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2561, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PositionalInjection, (PyObject *)&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2562, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_PositionalInjection) < 0) __PYX_ERR(1, 2562, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_PositionalInjection = &__pyx_type_19dependency_injector_9providers_PositionalInjection; __pyx_type_19dependency_injector_9providers_NamedInjection.tp_base = __pyx_ptype_19dependency_injector_9providers_Injection; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2589, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2590, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers_NamedInjection.tp_print = 0; #endif @@ -75115,7 +75115,7 @@ static int __Pyx_modinit_type_init_code(void) { } #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_NamedInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2589, __pyx_L1_error) + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_9providers_NamedInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 2590, __pyx_L1_error) if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_19dependency_injector_9providers_14NamedInjection___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_19dependency_injector_9providers_14NamedInjection___init__.doc = __pyx_doc_19dependency_injector_9providers_14NamedInjection___init__; @@ -75123,8 +75123,8 @@ static int __Pyx_modinit_type_init_code(void) { } } #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_NamedInjection, (PyObject *)&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2589, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2589, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_NamedInjection, (PyObject *)&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2590, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type_19dependency_injector_9providers_NamedInjection) < 0) __PYX_ERR(1, 2590, __pyx_L1_error) __pyx_ptype_19dependency_injector_9providers_NamedInjection = &__pyx_type_19dependency_injector_9providers_NamedInjection; if (PyType_Ready(&__pyx_type_19dependency_injector_9providers___pyx_scope_struct___get_self_name) < 0) __PYX_ERR(1, 1119, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 @@ -75142,7 +75142,7 @@ static int __Pyx_modinit_type_init_code(void) { __pyx_type_19dependency_injector_9providers___pyx_scope_struct_1_genexpr.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_19dependency_injector_9providers___pyx_scope_struct_1_genexpr = &__pyx_type_19dependency_injector_9providers___pyx_scope_struct_1_genexpr; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers___pyx_scope_struct_2___str__) < 0) __PYX_ERR(1, 2523, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers___pyx_scope_struct_2___str__) < 0) __PYX_ERR(1, 2524, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers___pyx_scope_struct_2___str__.tp_print = 0; #endif @@ -75150,7 +75150,7 @@ static int __Pyx_modinit_type_init_code(void) { __pyx_type_19dependency_injector_9providers___pyx_scope_struct_2___str__.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_19dependency_injector_9providers___pyx_scope_struct_2___str__ = &__pyx_type_19dependency_injector_9providers___pyx_scope_struct_2___str__; - if (PyType_Ready(&__pyx_type_19dependency_injector_9providers___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(1, 2533, __pyx_L1_error) + if (PyType_Ready(&__pyx_type_19dependency_injector_9providers___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(1, 2534, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_19dependency_injector_9providers___pyx_scope_struct_3_genexpr.tp_print = 0; #endif @@ -76322,89 +76322,89 @@ if (!__Pyx_RefNanny) { __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; PyType_Modified(__pyx_ptype_19dependency_injector_9providers_ConfigurationOption); - /* "dependency_injector/providers.pyx":1257 + /* "dependency_injector/providers.pyx":1258 * """ * * DEFAULT_NAME = 'config' # <<<<<<<<<<<<<< * * def __init__(self, name=DEFAULT_NAME, default=None): */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration->tp_dict, __pyx_n_s_DEFAULT_NAME, __pyx_n_s_config) < 0) __PYX_ERR(1, 1257, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration->tp_dict, __pyx_n_s_DEFAULT_NAME, __pyx_n_s_config) < 0) __PYX_ERR(1, 1258, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_Configuration); - /* "dependency_injector/providers.pyx":1259 + /* "dependency_injector/providers.pyx":1260 * DEFAULT_NAME = 'config' * * def __init__(self, name=DEFAULT_NAME, default=None): # <<<<<<<<<<<<<< * self.__name = name * */ - __Pyx_GetNameInClass(__pyx_t_9, (PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration, __pyx_n_s_DEFAULT_NAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1259, __pyx_L1_error) + __Pyx_GetNameInClass(__pyx_t_9, (PyObject *)__pyx_ptype_19dependency_injector_9providers_Configuration, __pyx_n_s_DEFAULT_NAME); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __pyx_k__6 = __pyx_t_9; __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; - /* "dependency_injector/providers.pyx":1544 + /* "dependency_injector/providers.pyx":1545 * """ * * provided_type = None # <<<<<<<<<<<<<< * * def __init__(self, provides, *args, **kwargs): */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory->tp_dict, __pyx_n_s_provided_type, Py_None) < 0) __PYX_ERR(1, 1544, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_Factory->tp_dict, __pyx_n_s_provided_type, Py_None) < 0) __PYX_ERR(1, 1545, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_Factory); - /* "dependency_injector/providers.pyx":1729 + /* "dependency_injector/providers.pyx":1730 * """ * * __IS_DELEGATED__ = True # <<<<<<<<<<<<<< * * */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedFactory->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 1729, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedFactory->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 1730, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_DelegatedFactory); - /* "dependency_injector/providers.pyx":1809 + /* "dependency_injector/providers.pyx":1810 * """ * * __IS_DELEGATED__ = True # <<<<<<<<<<<<<< * * def __init__(self, **factories): */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryAggregate->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 1809, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_FactoryAggregate->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 1810, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_FactoryAggregate); - /* "dependency_injector/providers.pyx":1885 + /* "dependency_injector/providers.pyx":1886 * """Base class of singleton providers.""" * * provided_type = None # <<<<<<<<<<<<<< * * def __init__(self, provides, *args, **kwargs): */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton->tp_dict, __pyx_n_s_provided_type, Py_None) < 0) __PYX_ERR(1, 1885, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_BaseSingleton->tp_dict, __pyx_n_s_provided_type, Py_None) < 0) __PYX_ERR(1, 1886, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_BaseSingleton); - /* "dependency_injector/providers.pyx":2110 + /* "dependency_injector/providers.pyx":2111 * """ * * __IS_DELEGATED__ = True # <<<<<<<<<<<<<< * * */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2110, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2111, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_DelegatedSingleton); - /* "dependency_injector/providers.pyx":2116 + /* "dependency_injector/providers.pyx":2117 * """Thread-safe singleton provider.""" * * storage_lock = threading.RLock() # <<<<<<<<<<<<<< * """Storage reentrant lock. * */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_threading); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2116, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_threading); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_RLock); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2116, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_RLock); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; @@ -76419,55 +76419,55 @@ if (!__Pyx_RefNanny) { } __pyx_t_9 = (__pyx_t_1) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_1) : __Pyx_PyObject_CallNoArg(__pyx_t_8); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2116, __pyx_L1_error) + if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2117, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton->tp_dict, __pyx_n_s_storage_lock, __pyx_t_9) < 0) __PYX_ERR(1, 2116, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton->tp_dict, __pyx_n_s_storage_lock, __pyx_t_9) < 0) __PYX_ERR(1, 2117, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; PyType_Modified(__pyx_ptype_19dependency_injector_9providers_ThreadSafeSingleton); - /* "dependency_injector/providers.pyx":2167 + /* "dependency_injector/providers.pyx":2168 * """ * * __IS_DELEGATED__ = True # <<<<<<<<<<<<<< * * */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedThreadSafeSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2167, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedThreadSafeSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2168, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_DelegatedThreadSafeSingleton); - /* "dependency_injector/providers.pyx":2237 + /* "dependency_injector/providers.pyx":2238 * """ * * __IS_DELEGATED__ = True # <<<<<<<<<<<<<< * * */ - if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedThreadLocalSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2237, __pyx_L1_error) + if (PyDict_SetItem((PyObject *)__pyx_ptype_19dependency_injector_9providers_DelegatedThreadLocalSingleton->tp_dict, __pyx_n_s_IS_DELEGATED, Py_True) < 0) __PYX_ERR(1, 2238, __pyx_L1_error) PyType_Modified(__pyx_ptype_19dependency_injector_9providers_DelegatedThreadLocalSingleton); - /* "dependency_injector/providers.pyx":2728 + /* "dependency_injector/providers.pyx":2729 * return copy.deepcopy(instance, memo) * * def __add_sys_streams(memo): # <<<<<<<<<<<<<< * """Add system streams to memo dictionary. * */ - __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_19dependency_injector_9providers_21__add_sys_streams, NULL, __pyx_n_s_dependency_injector_providers); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2728, __pyx_L1_error) + __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_19dependency_injector_9providers_21__add_sys_streams, NULL, __pyx_n_s_dependency_injector_providers); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2729, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_add_sys_streams, __pyx_t_9) < 0) __PYX_ERR(1, 2728, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_add_sys_streams, __pyx_t_9) < 0) __PYX_ERR(1, 2729, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "dependency_injector/providers.pyx":2739 + /* "dependency_injector/providers.pyx":2740 * * * def merge_dicts(dict1, dict2): # <<<<<<<<<<<<<< * """Merge dictionaries recursively. * */ - __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_19dependency_injector_9providers_23merge_dicts, NULL, __pyx_n_s_dependency_injector_providers); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2739, __pyx_L1_error) + __pyx_t_9 = PyCFunction_NewEx(&__pyx_mdef_19dependency_injector_9providers_23merge_dicts, NULL, __pyx_n_s_dependency_injector_providers); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2740, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_merge_dicts, __pyx_t_9) < 0) __PYX_ERR(1, 2739, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_merge_dicts, __pyx_t_9) < 0) __PYX_ERR(1, 2740, __pyx_L1_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "(tree fragment)":1 diff --git a/src/dependency_injector/providers.pyx b/src/dependency_injector/providers.pyx index ea9b24ca..60d79b4e 100644 --- a/src/dependency_injector/providers.pyx +++ b/src/dependency_injector/providers.pyx @@ -1239,6 +1239,7 @@ cdef class Configuration(Object): """Configuration provider provides configuration options to the other providers. .. code-block:: python + config = Configuration('config') print(config.section1.option1()) # None print(config.section1.option2()) # None