fastapi-injected 0.1.0__tar.gz

fastapi_injected-0.1.0/.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: uv
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "03:00"
+  open-pull-requests-limit: 10
+  assignees:
+    - "uriyyo"
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily

fastapi_injected-0.1.0/.github/workflows/automerge.yml

@@ -0,0 +1,20 @@
+name: Dependabot auto-merge
+
+on: 
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - name: Enable auto-merge for Dependabot PRs
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

fastapi_injected-0.1.0/.github/workflows/lint.yml

@@ -0,0 +1,35 @@
+name: Lint
+
+on:
+  pull_request:
+    types:
+      - "opened"
+      - "synchronize"
+  push:
+    branches:
+      - "main"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Install dependencies
+        run: |
+          uv sync --all-extras --dev
+
+      - name: Lint
+        run: |
+          uv run pre-commit run --all-files --show-diff-on-failure

fastapi_injected-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Build
+        run: |
+          uv build
+
+      - name: Publish
+        env:
+          PYPI_USERNAME: ${{ secrets.PYPI_USERNAME }}
+          PYPI_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        run: |
+          uv publish -u "${{ env.PYPI_USERNAME }}" -p "${{ env.PYPI_PASSWORD }}"

fastapi_injected-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,41 @@
+name: Test
+
+on:
+  pull_request:
+    types:
+      - "opened"
+      - "synchronize"
+  push:
+    branches:
+      - "main"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+
+      - name: Install dependencies
+        run: |
+          uv sync --all-extras --dev
+
+      - name: Unit tests
+        run: |
+          uv run pytest tests --cov=fastapi_filters --cov-report=term-missing --cov-report=xml
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v7
+        with:
+          file: ./coverage.xml

fastapi_injected-0.1.0/.gitignore

@@ -0,0 +1,139 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# test dbs
+*.db
+test_db.sqlite
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEA
+.idea/
+
+# ruff
+.ruff_cache/

fastapi_injected-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,26 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff-format
+        language: python
+        name: ruff-format
+        pass_filenames: false
+        language_version: python3.12
+        entry: uv run ruff format fastapi_injected tests
+
+  - repo: local
+    hooks:
+      - id: ruff
+        language: python
+        name: ruff
+        pass_filenames: false
+        language_version: python3.12
+        entry: uv run ruff check --fix --exit-non-zero-on-fix --show-fixes fastapi_injected tests
+
+  - repo: local
+    hooks:
+      - id: ty
+        language: python
+        name: ty
+        pass_filenames: false
+        entry: uv run ty check fastapi_injected tests/test_typing.py --error-on-warning

fastapi_injected-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yurii Karabas
+
+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.

fastapi_injected-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: fastapi-injected
+Version: 0.1.0
+Summary: Yet another library to reuse fastapi dependency injection
+Project-URL: Repository, https://github.com/uriyyo/fastapi-injected
+Author-email: Yurii Karabas <1998uriyyo@gmail.com>
+License-Expression: MIT
+License-File: 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.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.139.2
+Description-Content-Type: text/markdown
+
+# fastapi-injected
+
+Yet another attempt to reuse FastAPI's dependency injection outside of request handlers.
+
+This is an opinionated library: it takes the DI machinery you already know from FastAPI (`Depends`, generator dependencies with teardown, dependency caching) and makes it usable in plain async functions — background jobs, CLI commands, workers, scripts — without a `Request` in sight.
+
+## Installation
+
+```sh
+pip install fastapi-injected
+```
+
+Requires Python 3.12+.
+
+## Usage
+
+Declare dependencies as regular classes and annotate fields with `Dep[...]`:
+
+```python
+from dataclasses import dataclass
+from typing import AsyncIterator
+
+from fastapi_injected import Dep, DepFactory, Inejected, inject
+
+
+@dataclass
+class Session:
+    closed: bool = False
+
+
+async def session_dep() -> AsyncIterator[Session]:
+    session = Session()
+    try:
+        yield session
+    finally:
+        session.closed = True
+
+
+@dataclass
+class Repository:
+    session: DepFactory[Session, session_dep]
+
+
+@dataclass
+class Service:
+    repo: Dep[Repository]
+
+
+@inject
+async def handler(*, service: Dep[Service] = Inejected) -> None:
+    ...  # service is built and injected, session is closed on exit
+
+
+await handler()
+```
+
+- `Dep[T]` — resolve `T` by calling it, same as FastAPI's `Annotated[T, Depends()]`.
+- `DepFactory[T, factory]` — resolve `T` via a factory, same as `Annotated[T, Depends(factory)]`. Generator factories get proper teardown.
+- `Inejected` — a sentinel default that exists purely to make type checkers happy: without it they would complain about a missing argument at call sites. At runtime the parameter is always filled in by `@inject`.
+
+Injected parameters mix freely with regular ones — pass your own arguments as usual and the rest is injected:
+
+```python
+@inject
+async def add(a: int, b: int, *, service: Dep[Service] = Inejected) -> int:
+    ...
+
+
+result = await add(1, 2)
+```
+
+### Solving a type directly
+
+No decorator needed — resolve a dependency graph on demand:
+
+```python
+from fastapi_injected import solve
+
+service = await solve(Service)
+```
+
+### Scopes and caching
+
+By default every call to an injected function gets its own scope: dependencies are built, cached within the call, and torn down when it returns. Wrap several calls in `push_inject_scope()` to share one cache (and defer teardown to the end of the scope):
+
+```python
+from fastapi_injected import push_inject_scope
+
+async with push_inject_scope():
+    a = await handler()  # dependencies built here
+    b = await handler()  # same instances reused
+# generator dependencies are torn down here
+```
+
+Use `@inject(new_scope=True)` to opt a function out of the surrounding scope and always get fresh dependencies.
+
+## License
+
+MIT

fastapi_injected-0.1.0/README.md

@@ -0,0 +1,99 @@
+# fastapi-injected
+
+Yet another attempt to reuse FastAPI's dependency injection outside of request handlers.
+
+This is an opinionated library: it takes the DI machinery you already know from FastAPI (`Depends`, generator dependencies with teardown, dependency caching) and makes it usable in plain async functions — background jobs, CLI commands, workers, scripts — without a `Request` in sight.
+
+## Installation
+
+```sh
+pip install fastapi-injected
+```
+
+Requires Python 3.12+.
+
+## Usage
+
+Declare dependencies as regular classes and annotate fields with `Dep[...]`:
+
+```python
+from dataclasses import dataclass
+from typing import AsyncIterator
+
+from fastapi_injected import Dep, DepFactory, Inejected, inject
+
+
+@dataclass
+class Session:
+    closed: bool = False
+
+
+async def session_dep() -> AsyncIterator[Session]:
+    session = Session()
+    try:
+        yield session
+    finally:
+        session.closed = True
+
+
+@dataclass
+class Repository:
+    session: DepFactory[Session, session_dep]
+
+
+@dataclass
+class Service:
+    repo: Dep[Repository]
+
+
+@inject
+async def handler(*, service: Dep[Service] = Inejected) -> None:
+    ...  # service is built and injected, session is closed on exit
+
+
+await handler()
+```
+
+- `Dep[T]` — resolve `T` by calling it, same as FastAPI's `Annotated[T, Depends()]`.
+- `DepFactory[T, factory]` — resolve `T` via a factory, same as `Annotated[T, Depends(factory)]`. Generator factories get proper teardown.
+- `Inejected` — a sentinel default that exists purely to make type checkers happy: without it they would complain about a missing argument at call sites. At runtime the parameter is always filled in by `@inject`.
+
+Injected parameters mix freely with regular ones — pass your own arguments as usual and the rest is injected:
+
+```python
+@inject
+async def add(a: int, b: int, *, service: Dep[Service] = Inejected) -> int:
+    ...
+
+
+result = await add(1, 2)
+```
+
+### Solving a type directly
+
+No decorator needed — resolve a dependency graph on demand:
+
+```python
+from fastapi_injected import solve
+
+service = await solve(Service)
+```
+
+### Scopes and caching
+
+By default every call to an injected function gets its own scope: dependencies are built, cached within the call, and torn down when it returns. Wrap several calls in `push_inject_scope()` to share one cache (and defer teardown to the end of the scope):
+
+```python
+from fastapi_injected import push_inject_scope
+
+async with push_inject_scope():
+    a = await handler()  # dependencies built here
+    b = await handler()  # same instances reused
+# generator dependencies are torn down here
+```
+
+Use `@inject(new_scope=True)` to opt a function out of the surrounding scope and always get fresh dependencies.
+
+## License
+
+MIT

fastapi_injected-0.1.0/fastapi_injected/__init__.py

@@ -0,0 +1,13 @@
+from .inject import inject
+from .scope import push_inject_scope
+from .solve import solve
+from .types import Dep, DepFactory, Inejected
+
+__all__ = [
+    "Dep",
+    "DepFactory",
+    "Inejected",
+    "inject",
+    "push_inject_scope",
+    "solve",
+]