fast-depends 1.0.0__tar.gz

fast_depends-1.0.0/.gitignore

@@ -0,0 +1,20 @@
+dist
+__pycache__
+*.lock
+.vscode
+.pypirc
+venv
+app
+serve.py
+test.py
+poetry.lock
+docker-compose.yaml
+.pytest_cache
+poetry.lock
+.coverage*
+htmlcov
+wtf
+.ruff_cache
+.mypy_cache
+coverage.json
+site

fast_depends-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Pastukhov Nikita
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

fast_depends-1.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: fast-depends
+Version: 1.0.0
+Summary: FastDepends - extracted and cleared from HTTP domain Fastapi Dependency Injection System
+Project-URL: Homepage, https://lancetnik.github.io/FastDI/
+Project-URL: Documentation, https://lancetnik.github.io/FastDI/
+Project-URL: Tracker, https://github.com/Lancetnik/FastDI/issues
+Project-URL: Source, https://github.com/Lancetnik/FastDI
+Author-email: Pastukhov Nikita <diementros@yandex.ru>
+License-File: LICENSE
+Keywords: dependency injection,fastapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 1
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Requires-Dist: anyio
+Requires-Dist: pydantic>=1.8
+Provides-Extra: dev
+Requires-Dist: black>=23.3.0; extra == 'dev'
+Requires-Dist: fastdepends[doc]; extra == 'dev'
+Requires-Dist: fastdepends[test]; extra == 'dev'
+Requires-Dist: isort>=5; extra == 'dev'
+Requires-Dist: mypy>=1.1; extra == 'dev'
+Requires-Dist: ruff>=0.0.260; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: mdx-include<2.0.0,>=1.4.1; extra == 'doc'
+Requires-Dist: mkdocs-markdownextradata-plugin<0.3.0,>=0.1.7; extra == 'doc'
+Requires-Dist: mkdocs-material<9.0.0,>=8.1.4; extra == 'doc'
+Requires-Dist: mkdocstrings[python]>=0.18; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: asyncmock; python_version < '3.8' and extra == 'test'
+Requires-Dist: coverage[toml]>=7.2; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'test'
+Requires-Dist: pytest-xdist[psutil]; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# FastDI
+
+---
+
+Documentation: https://lancetnik.github.io/FastDI/
+
+---
+
+FastDI - extracted and cleared from HTTP domain logic Fastapi Dependency Injection System.
+This is a little library, providing you ability to use lovely Fastapi interfaces at your own
+projects or tools.
+
+Thanks to [*fastapi*](https://fastapi.tiangolo.com/) and [*pytest*](https://docs.pytest.org/en/7.3.x/) projects for this
+greate functional. This package just a little change Fasapi sources to provide DI functionality pyre-python way.
+
+## Usage
+
+There is no way to make Dependency Injection easier
+
+You can use this library without any frameworks at **sync** and **async** code both
+
+### Async code
+```python
+import asyncio
+
+from fastdi import inject, Depends
+
+async def dependency(a: int) -> int:
+    return a
+
+@inject
+async def main(
+    a: int,
+    b: int,
+    c: int = Depends(dependency)
+) -> float:
+    return a + b + c
+
+assert asyncio.run(main("1", 2)) == 4.0
+```
+
+### Sync code
+```python
+from fastdi import inject, Depends
+
+def dependency(a: int) -> int:
+    return a
+
+@inject
+def main(
+    a: int,
+    b: int,
+    c: int = Depends(dependency)
+) -> float:
+    return a + b + c
+
+assert main("1", 2) == 4.0
+```
+
+`@inject` decorator playing multiple roles at the same time:
+
+* resolve *Depends* classes
+* cast types according python annotation
+* validate incoming parameters using *pydantic*
+
+---
+
+### Features
+Syncronous code is fully supported at this package: without any `async_to_sync`, `run_sync`, `syncify` or any another tricks.
+
+Also, *FastDI* casts function return the same way, it can be very felpfull to build your own tools.
+
+There is two main defferences from native Fastapi DI System.
+
+---
+
+### Note
+Library was build by actual **0.95.0 FastAPI** version.
+
+If we'll be too far behind, please, contact [me](mailto:diementros@yandex.ru)
+or contubute yourself. Really appreciate your help.

fast_depends-1.0.0/README.md

@@ -0,0 +1,81 @@
+# FastDI
+
+---
+
+Documentation: https://lancetnik.github.io/FastDI/
+
+---
+
+FastDI - extracted and cleared from HTTP domain logic Fastapi Dependency Injection System.
+This is a little library, providing you ability to use lovely Fastapi interfaces at your own
+projects or tools.
+
+Thanks to [*fastapi*](https://fastapi.tiangolo.com/) and [*pytest*](https://docs.pytest.org/en/7.3.x/) projects for this
+greate functional. This package just a little change Fasapi sources to provide DI functionality pyre-python way.
+
+## Usage
+
+There is no way to make Dependency Injection easier
+
+You can use this library without any frameworks at **sync** and **async** code both
+
+### Async code
+```python
+import asyncio
+
+from fastdi import inject, Depends
+
+async def dependency(a: int) -> int:
+    return a
+
+@inject
+async def main(
+    a: int,
+    b: int,
+    c: int = Depends(dependency)
+) -> float:
+    return a + b + c
+
+assert asyncio.run(main("1", 2)) == 4.0
+```
+
+### Sync code
+```python
+from fastdi import inject, Depends
+
+def dependency(a: int) -> int:
+    return a
+
+@inject
+def main(
+    a: int,
+    b: int,
+    c: int = Depends(dependency)
+) -> float:
+    return a + b + c
+
+assert main("1", 2) == 4.0
+```
+
+`@inject` decorator playing multiple roles at the same time:
+
+* resolve *Depends* classes
+* cast types according python annotation
+* validate incoming parameters using *pydantic*
+
+---
+
+### Features
+Syncronous code is fully supported at this package: without any `async_to_sync`, `run_sync`, `syncify` or any another tricks.
+
+Also, *FastDI* casts function return the same way, it can be very felpfull to build your own tools.
+
+There is two main defferences from native Fastapi DI System.
+
+---
+
+### Note
+Library was build by actual **0.95.0 FastAPI** version.
+
+If we'll be too far behind, please, contact [me](mailto:diementros@yandex.ru)
+or contubute yourself. Really appreciate your help.

fast_depends-1.0.0/fast_depends/__about__.py

@@ -0,0 +1,3 @@
+"""FastDepends - extracted and cleared from HTTP domain Fastapi Dependency Injection System"""
+
+__version__ = "1.0.0"

fast_depends-1.0.0/fast_depends/__init__.py

@@ -0,0 +1,8 @@
+from fast_depends.provider import dependency_provider
+from fast_depends.usage import Depends, inject
+
+__all__ = (
+    "inject",
+    "Depends",
+    "dependency_provider",
+)

fast_depends-1.0.0/fast_depends/construct.py

@@ -0,0 +1,250 @@
+import inspect
+from typing import Any, Dict, Optional, Tuple, Type, Union
+
+from pydantic import BaseConfig
+from pydantic.class_validators import Validator
+from pydantic.fields import (
+    SHAPE_FROZENSET,
+    SHAPE_LIST,
+    SHAPE_SEQUENCE,
+    SHAPE_SET,
+    SHAPE_TUPLE,
+    SHAPE_TUPLE_ELLIPSIS,
+    FieldInfo,
+    ModelField,
+    Required,
+    Undefined,
+    UndefinedType,
+)
+from pydantic.schema import get_annotation_from_field_info
+from pydantic.typing import ForwardRef, evaluate_forwardref, get_args, get_origin
+from typing_extensions import Annotated
+
+from fast_depends import model
+from fast_depends.types import AnyCallable, AnyDict
+
+sequence_shapes = {
+    SHAPE_LIST,
+    SHAPE_SET,
+    SHAPE_FROZENSET,
+    SHAPE_TUPLE,
+    SHAPE_SEQUENCE,
+    SHAPE_TUPLE_ELLIPSIS,
+}
+sequence_types = (list, set, tuple)
+
+
+def get_dependant(
+    *,
+    path: str,
+    call: AnyCallable,
+    name: Optional[str] = None,
+    use_cache: bool = True,
+) -> model.Dependant:
+    dependant = model.Dependant(
+        call=call,
+        path=path,
+        name=name,
+        use_cache=use_cache,
+        return_field=None,
+    )
+
+    endpoint_signature = get_typed_signature(call)
+    signature_params = endpoint_signature.parameters
+
+    for param in signature_params.values():
+        depends, param_field = analyze_param(
+            param_name=param.name,
+            annotation=param.annotation,
+            default=param.default,
+        )
+
+        if param.name == model.RETURN_FIELD:
+            dependant.return_field = param_field
+            continue
+
+        if depends is not None:
+            sub_dependant = get_param_sub_dependant(
+                param_name=param.name,
+                depends=depends,
+                path=path,
+            )
+            dependant.dependencies.append(sub_dependant)
+
+        dependant.params.append(param_field)
+
+    return dependant
+
+
+def analyze_param(
+    *,
+    param_name: str,
+    annotation: Any,
+    default: Any,
+) -> Tuple[Any, Optional[model.Depends], Optional[ModelField]]:
+    depends = None
+    field_info = None
+
+    if (
+        annotation is not inspect.Signature.empty
+        and get_origin(annotation) is Annotated  # type: ignore[comparison-overlap]
+    ):
+        annotated_args = get_args(annotation)
+        custom_annotations = [
+            arg
+            for arg in annotated_args[1:]
+            if isinstance(arg, (FieldInfo, model.Depends))
+        ]
+
+        custom_annotations = next(iter(custom_annotations), None)
+        if isinstance(custom_annotations, FieldInfo):
+            field_info = custom_annotations
+            assert field_info.default is Undefined or field_info.default is Required, (
+                f"`{field_info.__class__.__name__}` default value cannot be set in"
+                f" `Annotated` for {param_name!r}. Set the default value with `=` instead."
+            )
+            field_info.default = Required
+
+        elif isinstance(custom_annotations, model.Depends):  # pragma: no branch
+            depends = custom_annotations
+
+    if isinstance(default, model.Depends):
+        assert depends is None, (
+            "Cannot specify `Depends` in `Annotated` and default value"
+            f" together for {param_name!r}"
+        )
+        assert field_info is None, (
+            "Cannot specify a annotation in `Annotated` and `Depends` as a"
+            f" default value together for {param_name!r}"
+        )
+        depends = default
+
+    elif isinstance(default, FieldInfo):
+        assert field_info is None, (
+            "Cannot specify annotations in `Annotated` and default value"
+            f" together for {param_name!r}"
+        )
+        field_info = default
+
+    if depends is not None:
+        field = None
+
+    if field_info is not None:
+        annotation = get_annotation_from_field_info(
+            annotation if annotation is not inspect.Signature.empty else Any,
+            field_info,
+            param_name,
+        )
+    else:
+        field_info = FieldInfo(default=default)
+
+    alias = field_info.alias or param_name
+
+    field = create_response_field(
+        name=param_name,
+        type_=annotation,
+        default=field_info.default if depends is None else None,
+        alias=alias,
+        required=field_info.default in (Required, Undefined, inspect._empty),
+        field_info=field_info,
+    )
+
+    return depends, field
+
+
+def get_typed_signature(call: AnyCallable) -> inspect.Signature:
+    signature = inspect.signature(call)
+    globalns = getattr(call, "__globals__", {})
+    typed_params = [
+        inspect.Parameter(
+            name=param.name,
+            kind=param.kind,
+            default=param.default,
+            annotation=get_typed_annotation(param.annotation, globalns),
+        )
+        for param in signature.parameters.values()
+    ]
+
+    if signature.return_annotation is not signature.empty:
+        typed_params.append(
+            inspect.Parameter(
+                name=model.RETURN_FIELD,
+                kind=inspect._KEYWORD_ONLY,
+                annotation=get_typed_annotation(signature.return_annotation, globalns),
+            )
+        )
+    typed_signature = inspect.Signature(typed_params)
+    return typed_signature
+
+
+def get_typed_annotation(annotation: Any, globalns: AnyDict) -> Any:
+    if isinstance(annotation, str):
+        try:
+            annotation = ForwardRef(annotation)
+            annotation = evaluate_forwardref(annotation, globalns, globalns)
+        except Exception:
+            raise ValueError(  # noqa: B904
+                f"Invalid filed annotation! Hint: check that {annotation} is a valid pydantic field type"
+            )
+    return annotation
+
+
+def get_param_sub_dependant(
+    *,
+    param_name: str,
+    depends: model.Depends,
+    path: str,
+) -> model.Dependant:
+    assert depends.dependency
+    return get_sub_dependant(
+        depends=depends,
+        dependency=depends.dependency,
+        path=path,
+        name=param_name,
+    )
+
+
+def get_sub_dependant(
+    *,
+    depends: model.Depends,
+    dependency: AnyCallable,
+    path: str,
+    name: Optional[str] = None,
+) -> model.Dependant:
+    sub_dependant = get_dependant(
+        path=path,
+        call=dependency,
+        name=name,
+        use_cache=depends.use_cache,
+    )
+    return sub_dependant
+
+
+def create_response_field(
+    name: str,
+    type_: Type[Any],
+    class_validators: Optional[Dict[str, Validator]] = None,
+    default: Optional[Any] = None,
+    required: Union[bool, UndefinedType] = True,
+    model_config: Type[BaseConfig] = BaseConfig,
+    field_info: Optional[FieldInfo] = None,
+    alias: Optional[str] = None,
+) -> ModelField:
+    """
+    Create a new response field. Raises if type_ is invalid.
+    """
+    try:
+        return ModelField(
+            name=name,
+            type_=type_ if type_ is not inspect._empty else Any,
+            class_validators=class_validators or {},
+            default=default,
+            required=required,
+            model_config=model_config,
+            alias=alias,
+            field_info=field_info or FieldInfo(),
+        )
+    except RuntimeError:  # pragma: no cover
+        raise ValueError(  # noqa: B904
+            f"Invalid args for response field! Hint: check that {type_} is a valid pydantic field type"
+        )

fast_depends-1.0.0/fast_depends/injector.py

@@ -0,0 +1,308 @@
+import asyncio
+import functools
+import inspect
+from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
+from copy import deepcopy
+from typing import (
+    Any,
+    AsyncGenerator,
+    Callable,
+    ContextManager,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    cast,
+)
+
+import anyio
+from pydantic.error_wrappers import ErrorWrapper
+from pydantic.errors import MissingError
+from pydantic.fields import ModelField
+
+from fast_depends.construct import get_dependant
+from fast_depends.model import Dependant
+from fast_depends.types import AnyCallable, AnyDict, P
+
+T = TypeVar("T")
+
+
+async def solve_dependencies_async(
+    *,
+    dependant: Dependant,
+    stack: AsyncExitStack,
+    body: Optional[AnyDict] = None,
+    dependency_overrides_provider: Optional[Any] = None,
+    dependency_cache: Optional[Dict[Tuple[AnyCallable, Tuple[str]], Any]] = None,
+) -> Tuple[
+    Dict[str, Any],
+    List[ErrorWrapper],
+    Dict[Tuple[AnyCallable, Tuple[str]], Any],
+]:
+    errors: List[ErrorWrapper] = []
+
+    dependency_cache = dependency_cache or {}
+
+    sub_dependant: Dependant
+    for sub_dependant in dependant.dependencies:
+        sub_dependant.call = cast(AnyCallable, sub_dependant.call)
+        sub_dependant.cache_key = cast(
+            Tuple[AnyCallable, Tuple[str]], sub_dependant.cache_key
+        )
+        call = sub_dependant.call
+        use_sub_dependant = sub_dependant
+        if (
+            dependency_overrides_provider
+            and dependency_overrides_provider.dependency_overrides
+        ):
+            call = getattr(
+                dependency_overrides_provider, "dependency_overrides", {}
+            ).get(sub_dependant.call)
+            if call is not None:  # pragma: no branch
+                use_sub_dependant = get_dependant(
+                    path=sub_dependant.path,
+                    call=call,
+                    name=sub_dependant.name,
+                )
+
+        solved_result = await solve_dependencies_async(
+            dependant=use_sub_dependant,
+            body=body,
+            dependency_overrides_provider=dependency_overrides_provider,
+            dependency_cache=dependency_cache,
+            stack=stack,
+        )
+        (
+            sub_values,
+            sub_errors,
+            sub_dependency_cache,
+        ) = solved_result
+
+        dependency_cache.update(sub_dependency_cache)
+
+        if sub_errors:
+            errors.extend(sub_errors)
+            continue
+
+        if (
+            use_sub_dependant.use_cache
+            and use_sub_dependant.cache_key in dependency_cache
+        ):
+            solved = dependency_cache[use_sub_dependant.cache_key]
+        elif is_gen_callable(call) or is_async_gen_callable(call):
+            solved, sub_errors = use_sub_dependant.cast_response(
+                await solve_generator_async(
+                    call=call, stack=stack, sub_values=sub_values
+                )
+            )
+        else:
+            solved, sub_errors = use_sub_dependant.cast_response(
+                await run_async(dependant=use_sub_dependant, values=sub_values)
+            )
+
+        if sub_errors:
+            errors.append(sub_errors)
+            continue
+
+        if use_sub_dependant.name is not None:  # pragma: no branch
+            body[use_sub_dependant.name] = solved
+
+        if use_sub_dependant.cache_key not in dependency_cache:
+            dependency_cache[use_sub_dependant.cache_key] = solved
+
+    params, main_errors = params_to_args(dependant.params, body or {})
+    errors.extend(main_errors)
+    return params, errors, dependency_cache
+
+
+def solve_dependencies_sync(
+    *,
+    dependant: Dependant,
+    stack: ExitStack,
+    body: Optional[AnyDict] = None,
+    dependency_overrides_provider: Optional[Any] = None,
+    dependency_cache: Optional[Dict[Tuple[AnyCallable, Tuple[str]], Any]] = None,
+) -> Tuple[
+    Dict[str, Any],
+    List[ErrorWrapper],
+    Dict[Tuple[AnyCallable, Tuple[str]], Any],
+]:
+    assert not is_coroutine_callable(dependant.call) and not is_async_gen_callable(
+        dependant.call
+    ), f"You can't call async `{dependant.call.__name__}` at sync code"
+
+    errors: List[ErrorWrapper] = []
+
+    dependency_cache = dependency_cache or {}
+
+    sub_dependant: Dependant
+    for sub_dependant in dependant.dependencies:
+        sub_dependant.call = cast(AnyCallable, sub_dependant.call)
+        sub_dependant.cache_key = cast(
+            Tuple[AnyCallable, Tuple[str]], sub_dependant.cache_key
+        )
+        call = sub_dependant.call
+        use_sub_dependant = sub_dependant
+        if (
+            dependency_overrides_provider
+            and dependency_overrides_provider.dependency_overrides
+        ):
+            call = getattr(
+                dependency_overrides_provider, "dependency_overrides", {}
+            ).get(sub_dependant.call)
+            if call is not None:  # pragma: no branch
+                use_sub_dependant = get_dependant(
+                    path=sub_dependant.path,
+                    call=call,
+                    name=sub_dependant.name,
+                )
+
+        solved_result = solve_dependencies_sync(
+            dependant=use_sub_dependant,
+            body=body,
+            stack=stack,
+            dependency_overrides_provider=dependency_overrides_provider,
+            dependency_cache=dependency_cache,
+        )
+        (
+            sub_values,
+            sub_errors,
+            sub_dependency_cache,
+        ) = solved_result
+
+        dependency_cache.update(sub_dependency_cache)
+
+        if sub_errors:
+            errors.extend(sub_errors)
+            continue
+
+        if (
+            use_sub_dependant.use_cache
+            and use_sub_dependant.cache_key in dependency_cache
+        ):
+            solved = dependency_cache[sub_dependant.cache_key]
+        elif is_gen_callable(call):
+            solved, sub_errors = use_sub_dependant.cast_response(
+                solve_generator_sync(call=call, stack=stack, sub_values=sub_values)
+            )
+        else:
+            solved, sub_errors = use_sub_dependant.cast_response(call(**sub_values))
+
+        if sub_errors:
+            errors.append(sub_errors)
+            continue
+
+        if use_sub_dependant.name is not None:  # pragma: no branch
+            body[sub_dependant.name] = solved
+
+        if use_sub_dependant.cache_key not in dependency_cache:
+            dependency_cache[use_sub_dependant.cache_key] = solved
+
+    params, main_errors = params_to_args(dependant.params, body or {})
+    errors.extend(main_errors)
+    return params, errors, dependency_cache
+
+
+def is_async_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isasyncgenfunction(call):
+        return True
+    dunder_call = getattr(call, "__call__", None)  # noqa: B004
+    return inspect.isasyncgenfunction(dunder_call)
+
+
+def is_gen_callable(call: Callable[..., Any]) -> bool:
+    if inspect.isgeneratorfunction(call):
+        return True
+    dunder_call = getattr(call, "__call__", None)  # noqa: B004
+    return inspect.isgeneratorfunction(dunder_call)
+
+
+def is_coroutine_callable(call: AnyCallable) -> bool:
+    if inspect.isroutine(call):
+        return inspect.iscoroutinefunction(call)
+    if inspect.isclass(call):
+        return False
+    call = getattr(call, "__call__", None)  # noqa: B004
+    return inspect.iscoroutinefunction(call)
+
+
+async def solve_generator_async(
+    *, call: Callable[..., Any], stack: AsyncExitStack, sub_values: Dict[str, Any]
+) -> Any:
+    if is_gen_callable(call):
+        cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values))
+    elif is_async_gen_callable(call):  # pragma: no branch
+        cm = asynccontextmanager(call)(**sub_values)
+    return await stack.enter_async_context(cm)
+
+
+def solve_generator_sync(
+    *, call: Callable[..., Any], stack: ExitStack, sub_values: Dict[str, Any]
+) -> Any:
+    cm = contextmanager(call)(**sub_values)
+    return stack.enter_context(cm)
+
+
+async def run_async(*, dependant: Dependant, values: AnyDict) -> Any:
+    assert dependant.call is not None, "dependant.call must be a function"
+    if asyncio.iscoroutinefunction(dependant.call):
+        return await dependant.call(**values)
+    else:
+        return await run_in_threadpool(dependant.call, **values)
+
+
+async def run_in_threadpool(
+    func: Callable[P, T], *args: P.args, **kwargs: P.kwargs
+) -> T:
+    if kwargs:  # pragma: no cover
+        func = functools.partial(func, **kwargs)
+    return await anyio.to_thread.run_sync(func, *args)
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(
+    cm: ContextManager[T],
+) -> AsyncGenerator[T, None]:
+    exit_limiter = anyio.CapacityLimiter(1)
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = bool(
+            await anyio.to_thread.run_sync(
+                cm.__exit__, type(e), e, None, limiter=exit_limiter
+            )
+        )
+        if not ok:  # pragma: no branch
+            raise e
+    else:
+        await anyio.to_thread.run_sync(
+            cm.__exit__, None, None, None, limiter=exit_limiter
+        )
+
+
+def params_to_args(
+    required_params: Sequence[ModelField],
+    received_params: Mapping[str, Any],
+) -> Tuple[AnyDict, List[ErrorWrapper]]:
+    values: AnyDict = {}
+    errors: List[ErrorWrapper] = []
+    for field in required_params:
+        value = received_params.get(field.alias)
+        if value is None:
+            if field.required:
+                errors.append(ErrorWrapper(MissingError(), loc=(field.alias,)))
+            else:
+                values[field.name] = deepcopy(field.default)
+            continue
+
+        v_, errors_ = field.validate(value, values, loc=(field.alias,))
+        if isinstance(errors_, ErrorWrapper):
+            errors.append(errors_)
+        elif isinstance(errors_, list):  # pragma: no cover
+            errors.extend(errors_)
+        else:
+            values[field.name] = v_
+    return values, errors

fast_depends-1.0.0/fast_depends/model.py

@@ -0,0 +1,51 @@
+from typing import Any, List, Optional, Tuple
+
+from pydantic.error_wrappers import ErrorList
+from pydantic.fields import ModelField
+
+from fast_depends.types import AnyCallable
+
+RETURN_FIELD = "custom_return"
+
+
+class Dependant:
+    def __init__(
+        self,
+        *,
+        call: Optional[AnyCallable] = None,
+        params: Optional[List[ModelField]] = None,
+        return_field: Optional[ModelField] = None,
+        dependencies: Optional[List["Dependant"]] = None,
+        use_cache: bool = True,
+        path: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> None:
+        self.params = params or []
+        self.return_field = return_field
+        self.dependencies = dependencies or []
+        self.call = call
+        self.use_cache = use_cache
+        # Parent argument name at subdependency
+        self.name = name
+        # Store the path to be able to re-generate a dependable from it in overrides
+        self.path = path
+        # Save the cache key at creation to optimize performance
+        self.cache_key = (self.call,)
+
+    def cast_response(self, response: Any) -> Tuple[Optional[Any], Optional[ErrorList]]:
+        if self.return_field is None:
+            return response, []
+        return self.return_field.validate(response, {}, loc=RETURN_FIELD)
+
+
+class Depends:
+    def __init__(
+        self, dependency: Optional[AnyCallable] = None, *, use_cache: bool = True
+    ) -> None:
+        self.dependency = dependency
+        self.use_cache = use_cache
+
+    def __repr__(self) -> str:
+        attr = getattr(self.dependency, "__name__", type(self.dependency).__name__)
+        cache = "" if self.use_cache else ", use_cache=False"
+        return f"{self.__class__.__name__}({attr}{cache})"

fast_depends-1.0.0/fast_depends/provider.py

@@ -0,0 +1,17 @@
+from typing import Dict
+
+from fast_depends.types import AnyCallable
+
+
+class Provider:
+    def __init__(self):
+        self.dependency_overrides: Dict[AnyCallable, AnyCallable] = {}
+
+    def override(self, original: AnyCallable, override: AnyCallable) -> None:
+        self.dependency_overrides[original] = override
+
+    def clear(self) -> None:
+        self.dependency_overrides = {}
+
+
+dependency_provider = Provider()

fast_depends-1.0.0/fast_depends/types.py

@@ -0,0 +1,8 @@
+from typing import Any, Callable, Dict, TypeVar
+from typing_extensions import ParamSpec, TypeAlias
+
+P = ParamSpec("P")
+
+AnyCallable = TypeVar("AnyCallable", bound=Callable[..., Any])
+DecoratedCallable: TypeAlias = AnyCallable
+AnyDict = TypeVar("AnyDict", bound=Dict[str, Any])

fast_depends-1.0.0/fast_depends/usage.py

@@ -0,0 +1,106 @@
+from contextlib import AsyncExitStack, ExitStack
+from functools import partial, wraps
+from typing import Any, Callable, Optional, TypeVar
+
+from pydantic import BaseModel, ValidationError, create_model
+
+from fast_depends import model
+from fast_depends.construct import get_dependant
+from fast_depends.injector import (
+    is_coroutine_callable,
+    run_async,
+    solve_dependencies_async,
+    solve_dependencies_sync,
+)
+from fast_depends.provider import dependency_provider
+from fast_depends.types import AnyCallable, P
+from fast_depends.utils import args_to_kwargs
+
+T = TypeVar("T")
+
+
+def Depends(  # noqa: N802
+    dependency: Optional[AnyCallable] = None, *, use_cache: bool = True
+) -> Any:
+    return model.Depends(dependency=dependency, use_cache=use_cache)
+
+
+def inject(
+    func: Callable[P, T],
+    *,
+    dependency_overrides_provider: Optional[Any] = dependency_provider,
+) -> Callable[P, T]:
+    dependant = get_dependant(call=func, path=func.__name__)
+    error_model = create_model(func.__name__)
+
+    if is_coroutine_callable(func) is True:
+        f = async_typed_wrapper
+    else:
+        f = sync_typed_wrapper
+
+    return wraps(func)(
+        partial(
+            f,
+            dependant=dependant,
+            error_model=error_model,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+    )
+
+
+async def async_typed_wrapper(
+    *args: P.args,
+    dependant: model.Dependant,
+    error_model: BaseModel,
+    dependency_overrides_provider: Optional[Any],
+    **kwargs: P.kwargs,
+) -> Any:
+    kwargs = args_to_kwargs((x.name for x in dependant.params), *args, **kwargs)
+
+    async with AsyncExitStack() as stack:
+        solved_result, errors, _ = await solve_dependencies_async(
+            body=kwargs,
+            dependant=dependant,
+            stack=stack,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+
+        if errors:
+            raise ValidationError(errors, error_model)
+
+        v, errors = dependant.cast_response(
+            await run_async(dependant=dependant, values=solved_result)
+        )
+
+        if errors:
+            raise ValidationError(errors, error_model)
+
+        return v
+
+
+def sync_typed_wrapper(
+    *args: P.args,
+    dependant: model.Dependant,
+    error_model: BaseModel,
+    dependency_overrides_provider: Optional[Any],
+    **kwargs: P.kwargs,
+) -> Any:
+    kwargs = args_to_kwargs((x.name for x in dependant.params), *args, **kwargs)
+
+    with ExitStack() as stack:
+        solved_result, errors, _ = solve_dependencies_sync(
+            body=kwargs,
+            dependant=dependant,
+            stack=stack,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+
+        if errors:
+            raise ValidationError(errors, error_model)
+
+        v, errors = dependant.cast_response(dependant.call(**solved_result))
+
+        if errors:
+            raise ValidationError(errors, error_model)
+
+        return v

fast_depends-1.0.0/fast_depends/utils.py

@@ -0,0 +1,14 @@
+from typing import Sequence
+
+from fast_depends.types import AnyDict, P
+
+
+def args_to_kwargs(
+    arguments: Sequence[str], *args: P.args, **kwargs: P.kwargs
+) -> AnyDict:
+    if not args:
+        return kwargs
+
+    unused = filter(lambda x: x not in kwargs, arguments)
+
+    return dict((*zip(unused, args), *kwargs.items()))

fast_depends-1.0.0/pyproject.toml

@@ -0,0 +1,190 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fast-depends"
+description = "FastDepends - extracted and cleared from HTTP domain Fastapi Dependency Injection System"
+readme = "README.md"
+authors = [
+    { name = "Pastukhov Nikita", email = "diementros@yandex.ru" },
+]
+
+keywords = ["fastapi", "dependency injection"]
+
+requires-python = ">=3.7"
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 1",
+]
+
+dependencies = [
+    "pydantic>=1.8",
+    "anyio",
+]
+
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://lancetnik.github.io/FastDI/"
+Documentation = "https://lancetnik.github.io/FastDI/"
+Tracker = "https://github.com/Lancetnik/FastDI/issues"
+Source = "https://github.com/Lancetnik/FastDI"
+
+[project.optional-dependencies]
+test = [
+    "coverage[toml]>=7.2",
+    "pytest>=7",
+    "pytest-asyncio>=0.21",
+    "pytest-xdist[psutil]",
+
+    "asyncmock; python_version < '3.8'",
+]
+
+doc = [
+    "mkdocs-material >=8.1.4,<9.0.0",
+    "mkdocstrings[python]>=0.18",
+    "mdx-include >=1.4.1,<2.0.0",
+    "mkdocs-markdownextradata-plugin >=0.1.7,<0.3.0",
+]
+
+dev = [
+    "FastDepends[test]",
+    "FastDepends[doc]",
+
+    "mypy>=1.1",
+    "black>=23.3.0",
+    "isort>=5",
+    "ruff>=0.0.260",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+allow-ambiguous-features = true
+
+[tool.hatch.version]
+path = "fast_depends/__about__.py"
+
+[tool.hatch.build]
+skip-excluded-dirs = true
+exclude = [
+    "/tests",
+    "/docs",
+]
+
+[tool.hatch.envs.default]
+python = "3.11" 
+skip-install = false
+features = [
+  "dev",
+]
+
+[tool.hatch.envs.test]
+features = [
+  "test",
+]
+
+[tool.hatch.envs.test.scripts]
+run = "pytest -q"
+
+[[tool.hatch.envs.test.matrix]]
+python = ["37", "38", "39", "310", "311"]
+
+[tool.hatch.envs.test-last]
+python = "3.11"
+features = [
+  "test",
+]
+
+[tool.hatch.envs.test-last.scripts]
+run = "pytest -q"
+cov = "bash ./scripts/test-cov.sh -v"
+
+[tool.mypy]
+strict = true
+ignore_missing_imports = true
+
+[tool.isort]
+profile = "black"
+known_third_party = ["pydantic", "anyio"]
+
+[tool.ruff]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+]
+ignore = [
+    "E501",  # line too long, handled by black
+    "C901",  # too complex
+]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+addopts = "-q"
+testpaths = [
+    "tests",
+]
+
+[tool.coverage.run]
+parallel = true
+branch = true
+concurrency = [
+    "multiprocessing",
+    "thread"
+]
+source = [
+    "fastdi",
+    "tests"
+]
+context = '${CONTEXT}'
+omit = [
+    "**/__init__.py",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+exclude_lines = [
+    ".*# pragma: no cover",
+    "if __name__ == .__main__.:",
+    "self.logger",
+    "def __repr__",
+    "lambda: None",
+    "from .*",
+    "import .*",
+    '@(abc\.)?abstractmethod',
+    "raise NotImplementedError",
+    'raise AssertionError',
+    'raise ValueError',
+    'logger\..*',
+    "pass",
+    '\.\.\.',
+]
+omit = [
+    '*/__about__.py',
+    '*/__main__.py',
+    '*/__init__.py',
+]

fast_depends-1.0.0/scripts/lint.sh

@@ -0,0 +1,4 @@
+mypy fastdi tests
+ruff fastdi tests --fix
+black fastdi tests
+isort fastdi tests

fast_depends-1.0.0/scripts/publish.sh

@@ -0,0 +1,3 @@
+hatch clean
+hatch build
+hatch publish

fast_depends-1.0.0/scripts/test-cov.sh

@@ -0,0 +1,5 @@
+bash scripts/test.sh "$@"
+coverage combine
+coverage report --show-missing
+
+rm .coverage*

fast_depends-1.0.0/scripts/test.sh

@@ -0,0 +1 @@
+coverage run -m pytest "$@"

fast_depends-1.0.0/wtf.py

@@ -0,0 +1,13 @@
+import contextlib
+from fast_depends import inject, Depends
+
+@contextlib.contextmanager
+def dep():
+    print("here")
+    return 1
+
+@inject
+def func(d = Depends(dep)):
+    return d
+
+func()