From e3408075debeccfca90b571dd062fff0561fb920 Mon Sep 17 00:00:00 2001 From: Roman Mogilatov Date: Wed, 2 Nov 2016 22:58:30 +0200 Subject: [PATCH] Update repository structure --- .pylintrc | 2 +- .travis.yml | 2 +- MANIFEST.in | 2 +- Makefile | 19 +- setup.py | 16 +- .../dependency_injector}/__init__.py | 0 .../dependency_injector}/containers.py | 0 .../dependency_injector}/errors.py | 2 - src/dependency_injector/injections.c | 5291 +++++++++++++++++ .../dependency_injector}/injections.pxd | 0 .../dependency_injector}/injections.pyx | 0 src/dependency_injector/injections.so | Bin 0 -> 119908 bytes .../providers/__init__.py | 0 .../dependency_injector}/providers/base.py | 0 .../providers/callable.py | 0 .../providers/creational.py | 0 .../dependency_injector}/utils.py | 0 tests/{ => unit}/.pydocstylerc | 0 tests/{ => unit}/__init__.py | 0 tests/{ => unit}/providers/__init__.py | 0 tests/{ => unit}/providers/test_base.py | 0 tests/{ => unit}/providers/test_callable.py | 0 tests/{ => unit}/providers/test_creational.py | 0 tests/{ => unit}/providers/test_static.py | 0 tests/{ => unit}/test_common.py | 0 tests/{ => unit}/test_containers.py | 0 tests/{ => unit}/test_injections.py | 0 tests/{ => unit}/test_utils.py | 0 tox.ini | 5 +- 29 files changed, 5317 insertions(+), 22 deletions(-) rename {dependency_injector => src/dependency_injector}/__init__.py (100%) rename {dependency_injector => src/dependency_injector}/containers.py (100%) rename {dependency_injector => src/dependency_injector}/errors.py (85%) create mode 100644 src/dependency_injector/injections.c rename {dependency_injector => src/dependency_injector}/injections.pxd (100%) rename {dependency_injector => src/dependency_injector}/injections.pyx (100%) create mode 100755 src/dependency_injector/injections.so rename {dependency_injector => src/dependency_injector}/providers/__init__.py (100%) rename {dependency_injector => src/dependency_injector}/providers/base.py (100%) rename {dependency_injector => src/dependency_injector}/providers/callable.py (100%) rename {dependency_injector => src/dependency_injector}/providers/creational.py (100%) rename {dependency_injector => src/dependency_injector}/utils.py (100%) rename tests/{ => unit}/.pydocstylerc (100%) rename tests/{ => unit}/__init__.py (100%) rename tests/{ => unit}/providers/__init__.py (100%) rename tests/{ => unit}/providers/test_base.py (100%) rename tests/{ => unit}/providers/test_callable.py (100%) rename tests/{ => unit}/providers/test_creational.py (100%) rename tests/{ => unit}/providers/test_static.py (100%) rename tests/{ => unit}/test_common.py (100%) rename tests/{ => unit}/test_containers.py (100%) rename tests/{ => unit}/test_injections.py (100%) rename tests/{ => unit}/test_utils.py (100%) diff --git a/.pylintrc b/.pylintrc index cb6a6fb8..679c86b4 100644 --- a/.pylintrc +++ b/.pylintrc @@ -2,7 +2,7 @@ # Add to the black list. It should be a base name, not a # path. You may set this option multiple times. -ignore=utils,test +ignore=utils,tests [MESSAGES CONTROL] diff --git a/.travis.yml b/.travis.yml index f31dfb55..806953de 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ install: - pip install cython - make cythonize script: - - tox -v + - tox language: python python: - 3.5 diff --git a/MANIFEST.in b/MANIFEST.in index 169d08f5..bb14403d 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,4 +1,4 @@ -recursive-include dependency_injector *.py *.pyx *.pxd *.c +recursive-include src/dependency_injector *.py *.pyx *.pxd *.c include README.rst include CONTRIBUTORS.rst include LICENSE.rst diff --git a/Makefile b/Makefile index d2489b38..fd9e2f59 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ VERSION := $(shell python setup.py --version) -CYTHON_SRC := $(shell find dependency_injector -name '*.pyx') +CYTHON_SRC := $(shell find src/dependency_injector -name '*.pyx') CYTHON_DIRECTIVES = @@ -12,11 +12,11 @@ endif clean: # Clean sources - find dependency_injector -name '*.py[cod]' -delete - find dependency_injector -name '__pycache__' -delete - find dependency_injector -name '*.c' -delete - find dependency_injector -name '*.so' -delete - find dependency_injector -name '*.html' -delete + find src -name '*.py[cod]' -delete + find src -name '__pycache__' -delete + find src -name '*.c' -delete + find src -name '*.so' -delete + find src -name '*.html' -delete # Clean tests find tests -name '*.py[co]' -delete find tests -name '__pycache__' -delete @@ -29,16 +29,19 @@ cythonize: cython -a $(CYTHON_DIRECTIVES) $(CYTHON_SRC) # Move all Cython html reports mkdir -p reports/cython/ - find dependency_injector -name '*.html' -exec mv {} reports/cython/ \; + find src -name '*.html' -exec mv {} reports/cython/ \; build: clean cythonize # Compile C extensions python setup.py build_ext --inplace +install: clean cythonize + python setup.py install + test: # Unit tests with coverage report coverage erase - coverage run --rcfile=./.coveragerc -m unittest2 discover tests + coverage run --rcfile=./.coveragerc -m unittest2 discover tests/unit coverage report --rcfile=./.coveragerc coverage html --rcfile=./.coveragerc diff --git a/setup.py b/setup.py index 0128b60b..e7dad33c 100644 --- a/setup.py +++ b/setup.py @@ -15,7 +15,7 @@ with open('requirements.txt') as version: requirements = version.readlines() # Getting version: -with open('dependency_injector/__init__.py') as init_file: +with open('src/dependency_injector/__init__.py') as init_file: version = re.search('VERSION = \'(.*?)\'', init_file.read()).group(1) # Defining macros: @@ -34,15 +34,19 @@ setup(name='dependency-injector', maintainer='Roman Mogilatov', maintainer_email='rmogilatov@gmail.com', url='https://github.com/ets-labs/python-dependency-injector', - bugtrack_url='https://github.com/ets-labs/python-dependency-injector' + - '/issues', download_url='https://pypi.python.org/pypi/dependency_injector', install_requires=requirements, - packages=['dependency_injector', - 'dependency_injector.providers'], + packages=[ + 'dependency_injector', + 'dependency_injector.providers', + ], + package_dir={ + 'dependency_injector': 'src/dependency_injector', + 'dependency_injector.providers': 'src/dependency_injector/providers', + }, ext_modules=[ Extension('dependency_injector.injections', - ['dependency_injector/injections.c'], + ['src/dependency_injector/injections.c'], define_macros=defined_macros, extra_compile_args=['-O2']), ], diff --git a/dependency_injector/__init__.py b/src/dependency_injector/__init__.py similarity index 100% rename from dependency_injector/__init__.py rename to src/dependency_injector/__init__.py diff --git a/dependency_injector/containers.py b/src/dependency_injector/containers.py similarity index 100% rename from dependency_injector/containers.py rename to src/dependency_injector/containers.py diff --git a/dependency_injector/errors.py b/src/dependency_injector/errors.py similarity index 85% rename from dependency_injector/errors.py rename to src/dependency_injector/errors.py index 0d56b02b..69aa283e 100644 --- a/dependency_injector/errors.py +++ b/src/dependency_injector/errors.py @@ -6,5 +6,3 @@ class Error(Exception): All dependency injector errors extend this error class. """ - -print(__file__, __name__) diff --git a/src/dependency_injector/injections.c b/src/dependency_injector/injections.c new file mode 100644 index 00000000..717a1977 --- /dev/null +++ b/src/dependency_injector/injections.c @@ -0,0 +1,5291 @@ +/* Generated by Cython 0.25.1 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_25_1" +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000) + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" + #undef SHIFT + #undef BASE + #undef MASK +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && METH_FASTCALL == PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + + +#define __PYX_ERR(f_index, lineno, Ln_error) \ +{ \ + __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \ +} + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__dependency_injector__injections +#define __PYX_HAVE_API__dependency_injector__injections +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "src/dependency_injector/injections.pxd", + "src/dependency_injector/injections.pyx", +}; + +/*--- Type declarations ---*/ +struct __pyx_obj_19dependency_injector_10injections_Injection; +struct __pyx_obj_19dependency_injector_10injections_PositionalInjection; +struct __pyx_obj_19dependency_injector_10injections_NamedInjection; + +/* "dependency_injector/injections.pxd":10 + * + * + * cdef class Injection: # <<<<<<<<<<<<<< + * pass + * + */ +struct __pyx_obj_19dependency_injector_10injections_Injection { + PyObject_HEAD +}; + + +/* "dependency_injector/injections.pxd":14 + * + * + * cdef class PositionalInjection(Injection): # <<<<<<<<<<<<<< + * cdef object __value + * cdef int __is_provider + */ +struct __pyx_obj_19dependency_injector_10injections_PositionalInjection { + struct __pyx_obj_19dependency_injector_10injections_Injection __pyx_base; + struct __pyx_vtabstruct_19dependency_injector_10injections_PositionalInjection *__pyx_vtab; + PyObject *__pyx___value; + int __pyx___is_provider; + int __pyx___is_delegated; + int __pyx___call; +}; + + +/* "dependency_injector/injections.pxd":26 + * + * + * cdef class NamedInjection(Injection): # <<<<<<<<<<<<<< + * cdef object __name + * cdef object __value + */ +struct __pyx_obj_19dependency_injector_10injections_NamedInjection { + struct __pyx_obj_19dependency_injector_10injections_Injection __pyx_base; + struct __pyx_vtabstruct_19dependency_injector_10injections_NamedInjection *__pyx_vtab; + PyObject *__pyx___name; + PyObject *__pyx___value; + int __pyx___is_provider; + int __pyx___is_delegated; + int __pyx___call; +}; + + + +/* "dependency_injector/injections.pyx":14 + * + * + * cdef class PositionalInjection(Injection): # <<<<<<<<<<<<<< + * """Positional injection class.""" + * + */ + +struct __pyx_vtabstruct_19dependency_injector_10injections_PositionalInjection { + PyObject *(*__pyx___get_value)(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *); +}; +static struct __pyx_vtabstruct_19dependency_injector_10injections_PositionalInjection *__pyx_vtabptr_19dependency_injector_10injections_PositionalInjection; +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_19PositionalInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *); + + +/* "dependency_injector/injections.pyx":29 + * + * + * cdef class NamedInjection(Injection): # <<<<<<<<<<<<<< + * """Keyword injection class.""" + * + */ + +struct __pyx_vtabstruct_19dependency_injector_10injections_NamedInjection { + PyObject *(*__pyx___get_name)(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *); + PyObject *(*__pyx___get_value)(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *); +}; +static struct __pyx_vtabstruct_19dependency_injector_10injections_NamedInjection *__pyx_vtabptr_19dependency_injector_10injections_NamedInjection; +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_name(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *); +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *); + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* Profile.proto */ +#ifndef CYTHON_PROFILE +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON + #define CYTHON_PROFILE 0 +#else + #define CYTHON_PROFILE 1 +#endif +#endif +#ifndef CYTHON_TRACE_NOGIL + #define CYTHON_TRACE_NOGIL 0 +#else + #if CYTHON_TRACE_NOGIL && !defined(CYTHON_TRACE) + #define CYTHON_TRACE 1 + #endif +#endif +#ifndef CYTHON_TRACE + #define CYTHON_TRACE 0 +#endif +#if CYTHON_TRACE + #undef CYTHON_PROFILE_REUSE_FRAME +#endif +#ifndef CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_PROFILE_REUSE_FRAME 0 +#endif +#if CYTHON_PROFILE || CYTHON_TRACE + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" + #if CYTHON_PROFILE_REUSE_FRAME + #define CYTHON_FRAME_MODIFIER static + #define CYTHON_FRAME_DEL(frame) + #else + #define CYTHON_FRAME_MODIFIER + #define CYTHON_FRAME_DEL(frame) Py_CLEAR(frame) + #endif + #define __Pyx_TraceDeclarations\ + static PyCodeObject *__pyx_frame_code = NULL;\ + CYTHON_FRAME_MODIFIER PyFrameObject *__pyx_frame = NULL;\ + int __Pyx_use_tracing = 0; + #define __Pyx_TraceFrameInit(codeobj)\ + if (codeobj) __pyx_frame_code = (PyCodeObject*) codeobj; + #ifdef WITH_THREAD + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ + (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, funcname, srcfile, firstlineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ + (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #else + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error)\ + { PyThreadState* tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing) && !tstate->tracing &&\ + (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&__pyx_frame_code, &__pyx_frame, funcname, srcfile, firstlineno);\ + if (unlikely(__Pyx_use_tracing < 0)) goto_error;\ + }\ + } + #endif + #define __Pyx_TraceException()\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (tstate->use_tracing &&\ + (tstate->c_profilefunc || (CYTHON_TRACE && tstate->c_tracefunc))) {\ + tstate->tracing++;\ + tstate->use_tracing = 0;\ + PyObject *exc_info = __Pyx_GetExceptionTuple(tstate);\ + if (exc_info) {\ + if (CYTHON_TRACE && tstate->c_tracefunc)\ + tstate->c_tracefunc(\ + tstate->c_traceobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + tstate->c_profilefunc(\ + tstate->c_profileobj, __pyx_frame, PyTrace_EXCEPTION, exc_info);\ + Py_DECREF(exc_info);\ + }\ + tstate->use_tracing = 1;\ + tstate->tracing--;\ + }\ + } + static void __Pyx_call_return_trace_func(PyThreadState *tstate, PyFrameObject *frame, PyObject *result) { + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + tstate->tracing++; + tstate->use_tracing = 0; + if (CYTHON_TRACE && tstate->c_tracefunc) + tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_RETURN, result); + if (tstate->c_profilefunc) + tstate->c_profilefunc(tstate->c_profileobj, frame, PyTrace_RETURN, result); + CYTHON_FRAME_DEL(frame); + tstate->use_tracing = 1; + tstate->tracing--; + PyErr_Restore(type, value, traceback); + } + #ifdef WITH_THREAD + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = PyThreadState_GET();\ + if (tstate->use_tracing) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + PyGILState_Release(state);\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (tstate->use_tracing) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + }\ + } + #else + #define __Pyx_TraceReturn(result, nogil)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (tstate->use_tracing) {\ + __Pyx_call_return_trace_func(tstate, __pyx_frame, (PyObject*)result);\ + }\ + } + #endif + static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); + static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, const char *funcname, const char *srcfile, int firstlineno); +#else + #define __Pyx_TraceDeclarations + #define __Pyx_TraceFrameInit(codeobj) + #define __Pyx_TraceCall(funcname, srcfile, firstlineno, nogil, goto_error) if (1); else goto_error; + #define __Pyx_TraceException() + #define __Pyx_TraceReturn(result, nogil) +#endif +#if CYTHON_TRACE + static int __Pyx_call_line_trace_func(PyThreadState *tstate, PyFrameObject *frame, int lineno) { + int ret; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + __Pyx_PyFrame_SetLineNumber(frame, lineno); + tstate->tracing++; + tstate->use_tracing = 0; + ret = tstate->c_tracefunc(tstate->c_traceobj, frame, PyTrace_LINE, NULL); + tstate->use_tracing = 1; + tstate->tracing--; + if (likely(!ret)) { + PyErr_Restore(type, value, traceback); + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + } + return ret; + } + #ifdef WITH_THREAD + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + if (nogil) {\ + if (CYTHON_TRACE_NOGIL) {\ + int ret = 0;\ + PyThreadState *tstate;\ + PyGILState_STATE state = PyGILState_Ensure();\ + tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing && tstate->c_tracefunc)) {\ + ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + }\ + PyGILState_Release(state);\ + if (unlikely(ret)) goto_error;\ + }\ + } else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing && tstate->c_tracefunc)) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + }\ + } + #else + #define __Pyx_TraceLine(lineno, nogil, goto_error)\ + if (likely(!__Pyx_use_tracing)); else {\ + PyThreadState* tstate = PyThreadState_GET();\ + if (unlikely(tstate->use_tracing && tstate->c_tracefunc)) {\ + int ret = __Pyx_call_line_trace_func(tstate, __pyx_frame, lineno);\ + if (unlikely(ret)) goto_error;\ + }\ + } + #endif +#else + #define __Pyx_TraceLine(lineno, nogil, goto_error) if (1); else goto_error; +#endif + +/* GetModuleGlobalName.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#endif + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + Py_SIZE(list) = len+1; + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* ArgTypeTest.proto */ +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +/* py_dict_items.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +/* CallUnboundCMethod0.proto */ +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CallUnboundCMethod0(cfunc, self)\ + ((likely((cfunc)->func)) ?\ + (likely((cfunc)->flag == METH_NOARGS) ? (*((cfunc)->func))(self, NULL) :\ + (likely((cfunc)->flag == (METH_VARARGS | METH_KEYWORDS)) ? ((*(PyCFunctionWithKeywords)(cfunc)->func)(self, __pyx_empty_tuple, NULL)) :\ + ((cfunc)->flag == METH_VARARGS ? (*((cfunc)->func))(self, __pyx_empty_tuple) :\ + (PY_VERSION_HEX >= 0x030600B1 && (cfunc)->flag == METH_FASTCALL ? (*(__Pyx_PyCFunctionFast)(cfunc)->func)(self, &PyTuple_GET_ITEM(__pyx_empty_tuple, 0), 0, NULL) :\ + __Pyx__CallUnboundCMethod0(cfunc, self))))) :\ + __Pyx__CallUnboundCMethod0(cfunc, self)) +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* PyObjectCallNoArg.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* CallNextTpTraverse.proto */ +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +/* CallNextTpClear.proto */ +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(void); + +/* FunctionExport.proto */ +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_19PositionalInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_name(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self); /* proto*/ + +/* Module declarations from 'dependency_injector.injections' */ +static PyTypeObject *__pyx_ptype_19dependency_injector_10injections_Injection = 0; +static PyTypeObject *__pyx_ptype_19dependency_injector_10injections_PositionalInjection = 0; +static PyTypeObject *__pyx_ptype_19dependency_injector_10injections_NamedInjection = 0; +static PyObject *__pyx_f_19dependency_injector_10injections_parse_positional_injections(PyObject *, int __pyx_skip_dispatch); /*proto*/ +static PyObject *__pyx_f_19dependency_injector_10injections_parse_named_injections(PyObject *, int __pyx_skip_dispatch); /*proto*/ +#define __Pyx_MODULE_NAME "dependency_injector.injections" +int __pyx_module_is_main_dependency_injector__injections = 0; + +/* Implementation of 'dependency_injector.injections' */ +static PyObject *__pyx_builtin_range; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_items[] = "items"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_utils[] = "utils"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_get_name[] = "get_name"; +static const char __pyx_k_get_value[] = "get_value"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_is_provider[] = "is_provider"; +static const char __pyx_k_Dependency_injector_injections_C[] = "Dependency injector injections.\n\nCython optimized code.\n"; +static PyObject *__pyx_n_s_get_name; +static PyObject *__pyx_n_s_get_value; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_is_provider; +static PyObject *__pyx_n_s_items; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_utils; +static PyObject *__pyx_n_s_value; +static int __pyx_pf_19dependency_injector_10injections_19PositionalInjection___init__(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_19dependency_injector_10injections_19PositionalInjection_2get_value(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self); /* proto */ +static int __pyx_pf_19dependency_injector_10injections_14NamedInjection___init__(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_19dependency_injector_10injections_14NamedInjection_2get_name(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_19dependency_injector_10injections_14NamedInjection_4get_value(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_19dependency_injector_10injections_parse_positional_injections(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args); /* proto */ +static PyObject *__pyx_pf_19dependency_injector_10injections_2parse_named_injections(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_tp_new_19dependency_injector_10injections_Injection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_19dependency_injector_10injections_PositionalInjection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_19dependency_injector_10injections_NamedInjection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items = {0, &__pyx_n_s_items, 0, 0, 0}; + +/* "dependency_injector/injections.pyx":17 + * """Positional injection class.""" + * + * def __init__(self, value): # <<<<<<<<<<<<<< + * """Initializer.""" + * self.__value = value + */ + +/* Python wrapper */ +static int __pyx_pw_19dependency_injector_10injections_19PositionalInjection_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_19PositionalInjection___init__[] = "Initializer."; +#if CYTHON_COMPILING_IN_CPYTHON +struct wrapperbase __pyx_wrapperbase_19dependency_injector_10injections_19PositionalInjection___init__; +#endif +static int __pyx_pw_19dependency_injector_10injections_19PositionalInjection_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_value = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; + 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, 17, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 17, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("dependency_injector.injections.PositionalInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_19dependency_injector_10injections_19PositionalInjection___init__(((struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_19dependency_injector_10injections_19PositionalInjection___init__(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceCall("__init__", __pyx_f[1], 17, 0, __PYX_ERR(1, 17, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":19 + * def __init__(self, value): + * """Initializer.""" + * self.__value = value # <<<<<<<<<<<<<< + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + */ + __Pyx_TraceLine(19,0,__PYX_ERR(1, 19, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->__pyx___value); + __Pyx_DECREF(__pyx_v_self->__pyx___value); + __pyx_v_self->__pyx___value = __pyx_v_value; + + /* "dependency_injector/injections.pyx":20 + * """Initializer.""" + * self.__value = value + * self.__is_provider = is_provider(value) # <<<<<<<<<<<<<< + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + */ + __Pyx_TraceLine(20,0,__PYX_ERR(1, 20, __pyx_L1_error)) + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_provider); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(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); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_value); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 20, __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; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 20, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->__pyx___is_provider = ((int)__pyx_t_5); + + /* "dependency_injector/injections.pyx":21 + * self.__value = value + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() # <<<<<<<<<<<<<< + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + */ + __Pyx_TraceLine(21,0,__PYX_ERR(1, 21, __pyx_L1_error)) + __pyx_v_self->__pyx___is_delegated = 0; + + /* "dependency_injector/injections.pyx":22 + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 # <<<<<<<<<<<<<< + * + * def get_value(self): + */ + __Pyx_TraceLine(22,0,__PYX_ERR(1, 22, __pyx_L1_error)) + __pyx_t_6 = (((int)__pyx_v_self->__pyx___is_provider) == 1); + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_self->__pyx___is_delegated == 0); + __pyx_t_5 = __pyx_t_6; + __pyx_L3_bool_binop_done:; + __pyx_v_self->__pyx___call = __pyx_t_5; + + /* "dependency_injector/injections.pyx":17 + * """Positional injection class.""" + * + * def __init__(self, value): # <<<<<<<<<<<<<< + * """Initializer.""" + * self.__value = value + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dependency_injector.injections.PositionalInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":24 + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + * def get_value(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_value() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_19dependency_injector_10injections_19PositionalInjection_3get_value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_19PositionalInjection_2get_value[] = "Return injection value."; +static PyObject *__pyx_pw_19dependency_injector_10injections_19PositionalInjection_3get_value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_value (wrapper)", 0); + __pyx_r = __pyx_pf_19dependency_injector_10injections_19PositionalInjection_2get_value(((struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_19dependency_injector_10injections_19PositionalInjection_2get_value(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_value", 0); + __Pyx_TraceCall("get_value", __pyx_f[1], 24, 0, __PYX_ERR(1, 24, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":26 + * def get_value(self): + * """Return injection value.""" + * return self.__get_value() # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(26,0,__PYX_ERR(1, 26, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19dependency_injector_10injections_19PositionalInjection___get_value(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pyx":24 + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + * def get_value(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_value() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dependency_injector.injections.PositionalInjection.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":32 + * """Keyword injection class.""" + * + * def __init__(self, name, value): # <<<<<<<<<<<<<< + * """Initializer.""" + * self.__name = name + */ + +/* Python wrapper */ +static int __pyx_pw_19dependency_injector_10injections_14NamedInjection_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_14NamedInjection___init__[] = "Initializer."; +#if CYTHON_COMPILING_IN_CPYTHON +struct wrapperbase __pyx_wrapperbase_19dependency_injector_10injections_14NamedInjection___init__; +#endif +static int __pyx_pw_19dependency_injector_10injections_14NamedInjection_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 32, __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, 32, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 32, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_19dependency_injector_10injections_14NamedInjection___init__(((struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_19dependency_injector_10injections_14NamedInjection___init__(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_TraceCall("__init__", __pyx_f[1], 32, 0, __PYX_ERR(1, 32, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":34 + * def __init__(self, name, value): + * """Initializer.""" + * self.__name = name # <<<<<<<<<<<<<< + * self.__value = value + * self.__is_provider = is_provider(value) + */ + __Pyx_TraceLine(34,0,__PYX_ERR(1, 34, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->__pyx___name); + __Pyx_DECREF(__pyx_v_self->__pyx___name); + __pyx_v_self->__pyx___name = __pyx_v_name; + + /* "dependency_injector/injections.pyx":35 + * """Initializer.""" + * self.__name = name + * self.__value = value # <<<<<<<<<<<<<< + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + */ + __Pyx_TraceLine(35,0,__PYX_ERR(1, 35, __pyx_L1_error)) + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->__pyx___value); + __Pyx_DECREF(__pyx_v_self->__pyx___value); + __pyx_v_self->__pyx___value = __pyx_v_value; + + /* "dependency_injector/injections.pyx":36 + * self.__name = name + * self.__value = value + * self.__is_provider = is_provider(value) # <<<<<<<<<<<<<< + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + */ + __Pyx_TraceLine(36,0,__PYX_ERR(1, 36, __pyx_L1_error)) + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_provider); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(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); + } + } + if (!__pyx_t_3) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } else { + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { + PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_1); + } else + #endif + { + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_value); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 36, __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; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 36, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->__pyx___is_provider = ((int)__pyx_t_5); + + /* "dependency_injector/injections.pyx":37 + * self.__value = value + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() # <<<<<<<<<<<<<< + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + */ + __Pyx_TraceLine(37,0,__PYX_ERR(1, 37, __pyx_L1_error)) + __pyx_v_self->__pyx___is_delegated = 0; + + /* "dependency_injector/injections.pyx":38 + * self.__is_provider = is_provider(value) + * self.__is_delegated = 0 # TODO: use utils.is_delegated() + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 # <<<<<<<<<<<<<< + * + * def get_name(self): + */ + __Pyx_TraceLine(38,0,__PYX_ERR(1, 38, __pyx_L1_error)) + __pyx_t_6 = (((int)__pyx_v_self->__pyx___is_provider) == 1); + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_6 = (__pyx_v_self->__pyx___is_delegated == 0); + __pyx_t_5 = __pyx_t_6; + __pyx_L3_bool_binop_done:; + __pyx_v_self->__pyx___call = __pyx_t_5; + + /* "dependency_injector/injections.pyx":32 + * """Keyword injection class.""" + * + * def __init__(self, name, value): # <<<<<<<<<<<<<< + * """Initializer.""" + * self.__name = name + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_TraceReturn(Py_None, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":40 + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + * def get_name(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_name() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_19dependency_injector_10injections_14NamedInjection_3get_name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_14NamedInjection_2get_name[] = "Return injection value."; +static PyObject *__pyx_pw_19dependency_injector_10injections_14NamedInjection_3get_name(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_name (wrapper)", 0); + __pyx_r = __pyx_pf_19dependency_injector_10injections_14NamedInjection_2get_name(((struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_19dependency_injector_10injections_14NamedInjection_2get_name(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_name", 0); + __Pyx_TraceCall("get_name", __pyx_f[1], 40, 0, __PYX_ERR(1, 40, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":42 + * def get_name(self): + * """Return injection value.""" + * return self.__get_name() # <<<<<<<<<<<<<< + * + * def get_value(self): + */ + __Pyx_TraceLine(42,0,__PYX_ERR(1, 42, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19dependency_injector_10injections_14NamedInjection___get_name(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pyx":40 + * self.__call = self.__is_provider == 1 and self.__is_delegated == 0 + * + * def get_name(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_name() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.get_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":44 + * return self.__get_name() + * + * def get_value(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_value() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_19dependency_injector_10injections_14NamedInjection_5get_value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_14NamedInjection_4get_value[] = "Return injection value."; +static PyObject *__pyx_pw_19dependency_injector_10injections_14NamedInjection_5get_value(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_value (wrapper)", 0); + __pyx_r = __pyx_pf_19dependency_injector_10injections_14NamedInjection_4get_value(((struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_19dependency_injector_10injections_14NamedInjection_4get_value(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("get_value", 0); + __Pyx_TraceCall("get_value", __pyx_f[1], 44, 0, __PYX_ERR(1, 44, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":46 + * def get_value(self): + * """Return injection value.""" + * return self.__get_value() # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(46,0,__PYX_ERR(1, 46, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19dependency_injector_10injections_14NamedInjection___get_value(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pyx":44 + * return self.__get_name() + * + * def get_value(self): # <<<<<<<<<<<<<< + * """Return injection value.""" + * return self.__get_value() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":49 + * + * + * cpdef tuple parse_positional_injections(tuple args): # <<<<<<<<<<<<<< + * """Parse positional injections.""" + * cdef list injections = list() + */ + +static PyObject *__pyx_pw_19dependency_injector_10injections_1parse_positional_injections(PyObject *__pyx_self, PyObject *__pyx_v_args); /*proto*/ +static PyObject *__pyx_f_19dependency_injector_10injections_parse_positional_injections(PyObject *__pyx_v_args, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_v_injections = 0; + int __pyx_v_args_len; + PyObject *__pyx_v_arg = 0; + int __pyx_v_index; + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_injection = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + __Pyx_RefNannySetupContext("parse_positional_injections", 0); + __Pyx_TraceCall("parse_positional_injections", __pyx_f[1], 49, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":51 + * cpdef tuple parse_positional_injections(tuple args): + * """Parse positional injections.""" + * cdef list injections = list() # <<<<<<<<<<<<<< + * cdef int args_len = len(args) + * + */ + __Pyx_TraceLine(51,0,__PYX_ERR(1, 51, __pyx_L1_error)) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_injections = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "dependency_injector/injections.pyx":52 + * """Parse positional injections.""" + * cdef list injections = list() + * cdef int args_len = len(args) # <<<<<<<<<<<<<< + * + * cdef object arg + */ + __Pyx_TraceLine(52,0,__PYX_ERR(1, 52, __pyx_L1_error)) + if (unlikely(__pyx_v_args == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 52, __pyx_L1_error) + } + __pyx_t_2 = PyTuple_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 52, __pyx_L1_error) + __pyx_v_args_len = __pyx_t_2; + + /* "dependency_injector/injections.pyx":58 + * cdef PositionalInjection injection + * + * for index in range(args_len): # <<<<<<<<<<<<<< + * arg = args[index] + * injection = PositionalInjection(arg) + */ + __Pyx_TraceLine(58,0,__PYX_ERR(1, 58, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_args_len; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_index = __pyx_t_4; + + /* "dependency_injector/injections.pyx":59 + * + * for index in range(args_len): + * arg = args[index] # <<<<<<<<<<<<<< + * injection = PositionalInjection(arg) + * injections.append(injection) + */ + __Pyx_TraceLine(59,0,__PYX_ERR(1, 59, __pyx_L1_error)) + if (unlikely(__pyx_v_args == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 59, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_args, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_1); + __pyx_t_1 = 0; + + /* "dependency_injector/injections.pyx":60 + * for index in range(args_len): + * arg = args[index] + * injection = PositionalInjection(arg) # <<<<<<<<<<<<<< + * injections.append(injection) + * + */ + __Pyx_TraceLine(60,0,__PYX_ERR(1, 60, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_arg); + __Pyx_GIVEREF(__pyx_v_arg); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_arg); + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_19dependency_injector_10injections_PositionalInjection), __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_injection, ((struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "dependency_injector/injections.pyx":61 + * arg = args[index] + * injection = PositionalInjection(arg) + * injections.append(injection) # <<<<<<<<<<<<<< + * + * return tuple(injections) + */ + __Pyx_TraceLine(61,0,__PYX_ERR(1, 61, __pyx_L1_error)) + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(1, 61, __pyx_L1_error) + } + + /* "dependency_injector/injections.pyx":63 + * injections.append(injection) + * + * return tuple(injections) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(63,0,__PYX_ERR(1, 63, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pyx":49 + * + * + * cpdef tuple parse_positional_injections(tuple args): # <<<<<<<<<<<<<< + * """Parse positional injections.""" + * cdef list injections = list() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("dependency_injector.injections.parse_positional_injections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_injections); + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XDECREF((PyObject *)__pyx_v_injection); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_19dependency_injector_10injections_1parse_positional_injections(PyObject *__pyx_self, PyObject *__pyx_v_args); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_parse_positional_injections[] = "Parse positional injections."; +static PyObject *__pyx_pw_19dependency_injector_10injections_1parse_positional_injections(PyObject *__pyx_self, PyObject *__pyx_v_args) { + 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, 49, __pyx_L1_error) + __pyx_r = __pyx_pf_19dependency_injector_10injections_parse_positional_injections(__pyx_self, ((PyObject*)__pyx_v_args)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_19dependency_injector_10injections_parse_positional_injections(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_args) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("parse_positional_injections", 0); + __Pyx_TraceCall("parse_positional_injections (wrapper)", __pyx_f[1], 49, 0, __PYX_ERR(1, 49, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19dependency_injector_10injections_parse_positional_injections(__pyx_v_args, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dependency_injector.injections.parse_positional_injections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pyx":66 + * + * + * cpdef tuple parse_named_injections(dict kwargs): # <<<<<<<<<<<<<< + * """Parse named injections.""" + * cdef list injections = list() + */ + +static PyObject *__pyx_pw_19dependency_injector_10injections_3parse_named_injections(PyObject *__pyx_self, PyObject *__pyx_v_kwargs); /*proto*/ +static PyObject *__pyx_f_19dependency_injector_10injections_parse_named_injections(PyObject *__pyx_v_kwargs, CYTHON_UNUSED int __pyx_skip_dispatch) { + PyObject *__pyx_v_injections = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_arg = 0; + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_injection = 0; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __pyx_t_9; + __Pyx_RefNannySetupContext("parse_named_injections", 0); + __Pyx_TraceCall("parse_named_injections", __pyx_f[1], 66, 0, __PYX_ERR(1, 66, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":68 + * cpdef tuple parse_named_injections(dict kwargs): + * """Parse named injections.""" + * cdef list injections = list() # <<<<<<<<<<<<<< + * + * cdef object name + */ + __Pyx_TraceLine(68,0,__PYX_ERR(1, 68, __pyx_L1_error)) + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_injections = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "dependency_injector/injections.pyx":74 + * cdef NamedInjection injection + * + * for name, arg in kwargs.items(): # <<<<<<<<<<<<<< + * injection = NamedInjection(name, arg) + * injections.append(injection) + */ + __Pyx_TraceLine(74,0,__PYX_ERR(1, 74, __pyx_L1_error)) + if (unlikely(__pyx_v_kwargs == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "items"); + __PYX_ERR(1, 74, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyDict_Items(__pyx_v_kwargs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 74, __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, 74, __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, 74, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + 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, 74, __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, 74, __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, 74, __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, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 74, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + #if !CYTHON_COMPILING_IN_PYPY + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 74, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_5 = PyList_GET_ITEM(sequence, 0); + __pyx_t_6 = PyList_GET_ITEM(sequence, 1); + } + __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, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 74, __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, 74, __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; + index = 0; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __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, 74, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(1, 74, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_arg, __pyx_t_6); + __pyx_t_6 = 0; + + /* "dependency_injector/injections.pyx":75 + * + * for name, arg in kwargs.items(): + * injection = NamedInjection(name, arg) # <<<<<<<<<<<<<< + * injections.append(injection) + * + */ + __Pyx_TraceLine(75,0,__PYX_ERR(1, 75, __pyx_L1_error)) + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_name); + __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_10injections_NamedInjection), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 75, __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_10injections_NamedInjection *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "dependency_injector/injections.pyx":76 + * for name, arg in kwargs.items(): + * injection = NamedInjection(name, arg) + * injections.append(injection) # <<<<<<<<<<<<<< + * + * return tuple(injections) + */ + __Pyx_TraceLine(76,0,__PYX_ERR(1, 76, __pyx_L1_error)) + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_injections, ((PyObject *)__pyx_v_injection)); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(1, 76, __pyx_L1_error) + + /* "dependency_injector/injections.pyx":74 + * cdef NamedInjection injection + * + * for name, arg in kwargs.items(): # <<<<<<<<<<<<<< + * injection = NamedInjection(name, arg) + * injections.append(injection) + */ + __Pyx_TraceLine(74,0,__PYX_ERR(1, 74, __pyx_L1_error)) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dependency_injector/injections.pyx":78 + * injections.append(injection) + * + * return tuple(injections) # <<<<<<<<<<<<<< + */ + __Pyx_TraceLine(78,0,__PYX_ERR(1, 78, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_AsTuple(__pyx_v_injections); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pyx":66 + * + * + * cpdef tuple parse_named_injections(dict kwargs): # <<<<<<<<<<<<<< + * """Parse named injections.""" + * cdef list injections = list() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("dependency_injector.injections.parse_named_injections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_injections); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_arg); + __Pyx_XDECREF((PyObject *)__pyx_v_injection); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_19dependency_injector_10injections_3parse_named_injections(PyObject *__pyx_self, PyObject *__pyx_v_kwargs); /*proto*/ +static char __pyx_doc_19dependency_injector_10injections_2parse_named_injections[] = "Parse named injections."; +static PyObject *__pyx_pw_19dependency_injector_10injections_3parse_named_injections(PyObject *__pyx_self, PyObject *__pyx_v_kwargs) { + 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, 66, __pyx_L1_error) + __pyx_r = __pyx_pf_19dependency_injector_10injections_2parse_named_injections(__pyx_self, ((PyObject*)__pyx_v_kwargs)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_19dependency_injector_10injections_2parse_named_injections(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("parse_named_injections", 0); + __Pyx_TraceCall("parse_named_injections (wrapper)", __pyx_f[1], 66, 0, __PYX_ERR(1, 66, __pyx_L1_error)); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_19dependency_injector_10injections_parse_named_injections(__pyx_v_kwargs, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("dependency_injector.injections.parse_named_injections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pxd":20 + * cdef int __call + * + * cdef inline object __get_value(self): # <<<<<<<<<<<<<< + * if self.__call == 0: + * return self.__value + */ + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_19PositionalInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__get_value", 0); + __Pyx_TraceCall("__get_value", __pyx_f[0], 20, 0, __PYX_ERR(0, 20, __pyx_L1_error)); + + /* "dependency_injector/injections.pxd":21 + * + * cdef inline object __get_value(self): + * if self.__call == 0: # <<<<<<<<<<<<<< + * return self.__value + * return self.__value() + */ + __Pyx_TraceLine(21,0,__PYX_ERR(0, 21, __pyx_L1_error)) + __pyx_t_1 = ((__pyx_v_self->__pyx___call == 0) != 0); + if (__pyx_t_1) { + + /* "dependency_injector/injections.pxd":22 + * cdef inline object __get_value(self): + * if self.__call == 0: + * return self.__value # <<<<<<<<<<<<<< + * return self.__value() + * + */ + __Pyx_TraceLine(22,0,__PYX_ERR(0, 22, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->__pyx___value); + __pyx_r = __pyx_v_self->__pyx___value; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":21 + * + * cdef inline object __get_value(self): + * if self.__call == 0: # <<<<<<<<<<<<<< + * return self.__value + * return self.__value() + */ + } + + /* "dependency_injector/injections.pxd":23 + * if self.__call == 0: + * return self.__value + * return self.__value() # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(23,0,__PYX_ERR(0, 23, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->__pyx___value); + __pyx_t_3 = __pyx_v_self->__pyx___value; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":20 + * cdef int __call + * + * cdef inline object __get_value(self): # <<<<<<<<<<<<<< + * if self.__call == 0: + * return self.__value + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dependency_injector.injections.PositionalInjection.__get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pxd":33 + * cdef int __call + * + * cdef inline object __get_name(self): # <<<<<<<<<<<<<< + * return self.__name + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_name(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get_name", 0); + __Pyx_TraceCall("__get_name", __pyx_f[0], 33, 0, __PYX_ERR(0, 33, __pyx_L1_error)); + + /* "dependency_injector/injections.pxd":34 + * + * cdef inline object __get_name(self): + * return self.__name # <<<<<<<<<<<<<< + * + * cdef inline object __get_value(self): + */ + __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->__pyx___name); + __pyx_r = __pyx_v_self->__pyx___name; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":33 + * cdef int __call + * + * cdef inline object __get_name(self): # <<<<<<<<<<<<<< + * return self.__name + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.__get_name", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pxd":36 + * return self.__name + * + * cdef inline object __get_value(self): # <<<<<<<<<<<<<< + * if self.__call == 0: + * return self.__value + */ + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections_14NamedInjection___get_value(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + __Pyx_RefNannySetupContext("__get_value", 0); + __Pyx_TraceCall("__get_value", __pyx_f[0], 36, 0, __PYX_ERR(0, 36, __pyx_L1_error)); + + /* "dependency_injector/injections.pxd":37 + * + * cdef inline object __get_value(self): + * if self.__call == 0: # <<<<<<<<<<<<<< + * return self.__value + * return self.__value() + */ + __Pyx_TraceLine(37,0,__PYX_ERR(0, 37, __pyx_L1_error)) + __pyx_t_1 = ((__pyx_v_self->__pyx___call == 0) != 0); + if (__pyx_t_1) { + + /* "dependency_injector/injections.pxd":38 + * cdef inline object __get_value(self): + * if self.__call == 0: + * return self.__value # <<<<<<<<<<<<<< + * return self.__value() + * + */ + __Pyx_TraceLine(38,0,__PYX_ERR(0, 38, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->__pyx___value); + __pyx_r = __pyx_v_self->__pyx___value; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":37 + * + * cdef inline object __get_value(self): + * if self.__call == 0: # <<<<<<<<<<<<<< + * return self.__value + * return self.__value() + */ + } + + /* "dependency_injector/injections.pxd":39 + * if self.__call == 0: + * return self.__value + * return self.__value() # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(39,0,__PYX_ERR(0, 39, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->__pyx___value); + __pyx_t_3 = __pyx_v_self->__pyx___value; __pyx_t_4 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":36 + * return self.__name + * + * cdef inline object __get_value(self): # <<<<<<<<<<<<<< + * if self.__call == 0: + * return self.__value + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("dependency_injector.injections.NamedInjection.__get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pxd":42 + * + * + * cdef inline tuple __provide_positional_args(tuple inj_args, # <<<<<<<<<<<<<< + * int inj_args_len, + * tuple args): + */ + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections___provide_positional_args(PyObject *__pyx_v_inj_args, int __pyx_v_inj_args_len, PyObject *__pyx_v_args) { + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *__pyx_v_injection = 0; + PyObject *__pyx_v_positional_args = NULL; + int __pyx_v_index; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + __Pyx_RefNannySetupContext("__provide_positional_args", 0); + __Pyx_TraceCall("__provide_positional_args", __pyx_f[0], 42, 0, __PYX_ERR(0, 42, __pyx_L1_error)); + __Pyx_INCREF(__pyx_v_args); + + /* "dependency_injector/injections.pxd":46 + * tuple args): + * cdef PositionalInjection injection + * if inj_args_len > 0: # <<<<<<<<<<<<<< + * positional_args = list() + * for index in range(inj_args_len): + */ + __Pyx_TraceLine(46,0,__PYX_ERR(0, 46, __pyx_L1_error)) + __pyx_t_1 = ((__pyx_v_inj_args_len > 0) != 0); + if (__pyx_t_1) { + + /* "dependency_injector/injections.pxd":47 + * cdef PositionalInjection injection + * if inj_args_len > 0: + * positional_args = list() # <<<<<<<<<<<<<< + * for index in range(inj_args_len): + * injection = inj_args[index] + */ + __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error)) + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_positional_args = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "dependency_injector/injections.pxd":48 + * if inj_args_len > 0: + * positional_args = list() + * for index in range(inj_args_len): # <<<<<<<<<<<<<< + * injection = inj_args[index] + * positional_args.append(injection.get_value()) + */ + __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error)) + __pyx_t_3 = __pyx_v_inj_args_len; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_index = __pyx_t_4; + + /* "dependency_injector/injections.pxd":49 + * positional_args = list() + * for index in range(inj_args_len): + * injection = inj_args[index] # <<<<<<<<<<<<<< + * positional_args.append(injection.get_value()) + * positional_args.extend(args) + */ + __Pyx_TraceLine(49,0,__PYX_ERR(0, 49, __pyx_L1_error)) + if (unlikely(__pyx_v_inj_args == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 49, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_GetItemInt_Tuple(__pyx_v_inj_args, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_injection, ((struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "dependency_injector/injections.pxd":50 + * for index in range(inj_args_len): + * injection = inj_args[index] + * positional_args.append(injection.get_value()) # <<<<<<<<<<<<<< + * positional_args.extend(args) + * args = positional_args + */ + __Pyx_TraceLine(50,0,__PYX_ERR(0, 50, __pyx_L1_error)) + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_injection), __pyx_n_s_get_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_6) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_positional_args, __pyx_t_5); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 50, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "dependency_injector/injections.pxd":51 + * injection = inj_args[index] + * positional_args.append(injection.get_value()) + * positional_args.extend(args) # <<<<<<<<<<<<<< + * args = positional_args + * return args + */ + __Pyx_TraceLine(51,0,__PYX_ERR(0, 51, __pyx_L1_error)) + __pyx_t_7 = __Pyx_PyList_Extend(__pyx_v_positional_args, __pyx_v_args); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 51, __pyx_L1_error) + + /* "dependency_injector/injections.pxd":52 + * positional_args.append(injection.get_value()) + * positional_args.extend(args) + * args = positional_args # <<<<<<<<<<<<<< + * return args + * + */ + __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error)) + if (!(likely(PyTuple_CheckExact(__pyx_v_positional_args))||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_positional_args)->tp_name), 0))) __PYX_ERR(0, 52, __pyx_L1_error) + __pyx_t_5 = __pyx_v_positional_args; + __Pyx_INCREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "dependency_injector/injections.pxd":46 + * tuple args): + * cdef PositionalInjection injection + * if inj_args_len > 0: # <<<<<<<<<<<<<< + * positional_args = list() + * for index in range(inj_args_len): + */ + } + + /* "dependency_injector/injections.pxd":53 + * positional_args.extend(args) + * args = positional_args + * return args # <<<<<<<<<<<<<< + * + * cdef inline dict __provide_keyword_args(tuple inj_kwargs, + */ + __Pyx_TraceLine(53,0,__PYX_ERR(0, 53, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_args); + __pyx_r = __pyx_v_args; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":42 + * + * + * cdef inline tuple __provide_positional_args(tuple inj_args, # <<<<<<<<<<<<<< + * int inj_args_len, + * tuple args): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("dependency_injector.injections.__provide_positional_args", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_injection); + __Pyx_XDECREF(__pyx_v_positional_args); + __Pyx_XDECREF(__pyx_v_args); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "dependency_injector/injections.pxd":55 + * return args + * + * cdef inline dict __provide_keyword_args(tuple inj_kwargs, # <<<<<<<<<<<<<< + * int inj_kwargs_len, + * dict kwargs): + */ + +static CYTHON_INLINE PyObject *__pyx_f_19dependency_injector_10injections___provide_keyword_args(PyObject *__pyx_v_inj_kwargs, int __pyx_v_inj_kwargs_len, PyObject *__pyx_v_kwargs) { + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *__pyx_v_kw_injection = 0; + int __pyx_v_index; + PyObject *__pyx_r = NULL; + __Pyx_TraceDeclarations + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + __Pyx_RefNannySetupContext("__provide_keyword_args", 0); + __Pyx_TraceCall("__provide_keyword_args", __pyx_f[0], 55, 0, __PYX_ERR(0, 55, __pyx_L1_error)); + + /* "dependency_injector/injections.pxd":59 + * dict kwargs): + * cdef NamedInjection kw_injection + * if inj_kwargs_len > 0: # <<<<<<<<<<<<<< + * for index in range(inj_kwargs_len): + * kw_injection = inj_kwargs[index] + */ + __Pyx_TraceLine(59,0,__PYX_ERR(0, 59, __pyx_L1_error)) + __pyx_t_1 = ((__pyx_v_inj_kwargs_len > 0) != 0); + if (__pyx_t_1) { + + /* "dependency_injector/injections.pxd":60 + * cdef NamedInjection kw_injection + * if inj_kwargs_len > 0: + * for index in range(inj_kwargs_len): # <<<<<<<<<<<<<< + * kw_injection = inj_kwargs[index] + * kwargs[kw_injection.get_name()] = kw_injection.get_value() + */ + __Pyx_TraceLine(60,0,__PYX_ERR(0, 60, __pyx_L1_error)) + __pyx_t_2 = __pyx_v_inj_kwargs_len; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_index = __pyx_t_3; + + /* "dependency_injector/injections.pxd":61 + * if inj_kwargs_len > 0: + * for index in range(inj_kwargs_len): + * kw_injection = inj_kwargs[index] # <<<<<<<<<<<<<< + * kwargs[kw_injection.get_name()] = kw_injection.get_value() + * return kwargs + */ + __Pyx_TraceLine(61,0,__PYX_ERR(0, 61, __pyx_L1_error)) + if (unlikely(__pyx_v_inj_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 61, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_inj_kwargs, __pyx_v_index, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_kw_injection, ((struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "dependency_injector/injections.pxd":62 + * for index in range(inj_kwargs_len): + * kw_injection = inj_kwargs[index] + * kwargs[kw_injection.get_name()] = kw_injection.get_value() # <<<<<<<<<<<<<< + * return kwargs + */ + __Pyx_TraceLine(62,0,__PYX_ERR(0, 62, __pyx_L1_error)) + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_kw_injection), __pyx_n_s_get_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_6) { + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(__pyx_v_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 62, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_kw_injection), __pyx_n_s_get_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_7) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error) + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(PyDict_SetItem(__pyx_v_kwargs, __pyx_t_4, __pyx_t_5) < 0)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "dependency_injector/injections.pxd":59 + * dict kwargs): + * cdef NamedInjection kw_injection + * if inj_kwargs_len > 0: # <<<<<<<<<<<<<< + * for index in range(inj_kwargs_len): + * kw_injection = inj_kwargs[index] + */ + } + + /* "dependency_injector/injections.pxd":63 + * kw_injection = inj_kwargs[index] + * kwargs[kw_injection.get_name()] = kw_injection.get_value() + * return kwargs # <<<<<<<<<<<<<< + */ + __Pyx_TraceLine(63,0,__PYX_ERR(0, 63, __pyx_L1_error)) + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_kwargs); + __pyx_r = __pyx_v_kwargs; + goto __pyx_L0; + + /* "dependency_injector/injections.pxd":55 + * return args + * + * cdef inline dict __provide_keyword_args(tuple inj_kwargs, # <<<<<<<<<<<<<< + * int inj_kwargs_len, + * dict kwargs): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("dependency_injector.injections.__provide_keyword_args", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_kw_injection); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_TraceReturn(__pyx_r, 0); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_tp_new_19dependency_injector_10injections_Injection(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_19dependency_injector_10injections_Injection(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} + +static PyTypeObject __pyx_type_19dependency_injector_10injections_Injection = { + PyVarObject_HEAD_INIT(0, 0) + "dependency_injector.injections.Injection", /*tp_name*/ + sizeof(struct __pyx_obj_19dependency_injector_10injections_Injection), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_19dependency_injector_10injections_Injection, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 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, /*tp_flags*/ + "Abstract injection class.", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_19dependency_injector_10injections_Injection, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_19dependency_injector_10injections_PositionalInjection __pyx_vtable_19dependency_injector_10injections_PositionalInjection; + +static PyObject *__pyx_tp_new_19dependency_injector_10injections_PositionalInjection(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *p; + PyObject *o = __pyx_tp_new_19dependency_injector_10injections_Injection(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)o); + p->__pyx_vtab = __pyx_vtabptr_19dependency_injector_10injections_PositionalInjection; + p->__pyx___value = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_19dependency_injector_10injections_PositionalInjection(PyObject *o) { + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *p = (struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx___value); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_19dependency_injector_10injections_Injection(o); +} + +static int __pyx_tp_traverse_19dependency_injector_10injections_PositionalInjection(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *p = (struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)o; + e = ((likely(__pyx_ptype_19dependency_injector_10injections_Injection)) ? ((__pyx_ptype_19dependency_injector_10injections_Injection->tp_traverse) ? __pyx_ptype_19dependency_injector_10injections_Injection->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_19dependency_injector_10injections_PositionalInjection)); if (e) return e; + if (p->__pyx___value) { + e = (*v)(p->__pyx___value, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_19dependency_injector_10injections_PositionalInjection(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *p = (struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *)o; + if (likely(__pyx_ptype_19dependency_injector_10injections_Injection)) { if (__pyx_ptype_19dependency_injector_10injections_Injection->tp_clear) __pyx_ptype_19dependency_injector_10injections_Injection->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_19dependency_injector_10injections_PositionalInjection); + tmp = ((PyObject*)p->__pyx___value); + p->__pyx___value = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_19dependency_injector_10injections_PositionalInjection[] = { + {"get_value", (PyCFunction)__pyx_pw_19dependency_injector_10injections_19PositionalInjection_3get_value, METH_NOARGS, __pyx_doc_19dependency_injector_10injections_19PositionalInjection_2get_value}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_19dependency_injector_10injections_PositionalInjection = { + PyVarObject_HEAD_INIT(0, 0) + "dependency_injector.injections.PositionalInjection", /*tp_name*/ + sizeof(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_19dependency_injector_10injections_PositionalInjection, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 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*/ + "Positional injection class.", /*tp_doc*/ + __pyx_tp_traverse_19dependency_injector_10injections_PositionalInjection, /*tp_traverse*/ + __pyx_tp_clear_19dependency_injector_10injections_PositionalInjection, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_19dependency_injector_10injections_PositionalInjection, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_19dependency_injector_10injections_19PositionalInjection_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_19dependency_injector_10injections_PositionalInjection, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_19dependency_injector_10injections_NamedInjection __pyx_vtable_19dependency_injector_10injections_NamedInjection; + +static PyObject *__pyx_tp_new_19dependency_injector_10injections_NamedInjection(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *p; + PyObject *o = __pyx_tp_new_19dependency_injector_10injections_Injection(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)o); + p->__pyx_vtab = __pyx_vtabptr_19dependency_injector_10injections_NamedInjection; + p->__pyx___name = Py_None; Py_INCREF(Py_None); + p->__pyx___value = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_19dependency_injector_10injections_NamedInjection(PyObject *o) { + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *p = (struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx___name); + Py_CLEAR(p->__pyx___value); + #if CYTHON_USE_TYPE_SLOTS + if (PyType_IS_GC(Py_TYPE(o)->tp_base)) + #endif + PyObject_GC_Track(o); + __pyx_tp_dealloc_19dependency_injector_10injections_Injection(o); +} + +static int __pyx_tp_traverse_19dependency_injector_10injections_NamedInjection(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *p = (struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)o; + e = ((likely(__pyx_ptype_19dependency_injector_10injections_Injection)) ? ((__pyx_ptype_19dependency_injector_10injections_Injection->tp_traverse) ? __pyx_ptype_19dependency_injector_10injections_Injection->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_19dependency_injector_10injections_NamedInjection)); if (e) return e; + if (p->__pyx___name) { + e = (*v)(p->__pyx___name, a); if (e) return e; + } + if (p->__pyx___value) { + e = (*v)(p->__pyx___value, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_19dependency_injector_10injections_NamedInjection(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_19dependency_injector_10injections_NamedInjection *p = (struct __pyx_obj_19dependency_injector_10injections_NamedInjection *)o; + if (likely(__pyx_ptype_19dependency_injector_10injections_Injection)) { if (__pyx_ptype_19dependency_injector_10injections_Injection->tp_clear) __pyx_ptype_19dependency_injector_10injections_Injection->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_19dependency_injector_10injections_NamedInjection); + tmp = ((PyObject*)p->__pyx___name); + p->__pyx___name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx___value); + p->__pyx___value = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_19dependency_injector_10injections_NamedInjection[] = { + {"get_name", (PyCFunction)__pyx_pw_19dependency_injector_10injections_14NamedInjection_3get_name, METH_NOARGS, __pyx_doc_19dependency_injector_10injections_14NamedInjection_2get_name}, + {"get_value", (PyCFunction)__pyx_pw_19dependency_injector_10injections_14NamedInjection_5get_value, METH_NOARGS, __pyx_doc_19dependency_injector_10injections_14NamedInjection_4get_value}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_19dependency_injector_10injections_NamedInjection = { + PyVarObject_HEAD_INIT(0, 0) + "dependency_injector.injections.NamedInjection", /*tp_name*/ + sizeof(struct __pyx_obj_19dependency_injector_10injections_NamedInjection), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_19dependency_injector_10injections_NamedInjection, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 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*/ + "Keyword injection class.", /*tp_doc*/ + __pyx_tp_traverse_19dependency_injector_10injections_NamedInjection, /*tp_traverse*/ + __pyx_tp_clear_19dependency_injector_10injections_NamedInjection, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_19dependency_injector_10injections_NamedInjection, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_pw_19dependency_injector_10injections_14NamedInjection_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_19dependency_injector_10injections_NamedInjection, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"parse_positional_injections", (PyCFunction)__pyx_pw_19dependency_injector_10injections_1parse_positional_injections, METH_O, __pyx_doc_19dependency_injector_10injections_parse_positional_injections}, + {"parse_named_injections", (PyCFunction)__pyx_pw_19dependency_injector_10injections_3parse_named_injections, METH_O, __pyx_doc_19dependency_injector_10injections_2parse_named_injections}, + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "injections", + __pyx_k_Dependency_injector_injections_C, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_get_name, __pyx_k_get_name, sizeof(__pyx_k_get_name), 0, 0, 1, 1}, + {&__pyx_n_s_get_value, __pyx_k_get_value, sizeof(__pyx_k_get_value), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_is_provider, __pyx_k_is_provider, sizeof(__pyx_k_is_provider), 0, 0, 1, 1}, + {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_utils, __pyx_k_utils, sizeof(__pyx_k_utils), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 48, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_InitGlobals(void) { + __pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(1, 1, __pyx_L1_error); + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initinjections(void); /*proto*/ +PyMODINIT_FUNC initinjections(void) +#else +PyMODINIT_FUNC PyInit_injections(void); /*proto*/ +PyMODINIT_FUNC PyInit_injections(void) +#endif +{ + __Pyx_TraceDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_injections(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(1, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("injections", __pyx_methods, __pyx_k_Dependency_injector_injections_C, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(1, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(1, 1, __pyx_L1_error) + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(1, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_dependency_injector__injections) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(1, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "dependency_injector.injections")) { + if (unlikely(PyDict_SetItemString(modules, "dependency_injector.injections", __pyx_m) < 0)) __PYX_ERR(1, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("parse_positional_injections", (void (*)(void))__pyx_f_19dependency_injector_10injections_parse_positional_injections, "PyObject *(PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + if (__Pyx_ExportFunction("parse_named_injections", (void (*)(void))__pyx_f_19dependency_injector_10injections_parse_named_injections, "PyObject *(PyObject *, int __pyx_skip_dispatch)") < 0) __PYX_ERR(1, 1, __pyx_L1_error) + /*--- Type init code ---*/ + if (PyType_Ready(&__pyx_type_19dependency_injector_10injections_Injection) < 0) __PYX_ERR(1, 10, __pyx_L1_error) + __pyx_type_19dependency_injector_10injections_Injection.tp_print = 0; + if (PyObject_SetAttrString(__pyx_m, "Injection", (PyObject *)&__pyx_type_19dependency_injector_10injections_Injection) < 0) __PYX_ERR(1, 10, __pyx_L1_error) + __pyx_ptype_19dependency_injector_10injections_Injection = &__pyx_type_19dependency_injector_10injections_Injection; + __pyx_vtabptr_19dependency_injector_10injections_PositionalInjection = &__pyx_vtable_19dependency_injector_10injections_PositionalInjection; + __pyx_vtable_19dependency_injector_10injections_PositionalInjection.__pyx___get_value = (PyObject *(*)(struct __pyx_obj_19dependency_injector_10injections_PositionalInjection *))__pyx_f_19dependency_injector_10injections_19PositionalInjection___get_value; + __pyx_type_19dependency_injector_10injections_PositionalInjection.tp_base = __pyx_ptype_19dependency_injector_10injections_Injection; + if (PyType_Ready(&__pyx_type_19dependency_injector_10injections_PositionalInjection) < 0) __PYX_ERR(1, 14, __pyx_L1_error) + __pyx_type_19dependency_injector_10injections_PositionalInjection.tp_print = 0; + #if CYTHON_COMPILING_IN_CPYTHON + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_10injections_PositionalInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 14, __pyx_L1_error) + if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { + __pyx_wrapperbase_19dependency_injector_10injections_19PositionalInjection___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_19dependency_injector_10injections_19PositionalInjection___init__.doc = __pyx_doc_19dependency_injector_10injections_19PositionalInjection___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_19dependency_injector_10injections_19PositionalInjection___init__; + } + } + #endif + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_10injections_PositionalInjection.tp_dict, __pyx_vtabptr_19dependency_injector_10injections_PositionalInjection) < 0) __PYX_ERR(1, 14, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "PositionalInjection", (PyObject *)&__pyx_type_19dependency_injector_10injections_PositionalInjection) < 0) __PYX_ERR(1, 14, __pyx_L1_error) + __pyx_ptype_19dependency_injector_10injections_PositionalInjection = &__pyx_type_19dependency_injector_10injections_PositionalInjection; + __pyx_vtabptr_19dependency_injector_10injections_NamedInjection = &__pyx_vtable_19dependency_injector_10injections_NamedInjection; + __pyx_vtable_19dependency_injector_10injections_NamedInjection.__pyx___get_name = (PyObject *(*)(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *))__pyx_f_19dependency_injector_10injections_14NamedInjection___get_name; + __pyx_vtable_19dependency_injector_10injections_NamedInjection.__pyx___get_value = (PyObject *(*)(struct __pyx_obj_19dependency_injector_10injections_NamedInjection *))__pyx_f_19dependency_injector_10injections_14NamedInjection___get_value; + __pyx_type_19dependency_injector_10injections_NamedInjection.tp_base = __pyx_ptype_19dependency_injector_10injections_Injection; + if (PyType_Ready(&__pyx_type_19dependency_injector_10injections_NamedInjection) < 0) __PYX_ERR(1, 29, __pyx_L1_error) + __pyx_type_19dependency_injector_10injections_NamedInjection.tp_print = 0; + #if CYTHON_COMPILING_IN_CPYTHON + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_19dependency_injector_10injections_NamedInjection, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 29, __pyx_L1_error) + if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { + __pyx_wrapperbase_19dependency_injector_10injections_14NamedInjection___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_19dependency_injector_10injections_14NamedInjection___init__.doc = __pyx_doc_19dependency_injector_10injections_14NamedInjection___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_19dependency_injector_10injections_14NamedInjection___init__; + } + } + #endif + if (__Pyx_SetVtable(__pyx_type_19dependency_injector_10injections_NamedInjection.tp_dict, __pyx_vtabptr_19dependency_injector_10injections_NamedInjection) < 0) __PYX_ERR(1, 29, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "NamedInjection", (PyObject *)&__pyx_type_19dependency_injector_10injections_NamedInjection) < 0) __PYX_ERR(1, 29, __pyx_L1_error) + __pyx_ptype_19dependency_injector_10injections_NamedInjection = &__pyx_type_19dependency_injector_10injections_NamedInjection; + /*--- Type import code ---*/ + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(1, 1, __pyx_L1_error) + #endif + __Pyx_TraceCall("PyMODINIT_FUNC PyInit_injections(void)", __pyx_f[1], 1, 0, __PYX_ERR(1, 1, __pyx_L1_error)); + + /* "dependency_injector/injections.pyx":7 + * + * # TODO: replace to cimport + * from .utils import is_provider # <<<<<<<<<<<<<< + * + * + */ + __Pyx_TraceLine(7,0,__PYX_ERR(1, 7, __pyx_L1_error)) + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_is_provider); + __Pyx_GIVEREF(__pyx_n_s_is_provider); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_is_provider); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_utils, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_is_provider); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_provider, __pyx_t_1) < 0) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dependency_injector/injections.pyx":1 + * """Dependency injector injections. # <<<<<<<<<<<<<< + * + * Cython optimized code. + */ + __Pyx_TraceLine(1,0,__PYX_ERR(1, 1, __pyx_L1_error)) + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "dependency_injector/injections.pxd":55 + * return args + * + * cdef inline dict __provide_keyword_args(tuple inj_kwargs, # <<<<<<<<<<<<<< + * int inj_kwargs_len, + * dict kwargs): + */ + __Pyx_TraceReturn(Py_None, 0); + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init dependency_injector.injections", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init dependency_injector.injections"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* Profile */ +#if CYTHON_PROFILE +static int __Pyx_TraceSetupAndCall(PyCodeObject** code, + PyFrameObject** frame, + const char *funcname, + const char *srcfile, + int firstlineno) { + PyObject *type, *value, *traceback; + int retval; + PyThreadState* tstate = PyThreadState_GET(); + if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) { + if (*code == NULL) { + *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno); + if (*code == NULL) return 0; + } + *frame = PyFrame_New( + tstate, /*PyThreadState *tstate*/ + *code, /*PyCodeObject *code*/ + __pyx_d, /*PyObject *globals*/ + 0 /*PyObject *locals*/ + ); + if (*frame == NULL) return 0; + if (CYTHON_TRACE && (*frame)->f_trace == NULL) { + Py_INCREF(Py_None); + (*frame)->f_trace = Py_None; + } +#if PY_VERSION_HEX < 0x030400B1 + } else { + (*frame)->f_tstate = tstate; +#endif + } + __Pyx_PyFrame_SetLineNumber(*frame, firstlineno); + retval = 1; + tstate->tracing++; + tstate->use_tracing = 0; + PyErr_Fetch(&type, &value, &traceback); + #if CYTHON_TRACE + if (tstate->c_tracefunc) + retval = tstate->c_tracefunc(tstate->c_traceobj, *frame, PyTrace_CALL, NULL) == 0; + if (retval && tstate->c_profilefunc) + #endif + retval = tstate->c_profilefunc(tstate->c_profileobj, *frame, PyTrace_CALL, NULL) == 0; + tstate->use_tracing = (tstate->c_profilefunc || + (CYTHON_TRACE && tstate->c_tracefunc)); + tstate->tracing--; + if (retval) { + PyErr_Restore(type, value, traceback); + return tstate->use_tracing && retval; + } else { + Py_XDECREF(type); + Py_XDECREF(value); + Py_XDECREF(traceback); + return -1; + } +} +static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) { + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + PyCodeObject *py_code = 0; + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + py_srcfile = PyString_FromString(srcfile); + #else + py_funcname = PyUnicode_FromString(funcname); + py_srcfile = PyUnicode_FromString(srcfile); + #endif + if (!py_funcname | !py_srcfile) goto bad; + py_code = PyCode_New( + 0, + #if PY_MAJOR_VERSION >= 3 + 0, + #endif + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + firstlineno, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return py_code; +} +#endif + +/* GetModuleGlobalName */ +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + PyObject *result; + int flags; + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL); +} +#endif // CYTHON_FAST_PYCCALL + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +#include "frameobject.h" +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = PyThreadState_GET(); + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = f->f_localsplus; + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif // CPython < 3.6 +#endif // CYTHON_FAST_PYCALL + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* GetItemInt */ + static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ArgTypeTest */ + static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +/* UnpackUnboundCMethod */ + static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + target->method = method; +#if CYTHON_COMPILING_IN_CPYTHON + #if PY_MAJOR_VERSION >= 3 + if (likely(PyObject_TypeCheck(method, &PyMethodDescr_Type))) + #endif + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST); + } +#endif + return 0; +} + +/* CallUnboundCMethod0 */ + static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *args, *result = NULL; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_ASSUME_SAFE_MACROS + args = PyTuple_New(1); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); +#else + args = PyTuple_Pack(1, self); + if (unlikely(!args)) goto bad; +#endif + result = __Pyx_PyObject_Call(cfunc->method, args, NULL); + Py_DECREF(args); +bad: + return result; +} + +/* py_dict_items */ + static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + if (PY_MAJOR_VERSION >= 3) + return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_items, d); + else + return PyDict_Items(d); +} + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { +#if CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = PyThreadState_GET(); + PyObject* exc_type = tstate->curexc_type; + if (unlikely(exc_type)) { + if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { + PyObject *exc_value, *exc_tb; + exc_value = tstate->curexc_value; + exc_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + Py_DECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_tb); + return 0; + } else { + return -1; + } + } + return 0; +#else + if (unlikely(PyErr_Occurred())) { + if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { + PyErr_Clear(); + return 0; + } else { + return -1; + } + } + return 0; +#endif +} + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } else { + return __Pyx_IterFinish(); + } + return 0; +} + +/* PyObjectCallNoArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, NULL, 0); + } +#endif +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +/* CallNextTpTraverse */ + static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +/* CallNextTpClear */ + static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +/* SetVTable */ + static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* ImportFrom */ + static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* FunctionExport */ + static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } + #else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } + #endif +#else + res = PyNumber_Int(x); +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/dependency_injector/injections.pxd b/src/dependency_injector/injections.pxd similarity index 100% rename from dependency_injector/injections.pxd rename to src/dependency_injector/injections.pxd diff --git a/dependency_injector/injections.pyx b/src/dependency_injector/injections.pyx similarity index 100% rename from dependency_injector/injections.pyx rename to src/dependency_injector/injections.pyx diff --git a/src/dependency_injector/injections.so b/src/dependency_injector/injections.so new file mode 100755 index 0000000000000000000000000000000000000000..85286d7f80c40f1c5a146c80f1856f9feb85ad05 GIT binary patch literal 119908 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