diff --git a/.github/actions/environment/action.yml b/.github/actions/environment/action.yml index c174636..2370b86 100644 --- a/.github/actions/environment/action.yml +++ b/.github/actions/environment/action.yml @@ -16,4 +16,4 @@ runs: - name: Install Dependencies shell: bash - run: uv sync + run: uv sync --no-group bench diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml index 6b0ab2d..62ef492 100644 --- a/.github/workflows/cd.yml +++ b/.github/workflows/cd.yml @@ -13,7 +13,7 @@ jobs: steps: - name: Run checkout - uses: actions/checkout@v5 + uses: actions/checkout@v6 - name: Set up environment uses: ./.github/actions/environment diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1d6f254..1a41d69 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -20,7 +20,7 @@ jobs: steps: - name: Run checkout - uses: actions/checkout@v5 + uses: actions/checkout@v6 - name: Set up environment uses: ./.github/actions/environment diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml new file mode 100644 index 0000000..263eb29 --- /dev/null +++ b/.github/workflows/pages.yml @@ -0,0 +1,29 @@ +name: GitHub Pages + +on: + push: + branches: + - prod + +jobs: + delivery: + name: Delivery + runs-on: ubuntu-latest + permissions: + contents: write + + steps: + - name: Run checkout + uses: actions/checkout@v6 + + - name: Configure Git + run: | + git config --global user.name "github-pages[bot]" + git config --global user.email "github-pages[bot]@users.noreply.github.com" + + - name: Set up environment + uses: ./.github/actions/environment + + - name: Deploy MkDocs + shell: bash + run: uv run mkdocs gh-deploy --force diff --git a/Makefile b/Makefile index f51e5cb..0f40974 100644 --- a/Makefile +++ b/Makefile @@ -19,3 +19,6 @@ pyright: pytest: uv run pytest + +mkdocs: + uv run mkdocs serve diff --git a/README.md b/README.md index 98724ad..2fb8644 100644 --- a/README.md +++ b/README.md @@ -5,35 +5,18 @@ [![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=blue)](https://pypistats.org/packages/python-injection) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) +Documentation: https://python-injection.remimd.dev + ## Installation ⚠️ _Requires Python 3.12 or higher_ - ```bash pip install python-injection ``` -## Features - -* Automatic dependency resolution based on type hints. -* Support for multiple dependency lifetimes: `transient`, `singleton`, `constant`, and `scoped`. -* Works seamlessly in both `async` and `sync` environments. -* Separation of dependency sets using modules. -* Runtime switching between different sets of dependencies. -* Centralized setup logic using entrypoints. -* Built-in type annotation for easy integration with [`FastAPI`](https://github.com/fastapi/fastapi). -* Lazy dependency resolution for optimized performance. - -## Motivations - -1. Easy to use -2. No impact on class and function definitions -3. No tedious configuration - ## Quick start Simply apply the decorators and the package takes care of the rest. - ```python from injection import injectable, inject, singleton @@ -61,25 +44,3 @@ def main(service: Service): if __name__ == "__main__": main() ``` - -## Resources - -> ⚠️ The package isn't threadsafe by default, for better performance in single-threaded applications and those using -> `asyncio`. -> -> Non-threadsafe functions are those that resolve dependencies or define scopes. They all come with an optional -> parameter `threadsafe`. -> -> You can set `PYTHON_INJECTION_THREADSAFE=1` in environment variables to make the package fully threadsafe. The -> environment variable is resolved at the **Python module level**, so be careful if the variable is defined dynamically. - -* [**Basic usage**](https://github.com/100nm/python-injection/tree/prod/documentation/basic-usage.md) -* [**Scoped dependencies**](https://github.com/100nm/python-injection/tree/prod/documentation/scoped-dependencies.md) -* [**Testing**](https://github.com/100nm/python-injection/tree/prod/documentation/testing.md) -* [**Advanced usage**](https://github.com/100nm/python-injection/tree/prod/documentation/advanced-usage.md) -* [**Loaders**](https://github.com/100nm/python-injection/tree/prod/documentation/loaders.md) -* [**Entrypoint**](https://github.com/100nm/python-injection/tree/prod/documentation/entrypoint.md) -* [**Integrations**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations) - * [**FastAPI**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/fastapi.md) - * [**What if my framework isn't listed?**](https://github.com/100nm/python-injection/tree/prod/documentation/integrations/unlisted-framework.md) -* [**Concrete example**](https://github.com/100nm/python-injection-example) diff --git a/docs/CNAME b/docs/CNAME new file mode 100644 index 0000000..025c862 --- /dev/null +++ b/docs/CNAME @@ -0,0 +1 @@ +python-injection.remimd.dev diff --git a/docs/guides/imports.md b/docs/guides/imports.md new file mode 100644 index 0000000..e21f94d --- /dev/null +++ b/docs/guides/imports.md @@ -0,0 +1,73 @@ +# Auto-imports + +When using decorators to register dependencies, some implementations may never be explicitly imported in your project. This creates a problem: if a module is never imported, its decorators never execute, and the dependencies are never registered. + +For example, if you register an implementation with `@injectable(on=AbstractDependency)` but never import that implementation module, the dependency won't be available for injection even though it's decorated. + +To solve this, `python-injection` provides two solutions for automatically importing modules in a package. + +!!! tip + Call auto-import functions early in your application startup, **before loading your profile** and before any dependency resolution occurs. + +## load_packages + +The `load_packages` function imports all modules from the specified packages. Packages can be passed as module objects or as strings: +```python +from injection.loaders import load_packages +from src import adapters, services + +# Import all modules in adapters and services packages +load_packages(adapters, services) + +# Or using string notation +load_packages("src.adapters", "src.services") +``` + +This is the simplest approach and works well when you want to import everything from specific packages. + +## PythonModuleLoader + +For more control over which modules get imported, use `PythonModuleLoader` with a custom predicate function. Like `load_packages`, it accepts both module objects and strings: +```python +from injection.loaders import PythonModuleLoader +from src import adapters, services + +def predicate(module_name: str) -> bool: + # Only import modules containing "impl" in their name + return "impl" in module_name + +PythonModuleLoader(predicate).load(adapters, services) +``` + +The predicate function receives the full module name (e.g., `"src.adapters.dependency_impl"`) and returns `True` if the module should be imported. + +### Factory methods + +`PythonModuleLoader` provides three convenient factory methods for common filtering patterns: + +**Filter by prefix:** +```python +# Import only modules starting with "impl_" +PythonModuleLoader.startswith("impl_").load(adapters, services) +``` + +**Filter by suffix:** +```python +# Import only modules ending with "_impl" +PythonModuleLoader.endswith("_impl").load(adapters, services) +``` + +**Filter by keyword marker:** +```python +# Import only modules containing a specific comment +PythonModuleLoader.from_keywords("# auto-import").load(adapters, services) +``` + +This last approach is particularly useful for explicitly marking which modules should be auto-imported: +```python +# auto-import + +@injectable(on=AbstractDependency) +class Dependency(AbstractDependency): + ... +``` diff --git a/docs/guides/main-functions.md b/docs/guides/main-functions.md new file mode 100644 index 0000000..99b3074 --- /dev/null +++ b/docs/guides/main-functions.md @@ -0,0 +1,113 @@ +# Set up main functions + +As we've seen throughout this guide, there can be quite a bit of setup around a main function: loading modules, defining scopes, injecting dependencies, loading profiles, etc. This becomes repetitive when you have multiple entry points in your project (CLI commands, etc.). + +To solve this, `python-injection` provides **entrypoints**, a way to create custom decorators that encapsulate all your setup logic using a builder pattern. + +## Creating an entrypoint + +Use the `@entrypointmaker` decorator to define your setup logic once: +```python +from injection import adefine_scope +from injection.entrypoint import AsyncEntrypoint, Entrypoint, entrypointmaker +from injection.loaders import PythonModuleLoader + +@entrypointmaker +def entrypoint[**P, T](self: AsyncEntrypoint[P, T]) -> Entrypoint[P, T]: + import src + + module_loader = PythonModuleLoader.endswith("_impl") + return ( + self.inject() + .decorate(adefine_scope("lifespan", kind="shared")) + .async_to_sync() + .load_modules(module_loader, src) + ) +``` + +Now you can use your custom `@entrypoint` decorator on any function: +```python +@entrypoint +async def main(dependency: Dependency): + # All setup is automatically applied + ... + +if __name__ == "__main__": + main() +``` + +!!! info "Builder execution order" + The builder instructions execute in **reverse order**. Each method call re-decorates the main function, so the last instruction in the chain is call first. In the example above, modules are loaded first, then the function is converted to sync, then the scope is defined, and finally dependencies are injected. + +### Automatic execution + +The entrypoint decorator accepts an optional `autocall` parameter. When set to `True`, the decorated function is automatically called: +```python +@entrypoint(autocall=True) +async def main(dependency: Dependency): + # This function runs automatically when the module is executed + ... +``` + +This is particularly convenient for scripts and CLI commands where you want the entry point to execute immediately. + +## Integrating with ProfileLoader + +If you're using a [`ProfileLoader`](profiles.md#profileloader) in your project, pass it to `@entrypointmaker` using the `profile_loader` parameter: +```python +from injection.entrypoint import Entrypoint, entrypointmaker +from injection.loaders import ProfileLoader, PythonModuleLoader + +profile_loader = ProfileLoader(...) + +@entrypointmaker(profile_loader=profile_loader) +def entrypoint[**P, T](self: Entrypoint[P, T]) -> Entrypoint[P, T]: + import src + + module_loader = PythonModuleLoader.endswith("_impl") + return ( + self.inject() + .load_profile(Profile.DEV) # Load a specific profile + .load_modules(module_loader, src) + ) +``` + +The `load_profile` method accepts a profile name and loads it before the main function executes. + +## Resolving dependencies in the setup + +You can resolve dependencies from the setup function parameters. These dependencies must be registered in the default module (not in a profile-specific module) and should preferably be transient or constant. This is particularly useful for resolving configuration to determine which profile to load: +```python +from dataclasses import dataclass +from injection import constant +from injection.entrypoint import Entrypoint, entrypointmaker +from injection.loaders import PythonModuleLoader +from os import getenv + +@dataclass +class Config: + profile: Profile + +@constant +def _config_factory() -> Config: + profile = Profile(getenv("PROFILE", "development")) + return Config(profile) + +@entrypointmaker(profile_loader=profile_loader) +def entrypoint[**P, T](self: Entrypoint[P, T], config: Config) -> Entrypoint[P, T]: + import src + + profile = config.profile # Use config to determine profile + suffixes = self.profile_loader.required_module_names(profile) + module_loader = PythonModuleLoader.endswith(*suffixes) + return ( + self.inject() + .load_profile(profile) + .load_modules(module_loader, src) + ) +``` + +In this example, `config` is resolved from the default module and used to dynamically load the appropriate profile. + +!!! warning + Dependencies resolved in the entrypoint setup function must be registered in the default module (not in a profile-specific module) and should be transient or constant to avoid state issues. diff --git a/docs/guides/profiles.md b/docs/guides/profiles.md new file mode 100644 index 0000000..8d378cd --- /dev/null +++ b/docs/guides/profiles.md @@ -0,0 +1,88 @@ +# Profiles + +Profiles allow you to swap different implementations of dependencies based on your environment or context (e.g., development, production, staging). This is particularly useful when you need different database connections, API clients, or configurations depending on where your application runs. + +## Modules + +The `Module` object is the core component for managing dependencies within a profile. Each module represents a set of dependencies specific to a particular profile. You can retrieve a module instance using the `mod` function. + +Storing your profile names in a `StrEnum` is recommended for type safety and consistency. +```python +from enum import StrEnum +from injection import mod + +class Profile(StrEnum): + DEV = "development" + PROD = "production" + STAGING = "staging" + +# Get a module for a specific profile +dev_module = mod(Profile.DEV) +``` + +Once you have a module, you can use it to register dependencies that should only be available when that profile is active. The module provides access to all the registration decorators we've seen earlier (`injectable`, `singleton`, `scoped`, `constant`) as well as the `set_constant` method. + +## Loading a profile + +!!! warning "Caution" + Always load your profile as early as possible in your program's execution, ideally at startup before any dependency resolution occurs. + +### load_profile + +For straightforward use cases, use the `load_profile` function: +```python +from injection.loaders import load_profile + +load_profile(Profile.DEV) +``` + +This is the simplest approach when each profile is independent and doesn't share dependencies with other profiles. + +### ProfileLoader + +For more complex scenarios where profiles share common subsets of dependencies, use `ProfileLoader`: +```python +from injection.loaders import ProfileLoader + +profile_loader = ProfileLoader({ + Profile.DEV: [SubProfile.STUB], + Profile.TEST: [SubProfile.STUB], +}) + +profile_loader.load(Profile.DEV) +``` + +In this example, both "dev" and "test" profiles load the "stub" module, allowing you to reuse common mock implementations or shared configurations across multiple profiles. + +!!! danger + Only create a single `ProfileLoader` instance for your entire application to avoid conflicts. It's recommended to instantiate it at the Python module level (as a global variable) to ensure uniqueness. + +#### Inspecting required modules + +`ProfileLoader` provides a `required_module_names` method that returns the set of module names required by a profile. This is useful for debugging or validating your profile configuration. +```python +dev_modules = profile_loader.required_module_names(Profile.DEV) +# Returns: frozenset({, , '__default__'}) +``` + +### Using loaders as context managers + +Both `load_profile` and `ProfileLoader` can be used as context managers. When the context exits, the profile is unloaded and all cached instances are cleared: +```python +with load_profile(Profile.DEV): + # Dev profile is active + run_app() + +# Profile is unloaded, cache is cleared +``` + +With `ProfileLoader`: +```python +with profile_loader.load(Profile.DEV): + # Dev profile is active + run_app() + +# Profile is unloaded, cache is cleared +``` + +This is particularly useful in testing scenarios where you want to ensure complete isolation between test runs. diff --git a/docs/guides/register-dependencies.md b/docs/guides/register-dependencies.md new file mode 100644 index 0000000..ea276a0 --- /dev/null +++ b/docs/guides/register-dependencies.md @@ -0,0 +1,143 @@ +# Register dependencies + +`python-injection` provides four main decorators to register your dependencies: `@injectable`, `@singleton`, `@scoped`, and `@constant`. These decorators can be applied to classes, sync functions, or async functions. The `@scoped` decorator additionally supports sync and async generator functions for context manager support. For pre-existing values, use the `set_constant` function. + +All constructor parameters and factory function parameters are automatically resolved based on their type annotations. + +## Transient + +A new instance is created every time the dependency is resolved. +```python +from injection import injectable + +@injectable +class Dependency: + ... +``` + +## Singleton + +A single instance is created and shared across the entire application. +```python +from injection import singleton + +@singleton +class Dependency: + ... +``` + +## Constant + +Register a pre-existing value as a dependency. +```python +from dataclasses import dataclass +from injection import set_constant + +@dataclass(frozen=True) +class Settings: + api_key: str + +settings = set_constant(Settings("")) +``` + +You can also use type aliases to register constants for primitive types: +```python +from injection import set_constant + +type APIKey = str + +api_key = set_constant("", APIKey, alias=True) +``` + +For lazy constants, use the `@constant` decorator: +```python +from injection import constant + +@constant +class LazySettings: + ... +``` + +## Factories + +All decorators work with both sync and async functions. + +_Make sure not to forget the return type annotation._ +```python +from injection import injectable + +class Dependency: + ... + +@injectable +def _dependency_factory() -> Dependency: + # ... + return Dependency() +``` + +## Abstract classes + +Register an implementation for an abstract class or protocol. + +!!! warning + Make sure the implementation is properly imported in your project for it to be registered (see [auto-imports](imports.md) section). +```python +from injection import injectable +from abc import ABC + +class AbstractDependency(ABC): + ... + +@injectable(on=AbstractDependency) +class Dependency(AbstractDependency): + ... +``` + +## Scoped + +A single instance is created per scope. Using a `StrEnum` for scope names is recommended. +```python +from injection import scoped + +@scoped("") +class Dependency: + ... +``` + +## Scoped with context manager + +Scoped dependencies can be registered using generator functions (sync or async) to handle setup and teardown logic. + +!!! note + If you're unfamiliar with context managers, [see Python's context manager documentation](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager). +```python +from collections.abc import Iterator +from injection import scoped + +class Dependency: + def open(self): + ... + + def close(self): + ... + +@scoped("") +def dependency_factory() -> Iterator[Dependency]: + dependency = Dependency() + dependency.open() + try: + yield dependency + finally: + dependency.close() +``` + +## Profiles + +Register a dependency for a specific profile. Using a `StrEnum` for profile names is recommended. +```python +from injection import mod + +@mod("").injectable +class Dependency: + ... +``` \ No newline at end of file diff --git a/docs/guides/resolve-dependencies.md b/docs/guides/resolve-dependencies.md new file mode 100644 index 0000000..6f10dba --- /dev/null +++ b/docs/guides/resolve-dependencies.md @@ -0,0 +1,137 @@ +# Resolve dependencies + +## Inject + +The `@inject` decorator automatically resolves function parameters based on their type annotations when the function is called. +```python +from injection import inject + +@inject +def function(dependency: Dependency): + ... + +function() # You can now call `function` without arguments +``` + +When `@inject` is applied to an async function, it can resolve dependencies that require an async context. If an async dependency is required by a sync function decorated with `@inject`, a `RuntimeError` will be raised. + +!!! note "Performance note" + The first call to an injected function is slower because it performs dependency resolution. Subsequent calls are faster as the resolution is cached. + +### Static type checkers + +Static type checkers like mypy will complain about missing arguments when calling injected functions: +```python +@inject +def function(dependency: Dependency): + ... + +function() # ❌ mypy error: Missing positional argument "dependency" in call to "function" [call-arg] +``` + +To fix this, provide a default value for injected parameters: +```python +@inject +def function(dependency: Dependency = NotImplemented): + ... + +function() # ✅ OK +``` + +Using `NotImplemented` as the default value is recommended because it acts as a sentinel value: if the function is called without injection, any attempt to use the dependency will produce a clear and understandable error. + +### asfunction + +The `@asfunction` decorator provides an alternative to `@inject` for cases where frameworks don't allow unknown parameters in their functions. +```python +from injection import asfunction +from typing import NamedTuple + +@asfunction +class Function(NamedTuple): + dependency: Dependency + + def __call__(self, foo: str, bar: str, baz: str): + # Use self.dependency here + ... + +# Call with only the runtime parameters +Function("foo", "bar", "baz") +``` + +**When to use `@asfunction`:** + +In most cases, the `@inject` decorator is sufficient. However, some frameworks strictly validate function signatures and raise errors when they encounter unexpected parameters. The `@asfunction` decorator solves this by separating injected dependencies (defined as class attributes) from runtime parameters (defined in `__call__`). + +Using `NamedTuple` is recommended for its concise syntax and built-in immutability. + +## Getters + +Getters provide an alternative way to retrieve dependencies without using the `@inject` decorator. They are particularly useful when you need to resolve dependencies programmatically or in contexts where decorators aren't suitable. + +### find_instance + +Returns the instance of the specified type or raises `NoInjectable` if not found. +```python +from injection import find_instance + +dependency = find_instance(Dependency) +``` + +This is useful when you expect the dependency to always be available and want to fail fast if it's not registered. + +### get_instance + +Returns the instance of the specified type or `NotImplemented` if not found. +```python +from injection import get_instance + +dependency = get_instance(Dependency) +``` + +### get_lazy_instance + +Returns an object with the `__invert__` operator implemented. Calling `~` on this object resolves and returns the instance, or `NotImplemented` if not found. +```python +from injection import get_lazy_instance + +lazy_dependency = get_lazy_instance(Dependency) +# ... later in your code +dependency = ~lazy_dependency +``` + +This is useful when you want to defer dependency resolution until it's actually needed. + +### Async variants + +All three getters have async versions prefixed with `a`: +```python +from injection import afind_instance, aget_instance, aget_lazy_instance + +# Async variants +dependency = await afind_instance(Dependency) +dependency = await aget_instance(Dependency) + +lazy_dependency = aget_lazy_instance(Dependency) +dependency = await lazy_dependency # Note: awaitable instead of invertible +``` + +The async version of `get_lazy_instance` returns an awaitable instead of an invertible object. + +## Descriptors + +### LazyInstance + +`LazyInstance` is a descriptor that acts as a getter, resolving the dependency each time it's accessed via `self`. +```python +from injection import LazyInstance + +class Class: + dependency = LazyInstance(Dependency) + + def do_something(self): + self.dependency.some_method() # Resolved on every access +``` + +!!! warning + Dependencies requiring an async context are not compatible with `LazyInstance` since descriptors cannot be awaited. diff --git a/docs/guides/scopes.md b/docs/guides/scopes.md new file mode 100644 index 0000000..c645f76 --- /dev/null +++ b/docs/guides/scopes.md @@ -0,0 +1,74 @@ +# Custom scopes + +Scopes allow you to control the lifetime of dependencies within a specific context. We've seen how to register scoped dependencies earlier. Now let's look at how to define and use scopes. + +## Defining scopes + +The `define_scope` context manager creates a scope for the duration of the context. It takes two parameters: + +- **scope_name** (required): The name of the scope. Using a `StrEnum` to store scope names is recommended. +- **kind** (optional): Either `"contextual"` (default) or `"shared"`. + +```python +from injection import define_scope + +with define_scope(""): + # Dependencies registered with this scope are available here + ... +``` + +### Scope kinds + +**Contextual scopes** (default) are based on [`ContextVar`](https://docs.python.org/3/library/contextvars.html#contextvars.ContextVar), meaning each concurrent context (like async tasks) maintains its own isolated scope: +```python +with define_scope("", kind="contextual"): + # Each async task will have its own isolated scope + ... +``` + +**Shared scopes** are based on global state, meaning all code within the scope shares the same dependency instances: +```python +with define_scope("", kind="shared"): + # All code shares the same scope instances + ... +``` + +### Async scopes + +For dependencies instantiated with async context managers, the async version `adefine_scope` is required: +```python +from injection import adefine_scope + +async with adefine_scope(""): + # Async scoped dependencies are available here + ... +``` + +## Defining scopes with bindings + +`MappedScope` allows you to define scopes with associated data bindings. This is useful when you want to make specific values available within the scope context. **Bindings are injectable in all dependencies**, making them accessible throughout your dependency graph. +```python +from injection import MappedScope + +type Locale = str + +@dataclass +class Bindings: + locale: Locale + + scope = MappedScope("") + +with Bindings("fr_FR").scope.define(): + # Dependencies can now access the locale binding + ... +``` + +The `define` method also accepts the `kind` parameter with the same `"contextual"` and `"shared"` options. + +For async scopes with bindings, use `adefine`: +```python +async with Bindings("fr_FR").scope.adefine(): + ... +``` + +This pattern is particularly useful for request-scoped data in web applications, where each request might have its own set of contextual values that need to be accessible to dependencies within that request's scope. diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..5f4c502 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,63 @@ +# python-injection + +[![PyPI - Version](https://img.shields.io/pypi/v/python-injection.svg?color=546d78&style=for-the-badge)](https://pypi.org/project/python-injection) +[![PyPI - Downloads](https://img.shields.io/pypi/dm/python-injection.svg?color=546d78&style=for-the-badge)](https://pypistats.org/packages/python-injection) + +## Project motivations + +Dependency injection in Python has long been a source of frustration. + +Existing solutions are often verbose, require extensive boilerplate, or fail to leverage Python's type hints effectively. `python-injection` was created to solve these problems once and for all by providing a simple, elegant, and powerful dependency injection framework that feels natural to Python developers. + +The goal is straightforward: make dependency injection so easy that you'll wonder how you ever managed without it. + +## Why choose python-injection? + +- **Type-driven resolution**: Dependencies are automatically resolved using Python's type annotations. +- **Decorator-based registration**: Register your dependencies with simple, readable decorators. +- **Flexible lifetimes**: Choose from 4 type of lifetimes to match your needs: + - **Transient**: A new instance every time + - **Singleton**: One instance for the entire application + - **Scoped**: One instance per scope, with context manager support + - **Constant**: Register pre-existing values +- **Profile support**: Ability to swap certain dependencies based on a profile. +- **Pull-based instantiation**: Dependencies are only created when needed, improving startup time and resource usage. +- **Full sync/async support**: Works seamlessly with both synchronous and asynchronous code. + +## Installation + +Requires Python 3.12 or higher. +```bash +pip install python-injection +``` + +## Quick start + +Simply apply the decorators and the package takes care of the rest. +```python +from injection import injectable, inject, singleton + +@singleton +class Printer: + def __init__(self): + self.history = [] + + def print(self, message: str): + self.history.append(message) + print(message) + +@injectable +class Service: + def __init__(self, printer: Printer): + self.printer = printer + + def hello(self): + self.printer.print("Hello world!") + +@inject +def main(service: Service): + service.hello() + +if __name__ == "__main__": + main() +``` diff --git a/documentation/integrations/fastapi.md b/docs/integrations/fastapi.md similarity index 77% rename from documentation/integrations/fastapi.md rename to docs/integrations/fastapi.md index f18fdaf..e607f3d 100644 --- a/documentation/integrations/fastapi.md +++ b/docs/integrations/fastapi.md @@ -3,25 +3,24 @@ ## Inject a dependency Here's how to inject an instance into a FastAPI endpoint. - ```python from injection.ext.fastapi import Inject @app.get("/") -async def my_endpoint(service: Inject[MyService]) -> None: +async def endpoint(dependency: Inject[Dependency]): ... ``` ## Useful scopes Two fairly common scopes in FastAPI: -* **Application lifespan scope**: associate with application lifespan. -* **Request scope**: associate with http request lifetime. -_For a better understanding of the scopes, [here's the associated documentation](../scoped-dependencies.md)._ +- **Application lifespan scope**: associate with application lifespan. +- **Request scope**: associate with http request lifetime. -Here's how to configure FastAPI: +_For a better understanding of the scopes, [here's the associated documentation](../guides/scopes.md)._ +Here's how to configure FastAPI: ```python from collections.abc import AsyncIterator from contextlib import asynccontextmanager @@ -36,12 +35,13 @@ class InjectionScope(StrEnum): REQUEST = auto() @asynccontextmanager -async def lifespan(_: FastAPI) -> AsyncIterator[None]: +async def lifespan(app: FastAPI) -> AsyncIterator[None]: async with adefine_scope(InjectionScope.LIFESPAN, kind="shared"): yield @dataclass class FastAPIRequestBindings: + # You can use any bindings; Request is just an example. request: Request scope = MappedScope(InjectionScope.REQUEST) diff --git a/docs/testing/classes.md b/docs/testing/classes.md new file mode 100644 index 0000000..84fecdf --- /dev/null +++ b/docs/testing/classes.md @@ -0,0 +1,38 @@ +# Writing test classes + +Test frameworks like pytest and unittest don't allow custom `__init__` methods in test classes. To inject dependencies into test classes, use `LazyInstance` for sync dependencies and `aget_lazy_instance` for async dependencies. + +## Using LazyInstance + +The `LazyInstance` descriptor resolves dependencies on access: +```python +from injection import LazyInstance + +class TestFeature: + dependency = LazyInstance(Dependency) + + def test_something(self): + result = self.dependency.some_method() + assert result == expected_value +``` + +## Using aget_lazy_instance for async + +For async dependencies, use `aget_lazy_instance` which returns an awaitable: +```python +from injection import aget_lazy_instance + +class TestAsyncFeature: + lazy_dependency = aget_lazy_instance(AsyncDependency) + + async def test_something(self): + dependency = await self.lazy_dependency + result = await dependency.some_method() + assert result == expected_value +``` + +!!! tip + Use `LazyInstance` for sync dependencies (cleaner syntax) and `aget_lazy_instance` only when you need async dependencies. + +!!! warning + `LazyInstance` resolves the dependency on **every access**. With transient dependencies, you get a new instance each time. With singletons, you get the same instance. diff --git a/docs/testing/pytest.md b/docs/testing/pytest.md new file mode 100644 index 0000000..423ee23 --- /dev/null +++ b/docs/testing/pytest.md @@ -0,0 +1,23 @@ +# [Pytest](https://github.com/pytest-dev/pytest) + +You can simplify test setup by creating a pytest fixture that automatically loads test dependencies. Add this fixture to your `conftest.py` file to make it available across all your tests. + +## Fixture +```python +# conftest.py + +import pytest +from injection.testing import load_test_profile + +@pytest.fixture(scope="function", autouse=True) +def setup_test_dependencies(): + with load_test_profile(): + yield +``` + +The `autouse=True` parameter ensures this fixture runs automatically for every test without needing to explicitly reference it. + +!!! note + If you're using a [`ProfileLoader`](../guides/profiles.md#profileloader), pass it to `load_test_profile`. + +With this setup, all your tests automatically have access to test dependencies without any additional configuration. diff --git a/docs/testing/test-dependencies.md b/docs/testing/test-dependencies.md new file mode 100644 index 0000000..799e09c --- /dev/null +++ b/docs/testing/test-dependencies.md @@ -0,0 +1,124 @@ +# Test dependencies + +Testing often requires replacing real dependencies with mocks, stubs, or test-specific implementations. The `injection.testing` module provides dedicated registration decorators that work alongside your regular dependencies without interfering with production code. + +## Activating test dependencies + +Before using test dependencies, you must activate the test profile using `load_test_profile`: +```python +from injection.testing import load_test_profile + +load_test_profile() +``` + +If you're using a [`ProfileLoader`](../guides/profiles.md#profileloader), pass it to `load_test_profile`: +```python +from injection.loaders import ProfileLoader +from injection.testing import load_test_profile + +profile_loader = ProfileLoader(...) + +load_test_profile(profile_loader) +``` + +`load_test_profile` can also be used as a context manager to automatically unload the test profile after test complete: +```python +from injection.testing import load_test_profile + +with load_test_profile(): + # Test dependencies are active here + run_test() + +# Test profile is unloaded, cache is cleared +``` + +## Test-specific decorators + +All the registration decorators you've seen earlier have test equivalents in `injection.testing`: +```python +from injection.testing import ( + set_test_constant, + test_constant, + test_injectable, + test_scoped, + test_singleton, +) +``` + +These decorators work exactly like their production counterparts but register dependencies in a separate test registry. + +### Using test decorators + +#### test_injectable + +```python +from injection.testing import test_injectable + +@test_injectable(on=AbstractDependency) +class MockDependency(AbstractDependency): + ... +``` + +#### test_singleton + +```python +from injection.testing import test_singleton + +@test_singleton(on=AbstractDependency) +class MockDependency(AbstractDependency): + ... +``` + +#### set_test_constant + +```python +from injection.testing import set_test_constant + +type APIKey = str + +test_api_key = set_test_constant("test_key_123", APIKey, alias=True) +``` + +#### test_constant + +```python +from dataclasses import dataclass +from injection import constant +from injection.testing import test_constant +from os import environ + +@dataclass(frozen=True) +class Settings: + api_key: str + debug: bool + +@constant +def _settings_factory() -> Settings: + return Settings(environ["API_KEY"], debug=False) + +@test_constant +def _settings_test_factory() -> Settings: + return Settings("test_key_123", debug=True) +``` + +#### test_scoped + +```python +from injection.testing import test_scoped + +@test_scoped("", on=AbstractDependency) +class MockDependency(AbstractDependency): + ... +``` + +## How test dependencies work + +Test dependencies are registered in a separate registry and **take precedence over production dependencies** when tests are running. This means: + +- You can override production implementations with test versions +- Production code remains unchanged +- Test dependencies are isolated from production dependencies +- No need to modify your production registration code + +!!! tip "Best practice" + Register test dependencies in your test files or in a dedicated test configuration module. This keeps test setup close to your tests and makes it clear which dependencies are being mocked. diff --git a/docs/threadsafety.md b/docs/threadsafety.md new file mode 100644 index 0000000..b95d43f --- /dev/null +++ b/docs/threadsafety.md @@ -0,0 +1,68 @@ +# Thread safety + +By default, `python-injection` is optimized for single-threaded performance. However, three components are not thread-safe: modules, dependency resolution, and scope definition. + +## Modules + +Module registration (using decorators like `@injectable`, `@singleton`, etc.) is not thread-safe. However, this is rarely an issue because modules are typically registered either: + +- At the Python module level (executed once during import) +- In the main function before any concurrent execution + +As long as you complete all module registration before spawning threads, you won't encounter issues. + +## Dependency resolution and scope definition + +Dependency resolution and scope definition are not thread-safe by default. If you need to resolve dependencies or define scopes in a multi-threaded environment, use the `threadsafe` parameter: +```python +from injection import define_scope, get_instance, inject + +# Thread-safe dependency injection +@inject(threadsafe=True) +def function(dependency: Dependency): + ... + +# Thread-safe manual resolution +dependency = get_instance(Dependency, threadsafe=True) + +# Thread-safe scope definition +with define_scope("", threadsafe=True): + ... +``` + +The `threadsafe` parameter is available on all functions that resolve dependencies or define scopes. + +## Global thread safety + +If you need thread safety throughout your application, set the `PYTHON_INJECTION_THREADSAFE` environment variable: +```bash +export PYTHON_INJECTION_THREADSAFE=1 +``` + +Or in Python: +```python +import os + +os.environ["PYTHON_INJECTION_THREADSAFE"] = "1" +``` + +When this environment variable is set, all dependency resolution and scope operations become thread-safe by default. + +!!! warning "Environment variable timing" + The `PYTHON_INJECTION_THREADSAFE` environment variable is resolved at the Python module level when `injection` is first imported. If you set environment variables dynamically in your main function, they may not take effect. Set the environment variable before importing `injection` or before running your application. +```python +# ❌ Too late - injection already imported +import injection +os.environ["PYTHON_INJECTION_THREADSAFE"] = "1" + +# ✅ Correct - set before import +os.environ["PYTHON_INJECTION_THREADSAFE"] = "1" +import injection +``` + +## Performance considerations + +Thread safety comes with a performance cost due to locking mechanisms. Only enable it when actually needed: + +- **Single-threaded applications**: Don't enable thread safety (default behavior is faster) +- **Multi-threaded applications**: Enable thread safety with the parameter or environment variable diff --git a/documentation/advanced-usage.md b/documentation/advanced-usage.md deleted file mode 100644 index 1d2098d..0000000 --- a/documentation/advanced-usage.md +++ /dev/null @@ -1,174 +0,0 @@ -# Advanced usage - -## Module - -A module is an object that contains an isolated injection environment. - -Modules have been designed to simplify unit test writing. So think carefully before instantiating a new one. They could -increase complexity unnecessarily if used extensively. - -### Get or create Module - -```python -from injection import mod - -custom_module = mod("custom_module") -``` - -### Basic decorators - -Modules contain basic decorators. [See more.](basic-usage.md) - -```python -# Injectable decorator - -@custom_module.injectable -class ServiceA: - ... - -# Singleton decorator - -@custom_module.singleton -class ServiceB: - ... - -# Inject decorator - -@custom_module.inject -def some_function(service_a: ServiceA, service_b: ServiceB): - ... -``` - -### Module interconnections - -> [!IMPORTANT] -> This section contains operations that can be performed between modules. In most cases, you don't need to worry about -> them. -> -> Instead, use [`ProfileLoader`](loaders.md#ProfileLoader) or [`load_profile`](loaders.md#load_profile), which are much -> simpler and easier to understand. - -> **Use a module** - -When a module is used by another module, the module's dependencies are replaced by those of the module used. - -```python -from injection import mod - -module_1 = mod("module_1") -module_2 = mod("module_2") - - -class AbstractService: - ... - - -@module_1.injectable(on=AbstractService) -class ConcreteService_1(AbstractService): - ... - - -@module_2.injectable(on=AbstractService) -class ConcreteService_2(AbstractService): - ... - - -@module_1.inject -def some_function(service: AbstractService): - ... - - -some_function() # Inject `ConcreteService_1` instance -module_1.use(module_2) -some_function() # Inject `ConcreteService_2` instance -module_1.stop_using(module_2) -some_function() # Inject `ConcreteService_1` instance -``` - -There's also a context decorator for using a module temporarily. - -```python -# Context Manager - -with module_1.use_temporarily(module_2): - ... - -# Decorator - -@module_1.use_temporarily(module_2) -def function(): - ... -``` - -> **Priorities** - -As a module can use several modules, there's a feature for prioritizing which modules to use. - -There are two priority values: -* **`LOW`**: The module concerned becomes the least important of the modules used. -* **`HIGH`**: The module concerned becomes the most important of the modules used. - -The default priority is **`LOW`**. - -Apply priority with `use` method: - -```python -module_1.use(module_2, priority="high") -``` - -Apply priority with `use_temporarily` method: - -```python -with module_1.use_temporarily(module_2, priority="high"): - ... -``` - -Change the priority of a used module: - -```python -module_1.change_priority(module_2, priority="low") -``` - -### Understand `ModuleLockError` - -> **Reason**: If a module is updated while a singleton is already instantiated, this error will be raised. - -#### Why? - -This error exists because there's a problem with singletons. If a module is updated while a singleton is instantiated, -there may be a problem with this instance. It may contain an obsolete dependency. - -#### How to avoid it? - -_First of all, make sure that all scripts containing injectables have been imported before executing the main function._ - -> [!TIP] -> * Avoid local imports -> * Avoid singletons if not necessary - -#### Unlock method - -If you know what you're doing, you can delete the cached instances of all singletons using the `unlock` method: - -```python -custom_module.unlock() -``` - -### Logging - -With a logging configuration that displays debug logs, you can observe everything that's happening in the modules. - -```python -import logging - -logging.basicConfig(level=logging.DEBUG) -``` - -Example: - -``` -DEBUG:python-injection:`Module(name='__default__')` now uses `Module(name='my_module')`. -DEBUG:python-injection:`Module(name='__default__')` has propagated an event: 1 dependency have been updated: `__main__.A`. -DEBUG:python-injection:`Module(name='my_module')` has propagated an event: 1 dependency have been updated: `__main__.B`. -DEBUG:python-injection:`Module(name='__default__')` has propagated an event: 1 dependency have been updated: `__main__.B`. -``` diff --git a/documentation/basic-usage.md b/documentation/basic-usage.md deleted file mode 100644 index 950e94a..0000000 --- a/documentation/basic-usage.md +++ /dev/null @@ -1,227 +0,0 @@ -# Basic usage - -## Register an injectable - -> [!NOTE] -> If the class needs dependencies, these will be resolved when the instance is retrieved. - -If you wish to inject a singleton, use `singleton` decorator. - -```python -from injection import singleton - -@singleton -class ServiceA: - """ class implementation """ -``` - -If you wish to inject a new instance each time, use `injectable` decorator. - -```python -from injection import injectable - -@injectable -class ServiceB: - """ class implementation """ -``` - -If you have a constant (such as a global variable) and wish to register it as an injectable, use `set_constant` -function. - -```python -from injection import set_constant - -class ServiceC: - """ class implementation """ - -service_c = set_constant(ServiceC()) -``` - -Or here is the decorator `constant` which is equivalent: - -> Unlike `@singleton`, dependencies will not be resolved. - -```python -from injection import constant - -@constant -class ServiceC: - """ class implementation """ -``` - -## Inject an instance - -To inject one or several instances, use `inject` decorator. -_Don't forget to annotate type of parameter to inject._ - -```python -from injection import inject - -@inject -def some_function(service_a: ServiceA): - """ function implementation """ -``` - -If `inject` decorates a class, it will be applied to the `__init__` method. -_Especially useful for dataclasses:_ - -> [!NOTE] -> Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the -> dependencies. - -```python -from dataclasses import dataclass - -from injection import inject - -@inject -@dataclass -class SomeDataClass: - service_a: ServiceA = ... -``` - -### Threadsafe injection - -With `threadsafe=True`, the injection logic is wrapped in a `threading.RLock`. - -```python -@inject(threadsafe=True) -def some_function(service_a: ServiceA): - """ function implementation """ -``` - -## Get an instance - -_Example with `get_instance` function:_ - -```python -from injection import get_instance - -service_a = get_instance(ServiceA) -``` - -_Example with `aget_instance` function:_ - -```python -from injection import aget_instance - -service_a = await aget_instance(ServiceA) -``` - -_Example with `get_lazy_instance` function:_ - -```python -from injection import get_lazy_instance - -lazy_service_a = get_lazy_instance(ServiceA) -# ... -service_a = ~lazy_service_a -``` - -_Example with `aget_lazy_instance` function:_ - -```python -from injection import aget_lazy_instance - -lazy_service_a = aget_lazy_instance(ServiceA) -# ... -service_a = await lazy_service_a -``` - -## Inheritance - -In the case of inheritance, you can use the decorator parameter `on` to link the injection to one or several other -classes. - -> [!WARNING] -> If the child class is in another file, make sure that file is imported before injection. -> [_See `load_packages` function._](loaders.md#load_packages) - -_Example with one class:_ - -```python -class AbstractService(ABC): - ... - -@injectable(on=AbstractService) -class ConcreteService(AbstractService): - ... -``` - -_Example with several classes:_ - -```python -class AbstractService(ABC): - ... - -class ConcreteService(AbstractService): - ... - -@injectable(on=(AbstractService, ConcreteService)) -class ConcreteServiceOverload(ConcreteService): - ... -``` - -If a class is registered in a package, and you want to override it, there is the `mode` parameter: - -```python -@injectable -class InaccessibleService: - ... - -# ... - -@injectable(on=InaccessibleService, mode="override") -class ServiceOverload(InaccessibleService): - ... -``` - -## Recipes - -A recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify -the return type annotation when defining the recipe. - -```python -from injection import injectable - -@injectable -def service_d_recipe() -> ServiceD: - """ recipe implementation """ -``` - -### Async recipes - -An asynchronous recipe is defined in the same way as a conventional recipe. To retrieve an instance of an asynchronous -recipe, you need to be in an asynchronous context (decorate an asynchronous function with `@inject` or use an -asynchronous getter). - -Asynchronous singletons can be retrieved in a synchronous context if they have already been instantiated. The -`all_ready` method ensures that all singletons have been instantiated. - -```python -from injection import get_instance, mod, singleton - -@singleton -async def service_e_recipe() -> ServiceE: - """ recipe implementation """ - -async def main(): - await mod().all_ready() - # ... - service_e = get_instance(ServiceE) -``` - -## Working with type aliases - -```python -from injection import injectable, set_constant - -type APIKey = str - -set_constant("", APIKey, alias=True) - -@injectable -class Client: - def __init__(self, api_key: APIKey): - ... -``` diff --git a/documentation/entrypoint.md b/documentation/entrypoint.md deleted file mode 100644 index 0605ea8..0000000 --- a/documentation/entrypoint.md +++ /dev/null @@ -1,106 +0,0 @@ -# Entrypoint - -## What is it? - -_An entrypoint is the first function executed when software starts._ - -When using `python-injection`, you often need to perform several setup actions at the entrypoint _(such as injecting -dependencies, opening a scope, or importing Python modules)_. - -To solve this problem, the package provides an `Entrypoint` class, a builder-style utility that simplifies -entrypoint preparation. - -## Creating an entrypoint decorator - -`entrypointmaker` allows you to define a custom decorator for your entrypoint functions. - -The function you decorate with `entrypointmaker` serves to configure the `Entrypoint` instance. Its first parameter must -be the `Entrypoint` instance being built. You can inject dependencies into this setup function, but **only** `constants` -or `injectables`, because everything is not yet fully configured at this stage. - -**Instruction order matters**: each configuration step applies a decorator and returns a new `Entrypoint` instance. - -Here's all you can do with an entrypoint _(take only what you need)_: - -```python -# src/entrypoint.py - -from enum import StrEnum, auto - -import uvloop -from injection import adefine_scope, mod -from injection.entrypoint import AsyncEntrypoint, Entrypoint, entrypointmaker -from injection.loaders import ProfileLoader, PythonModuleLoader -from pydantic_settings import BaseSettings - -class Profile(StrEnum): - DEFAULT = mod().name - DEV = "dev" - STAGING = "staging" - PROD = "prod" - -class SubProfile(StrEnum): - CONF = "conf" - -class Scope(StrEnum): - LIFESPAN = auto() - -@mod(SubProfile.CONF).constant -class Conf(BaseSettings): - profile: Profile = Profile.DEFAULT - -@entrypointmaker(profile_loader=ProfileLoader({Profile.DEFAULT: [SubProfile.CONF]})) -def entrypoint[**P, T](self: AsyncEntrypoint[P, T], conf: Conf) -> Entrypoint[P, T]: - import src - - profile = conf.profile - keyword = "# auto-import" - keywords = { - f"{keyword}: {name}" - for name in self.profile_loader.required_module_names(profile) - } - module_loader = PythonModuleLoader.from_keywords(*keywords) - return ( - self.inject() - .decorate(adefine_scope(Scope.LIFESPAN, kind="shared")) - .async_to_sync(uvloop.run) - .load_modules(module_loader, src) - .load_profile(profile) - ) -``` - -> [!IMPORTANT] -> **Typing rule** -> -> When creating a decorator for async entrypoints, make sure to type `self` as `AsyncEntrypoint`. -> For sync code, use `Entrypoint` instead. - -## Example of use - -Developing a CLI is a good example of using multiple entrypoints: - -```python -# src/cli.py - -from typer import Typer - -from src.entrypoint import entrypoint # the previously defined `entrypoint` decorator -from src.services.logger import AsyncLogger # project service, implementation not provided - -app = Typer() - -@app.command() -def hello(name: str) -> None: - @entrypoint(autocall=True) - async def _(logger: AsyncLogger) -> None: - await logger.info(f"Hello {name}!") - -@app.command() -def goodbye(name: str) -> None: - @entrypoint(autocall=True) - async def _(logger: AsyncLogger) -> None: - await logger.info(f"Goodbye {name}!") - -if __name__ == "__main__": - app() -``` \ No newline at end of file diff --git a/documentation/integrations/README.md b/documentation/integrations/README.md deleted file mode 100644 index 268e8b4..0000000 --- a/documentation/integrations/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Integrations - -**Integrations make it easy to connect `python-injection` to other frameworks.** diff --git a/documentation/integrations/unlisted-framework.md b/documentation/integrations/unlisted-framework.md deleted file mode 100644 index bb0a43b..0000000 --- a/documentation/integrations/unlisted-framework.md +++ /dev/null @@ -1,37 +0,0 @@ -# What if my framework isn't listed? - -You like `python-injection`, but your framework isn't officially supported? Don't worry, there are still several ways -to make it work. - -## If your framework doesn't inspect function signatures - -In most cases, if your framework doesn't inspect function signatures, you can use the `@inject` decorator without any -issues. - -## If your framework inspects function signatures - -If your framework inspects function signatures, things get a bit trickier. This is because dependencies can't be present -in function parameters. - -To solve this, you can define a class with a `__call__` method (where dependencies are injected when the class is -instantiated), and use the `asfunction` decorator to turn it into a function. - -The resulting function will have the same signature as the `__call__` method, but without the `self` parameter. - -Example: - -```python -from typing import NamedTuple -from injection import asfunction - -@asfunction -class DoSomething(NamedTuple): - service: MyService - - def __call__(self): - self.service.do_work() -``` - -## Need more than these tools? - -[**Feel free to start a discussion here.**](https://github.com/100nm/python-injection/discussions/new/choose) diff --git a/documentation/loaders.md b/documentation/loaders.md deleted file mode 100644 index b410077..0000000 --- a/documentation/loaders.md +++ /dev/null @@ -1,165 +0,0 @@ -# Loaders - -## PythonModuleLoader - -Useful for put in memory injectables hidden deep within a package. - -``` -package -├── sub_package -│ ├── __init__.py -│ └── module2.py -│ └── class Injectable2 -├── __init__.py -└── module1.py - └── class Injectable1 -``` - -To load Injectable1 and Injectable2 into memory you can do the following: - -```python -# Imports -from injection.loaders import PythonModuleLoader -import package -``` - -```python -def predicate(module_name: str) -> bool: - # logic to determine whether the module should be imported or not - return True - -PythonModuleLoader(predicate).load(package) -``` - -### Factory methods - -* `from_keywords` - -Automatically imports modules whose Python script contains one of the keywords passed in parameter. - -```python -PythonModuleLoader.from_keywords("# auto-import").load(package) -``` - -* `startswith` - -Automatically imports modules whose Python script name begins with one of the prefixes passed in parameter. - -```python -profile: str = ... -PythonModuleLoader.startswith(f"{profile}_").load(package) -``` - -* `endswith` - -Automatically imports modules whose Python script name ends with one of the suffixes passed in parameter. - -```python -profile: str = ... -PythonModuleLoader.endswith(f"_{profile}").load(package) -``` - -## load_packages - -`load_packages` is a simplified version of `PythonModuleLoader`. - -```python -from injection.loaders import load_packages - -import package - -load_packages(package) -``` - -## load_profile - -`load_profile` is an injection module initialization function based on profile name. -This is very useful when you want to use a set of dependencies based on the execution profile. - -> [!NOTE] -> A profile name is equivalent to an injection module name. - -For example, when I'm doing my development tests, I don't really feel like sending SMS messages. - -```python -import asyncio -from abc import abstractmethod -from typing import Protocol - -from injection import inject, mod, should_be_injectable, singleton -from injection.loaders import load_profile - -@should_be_injectable -class SMSService(Protocol): - @abstractmethod - async def send(self, phone_number: str, message: str): - raise NotImplementedError - -@singleton(on=SMSService) -class ConcreteSMSService(SMSService): - async def send(self, phone_number: str, message: str): - """ - Concrete implementation of `SMSService.send`. - """ - -@mod("dev").singleton(on=SMSService) -class ConsoleSMSService(SMSService): - async def send(self, phone_number: str, message: str): - print(f"SMS send to `{phone_number}`:\n{message}") - -@inject -async def send_sms(service: SMSService): - await service.send( - phone_number="+33 6 00 00 00 00", - message="Hello world!", - ) - -def main(profile_name: str = None, /): - if profile_name is not None: - load_profile(profile_name) - - asyncio.run(send_sms()) - -if __name__ == "__main__": - main("dev") # One could imagine the profile name being transmitted via an environment variable or CLI parameter -``` - -## ProfileLoader - -_This is a slightly more complete version of `load_profile`._ - -If you use modules as subsets of dependencies, this class will make your life easier. - -It is recommended to use a single instance of `ProfileLoader` to avoid unexpected behavior. If it exists, this instance -must be passed to `entrypointmaker` and `load_test_profile`. - -Here's an example of its use: - -```python -from injection import mod -from injection.loaders import ProfileLoader - -profile_loader = ProfileLoader( - { - mod().name: ["global"], - "dev": ["stub", "global"], - "test": ["stub", "global"], - "stub": ["global"] - } -) - -# Ensures that dependent modules are used properly. -# If `init` isn't called, it will be automatically called with `load`. -profile_loader.init() - -# Load `dev` profile. -profile_loader.load("dev") -``` - -> [!NOTE] -> `load` can also be used as a context manager: -> -> ```python -> with profile_loader.load(""): -> ... -> ``` diff --git a/documentation/scoped-dependencies.md b/documentation/scoped-dependencies.md deleted file mode 100644 index 98404ef..0000000 --- a/documentation/scoped-dependencies.md +++ /dev/null @@ -1,169 +0,0 @@ -# Scoped dependencies - -The scoped dependencies were created for two reasons: -* To have dependencies that have a defined lifespan. -* To be able to open and close things in a dependency recipe. - -## Best practices - -* Avoid making a singleton dependent on a scoped dependency. -* Define scope names in a `StrEnum`. - -## Scope - -The scope is responsible for instance persistence and for cleaning up when it closes. - -There are two kinds of scopes: -* **Contextual**: All threads have access to a different scope (based on [contextvars](https://docs.python.org/3.13/library/contextvars.html)). -* **Shared**: All threads have access to the same scope. - -First of all, the scope must be defined: - -_By default, the `kind` parameter is `"contextual"`._ - -> Define an asynchronous scope: - -```python -from injection import adefine_scope - -async def main() -> None: - async with adefine_scope(""): - ... -``` - -> Define a synchronous scope: - -```python -from injection import define_scope - -def main() -> None: - with define_scope(""): - ... -``` - -## MappedScope - -`MappedScope` allows you to open a dependency injection scope and register values with type annotation so they can be -retrieved by other dependencies within that scope. - -### How it works - -1. **Define bindings**: Create a class with type annotated fields. -2. **Create scope**: Instantiate `MappedScope` with a scope name. -3. **Open scope**: Use `define` or `adefine` context manager to register the scoped values. -4. **Access dependencies**: Other dependencies can now inject these scoped values within the context. - -This is particularly useful for request-scoped dependencies in web applications, where you need to make request-specific -data available throughout the request lifecycle. - -Example: - -```python -from dataclasses import dataclass -from injection import MappedScope - -class Request: ... - -@dataclass -class RequestBindings: - request: Request - - scope = MappedScope("request") - -def process_request(request: Request) -> None: - with RequestBindings(request).scope.define(): - # Dependencies can now access the scoped Request instance - ... -``` - -For asynchronous contexts, use `adefine`: - -```python -async def process_request_async(request: Request) -> None: - async with RequestBindings(request).scope.adefine(): - # Dependencies can now access the scoped Request instance - ... -``` - -## Register a scoped dependencies - -`@scoped` works exactly like `@injectable`, it just has extra features. - -### "contextmanager-like" recipes - -_Anything after the `yield` keyword will be executed when the scope is closed._ - -> Asynchronous (asynchronous scope required): - -```python -from collections.abc import AsyncIterator -from injection import scoped - -class Client: - async def open_connection(self) -> None: ... - - async def close_connection(self) -> None: ... - -@scoped("") -async def client_recipe() -> AsyncIterator[Client]: - # On resolving dependency - client = Client() - await client.open_connection() - - try: - yield client - finally: - # On scope close - await client.close_connection() -``` - -> Synchronous: - -```python -from collections.abc import Iterator -from injection import scoped - -class Client: - def open_connection(self) -> None: ... - - def close_connection(self) -> None: ... - -@scoped("") -def client_recipe() -> Iterator[Client]: - # On resolving dependency - client = Client() - client.open_connection() - - try: - yield client - finally: - # On scope close - client.close_connection() -``` - -### Scoped slots - -> [!IMPORTANT] -> It's preferable to use `MappedScope` instead. - -Scoped slots allow you to reserve a place for an instance within a predefined scope. This ensures that injected -functions can resolve dependencies efficiently without unnecessary recomputation. This is why the syntax can seem a -little verbose. - -Example: - -```python -from injection import define_scope, reserve_scoped_slot - -class Request: ... - -request_slot_key = reserve_scoped_slot(Request, scope_name="request") - -def process_request(request: Request) -> None: - with define_scope("request") as scope: - scope.set_slot(request_slot_key, request) - # ... -``` - -> [!NOTE] -> You can set several slots at once with the `slot_map` method. diff --git a/documentation/testing.md b/documentation/testing.md deleted file mode 100644 index 8f96cae..0000000 --- a/documentation/testing.md +++ /dev/null @@ -1,81 +0,0 @@ -# Testing - -## Test configuration - -Here is the [Pytest](https://github.com/pytest-dev/pytest) fixture for using test injectables on all tests: - -```python -# conftest.py - -import pytest -from injection.testing import load_test_profile - -@pytest.fixture(scope="session", autouse=True) -def autouse_test_injectables(): - # Ensure that test injectables have been imported here - - with load_test_profile(): - yield -``` - -## Register a test injectable - -> [!NOTE] -> * Test injectables replace conventional injectables if they are registered on the same type. -> * A test injectable can't depend on a conventional injectable. - -`@singleton` equivalent for testing: - - -```python -from injection.testing import test_singleton - -@test_singleton -class ServiceA: - """ class implementation """ -``` - -`@injectable` equivalent for testing: - - -```python -from injection.testing import test_injectable - -@test_injectable -class ServiceB: - """ class implementation """ -``` - -`set_constant` equivalent for testing: - -```python -from injection.testing import set_test_constant - -class ServiceC: - """ class implementation """ - -service_c = ServiceC() -set_test_constant(service_c) -``` - -## Writing test classes - -With Pytest, it's not possible to implement the `__init__` method of a test class, which makes retrieving dependencies -a little more complicated. -The solution provided by this package is based on a descriptor `LazyInstance`. -Each time the descriptor is accessed with `self`, the dependency is resolved. So **be careful** with `@injectable`, if you -want to keep its state, assign it to a variable. - -Here's an example: - -```python -from injection import LazyInstance - -class TestSomething: - dependency = LazyInstance(DependencyClass) - - def test_something(self): - # ... - self.dependency.do_work() - # ... -``` \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..623a0bd --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,56 @@ +site_name: python-injection + +repo_name: 100nm/python-injection +repo_url: https://github.com/100nm/python-injection + +markdown_extensions: + - admonition + - def_list + - pymdownx.highlight: + anchor_linenums: true + line_spans: __span + pygments_lang_class: true + - pymdownx.inlinehilite + - pymdownx.snippets + - pymdownx.superfences + +nav: + - Home: index.md + - Guides: + - Register dependencies: guides/register-dependencies.md + - Resolve dependencies: guides/resolve-dependencies.md + - Scopes: guides/scopes.md + - Profiles: guides/profiles.md + - Auto-imports: guides/imports.md + - Set up main functions: guides/main-functions.md + - Testing: + - Test dependencies: testing/test-dependencies.md + - Writing test classes: testing/classes.md + - Pytest: testing/pytest.md + - Thread safety: threadsafety.md + - Integrations: + - FastAPI: integrations/fastapi.md + +plugins: + - search + +theme: + name: material + icon: + repo: fontawesome/brands/github + palette: + scheme: slate + primary: blue grey + features: + - content.code.copy + - content.code.annotate + - content.tabs.link + - navigation.expand + - navigation.footer + - navigation.instant + - navigation.sections + - navigation.tabs + - navigation.top + - navigation.tracking + - search.highlight + - search.suggest diff --git a/pyproject.toml b/pyproject.toml index 346a388..b5f3f0e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,10 +14,10 @@ dev = [ "pyright", "ruff", ] -doc = [ - "fastapi", +docs = [ + "mkdocs", + "mkdocs-material", "pydantic-settings", - "typer", "uvloop", ] test = [ @@ -35,7 +35,7 @@ version = "0.0.0" description = "Fast and easy dependency injection framework." license = "MIT" license-files = ["LICENSE"] -readme = "README.md" +readme = "docs/index.md" requires-python = ">=3.12, <3.15" authors = [{ name = "remimd" }] keywords = ["dependencies", "dependency", "inject", "injection"] @@ -66,6 +66,7 @@ async = [ ] [project.urls] +Documentation = "https://python-injection.remimd.dev" Repository = "https://github.com/100nm/python-injection" [tool.coverage.report] @@ -135,5 +136,5 @@ ignore = ["N818"] fixable = ["ALL"] [tool.uv] -default-groups = ["bench", "dev", "doc", "test"] +default-groups = ["bench", "dev", "docs", "test"] package = true diff --git a/uv.lock b/uv.lock index 126811e..5c913b0 100644 --- a/uv.lock +++ b/uv.lock @@ -33,6 +33,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7f/9c/36c5c37947ebfb8c7f22e0eb6e4d188ee2d53aa3880f3f2744fb894f0cb1/anyio-4.12.0-py3-none-any.whl", hash = "sha256:dad2376a628f98eeca4881fc56cd06affd18f659b17a747d3ff0307ced94b1bb", size = 113362, upload-time = "2025-11-28T23:36:57.897Z" }, ] +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + [[package]] name = "backports-zstd" version = "1.2.0" @@ -92,6 +101,20 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/33/a519b4da2015069fb36cded5181ff078ecceb852861b675e2c79547ad10d/backports_zstd-1.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:a884be79cd0897436e1e06566d0b6bcad2360afca8e8e27fb19422ba0cca4d7a", size = 289583, upload-time = "2025-12-06T20:26:00.127Z" }, ] +[[package]] +name = "backrefs" +version = "6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/e3/bb3a439d5cb255c4774724810ad8073830fac9c9dee123555820c1bcc806/backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231", size = 7011962, upload-time = "2025-11-15T14:52:08.323Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ee/c216d52f58ea75b5e1841022bbae24438b19834a29b163cb32aa3a2a7c6e/backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1", size = 381059, upload-time = "2025-11-15T14:51:59.758Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9a/8da246d988ded941da96c7ed945d63e94a445637eaad985a0ed88787cb89/backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7", size = 392854, upload-time = "2025-11-15T14:52:01.194Z" }, + { url = "https://files.pythonhosted.org/packages/37/c9/fd117a6f9300c62bbc33bc337fd2b3c6bfe28b6e9701de336b52d7a797ad/backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a", size = 398770, upload-time = "2025-11-15T14:52:02.584Z" }, + { url = "https://files.pythonhosted.org/packages/eb/95/7118e935b0b0bd3f94dfec2d852fd4e4f4f9757bdb49850519acd245cd3a/backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05", size = 400726, upload-time = "2025-11-15T14:52:04.093Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/6296bad135bfafd3254ae3648cd152980a424bd6fed64a101af00cc7ba31/backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853", size = 412584, upload-time = "2025-11-15T14:52:05.233Z" }, + { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" }, +] + [[package]] name = "certifi" version = "2025.11.12" @@ -138,6 +161,63 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, ] +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + [[package]] name = "click" version = "8.3.1" @@ -288,7 +368,7 @@ wheels = [ [[package]] name = "fastapi" -version = "0.124.0" +version = "0.124.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-doc" }, @@ -296,9 +376,9 @@ dependencies = [ { name = "starlette" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/48/9c/11969bd3e3bc4aa3a711f83dd3720239d3565a934929c74fc32f6c9f3638/fastapi-0.124.0.tar.gz", hash = "sha256:260cd178ad75e6d259991f2fd9b0fee924b224850079df576a3ba604ce58f4e6", size = 357623, upload-time = "2025-12-06T13:11:35.692Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/21/ade3ff6745a82ea8ad88552b4139d27941549e4f19125879f848ac8f3c3d/fastapi-0.124.4.tar.gz", hash = "sha256:0e9422e8d6b797515f33f500309f6e1c98ee4e85563ba0f2debb282df6343763", size = 378460, upload-time = "2025-12-12T15:00:43.891Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/29/9e1e82e16e9a1763d3b55bfbe9b2fa39d7175a1fd97685c482fa402e111d/fastapi-0.124.0-py3-none-any.whl", hash = "sha256:91596bdc6dde303c318f06e8d2bc75eafb341fc793a0c9c92c0bc1db1ac52480", size = 112505, upload-time = "2025-12-06T13:11:34.392Z" }, + { url = "https://files.pythonhosted.org/packages/3e/57/aa70121b5008f44031be645a61a7c4abc24e0e888ad3fc8fda916f4d188e/fastapi-0.124.4-py3-none-any.whl", hash = "sha256:6d1e703698443ccb89e50abe4893f3c84d9d6689c0cf1ca4fad6d3c15cf69f15", size = 113281, upload-time = "2025-12-12T15:00:42.44Z" }, ] [[package]] @@ -310,6 +390,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, ] +[[package]] +name = "ghp-import" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" }, +] + [[package]] name = "h11" version = "0.16.0" @@ -462,6 +554,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, ] +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + [[package]] name = "keyring" version = "25.7.0" @@ -531,6 +635,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/de/0c/6605b6199de8178afe7efc77ca1d8e6db00453bc1d3349d27605c0f42104/librt-0.7.3-cp314-cp314t-win_arm64.whl", hash = "sha256:a9f9b661f82693eb56beb0605156c7fca57f535704ab91837405913417d6990b", size = 45647, upload-time = "2025-12-06T19:04:31.302Z" }, ] +[[package]] +name = "markdown" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/7dd27d9d863b3376fcf23a5a13cb5d024aed1db46f963f1b5735ae43b3be/markdown-3.10.tar.gz", hash = "sha256:37062d4f2aa4b2b6b32aefb80faa300f82cc790cb949a35b8caede34f2b68c0e", size = 364931, upload-time = "2025-11-03T19:51:15.007Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/81/54e3ce63502cd085a0c556652a4e1b919c45a446bd1e5300e10c44c8c521/markdown-3.10-py3-none-any.whl", hash = "sha256:b5b99d6951e2e4948d939255596523444c0e677c669700b1d17aa4a8a464cb7c", size = 107678, upload-time = "2025-11-03T19:51:13.887Z" }, +] + [[package]] name = "markdown-it-py" version = "4.0.0" @@ -543,6 +656,69 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, ] +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + [[package]] name = "mdurl" version = "0.1.2" @@ -552,6 +728,84 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, ] +[[package]] +name = "mergedeep" +version = "1.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" }, +] + +[[package]] +name = "mkdocs" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ghp-import" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "markupsafe" }, + { name = "mergedeep" }, + { name = "mkdocs-get-deps" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "pyyaml" }, + { name = "pyyaml-env-tag" }, + { name = "watchdog" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" }, +] + +[[package]] +name = "mkdocs-get-deps" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mergedeep" }, + { name = "platformdirs" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239, upload-time = "2023-11-20T17:51:09.981Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521, upload-time = "2023-11-20T17:51:08.587Z" }, +] + +[[package]] +name = "mkdocs-material" +version = "9.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "backrefs" }, + { name = "colorama" }, + { name = "jinja2" }, + { name = "markdown" }, + { name = "mkdocs" }, + { name = "mkdocs-material-extensions" }, + { name = "paginate" }, + { name = "pygments" }, + { name = "pymdown-extensions" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/3b/111b84cd6ff28d9e955b5f799ef217a17bc1684ac346af333e6100e413cb/mkdocs_material-9.7.0.tar.gz", hash = "sha256:602b359844e906ee402b7ed9640340cf8a474420d02d8891451733b6b02314ec", size = 4094546, upload-time = "2025-11-11T08:49:09.73Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/87/eefe8d5e764f4cf50ed91b943f8e8f96b5efd65489d8303b7a36e2e79834/mkdocs_material-9.7.0-py3-none-any.whl", hash = "sha256:da2866ea53601125ff5baa8aa06404c6e07af3c5ce3d5de95e3b52b80b442887", size = 9283770, upload-time = "2025-11-11T08:49:06.26Z" }, +] + +[[package]] +name = "mkdocs-material-extensions" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" }, +] + [[package]] name = "more-itertools" version = "10.8.0" @@ -621,6 +875,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, ] +[[package]] +name = "paginate" +version = "0.5.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" }, +] + [[package]] name = "pathspec" version = "0.12.1" @@ -787,6 +1050,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] +[[package]] +name = "pymdown-extensions" +version = "10.19" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/4e/e73e88f4f2d0b26cbd2e100074107470984f0a6055869805fc181b847ac7/pymdown_extensions-10.19.tar.gz", hash = "sha256:01bb917ea231f9ce14456fa9092cdb95ac3e5bd32202a3ee61dbd5ad2dd9ef9b", size = 847701, upload-time = "2025-12-11T18:20:46.093Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/56/fa9edaceb3805e03ac9faf68ca1ddc660a75b49aee5accb493511005fef5/pymdown_extensions-10.19-py3-none-any.whl", hash = "sha256:dc5f249fc3a1b6d8a6de4634ba8336b88d0942cee75e92b18ac79eaf3503bf7c", size = 266670, upload-time = "2025-12-11T18:20:44.736Z" }, +] + [[package]] name = "pyproject-hooks" version = "1.2.0" @@ -852,6 +1128,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" }, ] +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + [[package]] name = "python-dotenv" version = "1.2.1" @@ -886,10 +1174,10 @@ dev = [ { name = "pyright" }, { name = "ruff" }, ] -doc = [ - { name = "fastapi" }, +docs = [ + { name = "mkdocs" }, + { name = "mkdocs-material" }, { name = "pydantic-settings" }, - { name = "typer" }, { name = "uvloop" }, ] test = [ @@ -920,10 +1208,10 @@ dev = [ { name = "pyright" }, { name = "ruff" }, ] -doc = [ - { name = "fastapi" }, +docs = [ + { name = "mkdocs" }, + { name = "mkdocs-material" }, { name = "pydantic-settings" }, - { name = "typer" }, { name = "uvloop" }, ] test = [ @@ -944,6 +1232,79 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, ] +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyyaml-env-tag" +version = "1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + [[package]] name = "rich" version = "14.2.0" @@ -959,28 +1320,28 @@ wheels = [ [[package]] name = "ruff" -version = "0.14.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload-time = "2025-12-04T15:06:17.669Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload-time = "2025-12-04T15:06:14.896Z" }, - { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload-time = "2025-12-04T15:06:51.809Z" }, - { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload-time = "2025-12-04T15:06:08.925Z" }, - { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload-time = "2025-12-04T15:06:23.498Z" }, - { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload-time = "2025-12-04T15:06:33.432Z" }, - { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload-time = "2025-12-04T15:06:02.687Z" }, - { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload-time = "2025-12-04T15:06:29.828Z" }, - { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload-time = "2025-12-04T15:06:36.812Z" }, - { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload-time = "2025-12-04T15:06:39.979Z" }, - { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload-time = "2025-12-04T15:06:46.372Z" }, - { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload-time = "2025-12-04T15:06:20.497Z" }, - { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload-time = "2025-12-04T15:06:49.06Z" }, - { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload-time = "2025-12-04T15:06:54.574Z" }, - { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload-time = "2025-12-04T15:05:59.209Z" }, - { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload-time = "2025-12-04T15:06:06.027Z" }, - { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload-time = "2025-12-04T15:06:11.668Z" }, - { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload-time = "2025-12-04T15:06:26.409Z" }, - { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload-time = "2025-12-04T15:06:43.212Z" }, +version = "0.14.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/1b/ab712a9d5044435be8e9a2beb17cbfa4c241aa9b5e4413febac2a8b79ef2/ruff-0.14.9.tar.gz", hash = "sha256:35f85b25dd586381c0cc053f48826109384c81c00ad7ef1bd977bfcc28119d5b", size = 5809165, upload-time = "2025-12-11T21:39:47.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/1c/d1b1bba22cffec02351c78ab9ed4f7d7391876e12720298448b29b7229c1/ruff-0.14.9-py3-none-linux_armv6l.whl", hash = "sha256:f1ec5de1ce150ca6e43691f4a9ef5c04574ad9ca35c8b3b0e18877314aba7e75", size = 13576541, upload-time = "2025-12-11T21:39:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/94/ab/ffe580e6ea1fca67f6337b0af59fc7e683344a43642d2d55d251ff83ceae/ruff-0.14.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ed9d7417a299fc6030b4f26333bf1117ed82a61ea91238558c0268c14e00d0c2", size = 13779363, upload-time = "2025-12-11T21:39:20.29Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f8/2be49047f929d6965401855461e697ab185e1a6a683d914c5c19c7962d9e/ruff-0.14.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d5dc3473c3f0e4a1008d0ef1d75cee24a48e254c8bed3a7afdd2b4392657ed2c", size = 12925292, upload-time = "2025-12-11T21:39:38.757Z" }, + { url = "https://files.pythonhosted.org/packages/9e/e9/08840ff5127916bb989c86f18924fd568938b06f58b60e206176f327c0fe/ruff-0.14.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:84bf7c698fc8f3cb8278830fb6b5a47f9bcc1ed8cb4f689b9dd02698fa840697", size = 13362894, upload-time = "2025-12-11T21:39:02.524Z" }, + { url = "https://files.pythonhosted.org/packages/31/1c/5b4e8e7750613ef43390bb58658eaf1d862c0cc3352d139cd718a2cea164/ruff-0.14.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aa733093d1f9d88a5d98988d8834ef5d6f9828d03743bf5e338bf980a19fce27", size = 13311482, upload-time = "2025-12-11T21:39:17.51Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3a/459dce7a8cb35ba1ea3e9c88f19077667a7977234f3b5ab197fad240b404/ruff-0.14.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a1cfb04eda979b20c8c19550c8b5f498df64ff8da151283311ce3199e8b3648", size = 14016100, upload-time = "2025-12-11T21:39:41.948Z" }, + { url = "https://files.pythonhosted.org/packages/a6/31/f064f4ec32524f9956a0890fc6a944e5cf06c63c554e39957d208c0ffc45/ruff-0.14.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1e5cb521e5ccf0008bd74d5595a4580313844a42b9103b7388eca5a12c970743", size = 15477729, upload-time = "2025-12-11T21:39:23.279Z" }, + { url = "https://files.pythonhosted.org/packages/7a/6d/f364252aad36ccd443494bc5f02e41bf677f964b58902a17c0b16c53d890/ruff-0.14.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd429a8926be6bba4befa8cdcf3f4dd2591c413ea5066b1e99155ed245ae42bb", size = 15122386, upload-time = "2025-12-11T21:39:33.125Z" }, + { url = "https://files.pythonhosted.org/packages/20/02/e848787912d16209aba2799a4d5a1775660b6a3d0ab3944a4ccc13e64a02/ruff-0.14.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab208c1b7a492e37caeaf290b1378148f75e13c2225af5d44628b95fd7834273", size = 14497124, upload-time = "2025-12-11T21:38:59.33Z" }, + { url = "https://files.pythonhosted.org/packages/f3/51/0489a6a5595b7760b5dbac0dd82852b510326e7d88d51dbffcd2e07e3ff3/ruff-0.14.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72034534e5b11e8a593f517b2f2f2b273eb68a30978c6a2d40473ad0aaa4cb4a", size = 14195343, upload-time = "2025-12-11T21:39:44.866Z" }, + { url = "https://files.pythonhosted.org/packages/f6/53/3bb8d2fa73e4c2f80acc65213ee0830fa0c49c6479313f7a68a00f39e208/ruff-0.14.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:712ff04f44663f1b90a1195f51525836e3413c8a773574a7b7775554269c30ed", size = 14346425, upload-time = "2025-12-11T21:39:05.927Z" }, + { url = "https://files.pythonhosted.org/packages/ad/04/bdb1d0ab876372da3e983896481760867fc84f969c5c09d428e8f01b557f/ruff-0.14.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a111fee1db6f1d5d5810245295527cda1d367c5aa8f42e0fca9a78ede9b4498b", size = 13258768, upload-time = "2025-12-11T21:39:08.691Z" }, + { url = "https://files.pythonhosted.org/packages/40/d9/8bf8e1e41a311afd2abc8ad12be1b6c6c8b925506d9069b67bb5e9a04af3/ruff-0.14.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8769efc71558fecc25eb295ddec7d1030d41a51e9dcf127cbd63ec517f22d567", size = 13326939, upload-time = "2025-12-11T21:39:53.842Z" }, + { url = "https://files.pythonhosted.org/packages/f4/56/a213fa9edb6dd849f1cfbc236206ead10913693c72a67fb7ddc1833bf95d/ruff-0.14.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:347e3bf16197e8a2de17940cd75fd6491e25c0aa7edf7d61aa03f146a1aa885a", size = 13578888, upload-time = "2025-12-11T21:39:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/33/09/6a4a67ffa4abae6bf44c972a4521337ffce9cbc7808faadede754ef7a79c/ruff-0.14.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:7715d14e5bccf5b660f54516558aa94781d3eb0838f8e706fb60e3ff6eff03a8", size = 14314473, upload-time = "2025-12-11T21:39:50.78Z" }, + { url = "https://files.pythonhosted.org/packages/12/0d/15cc82da5d83f27a3c6b04f3a232d61bc8c50d38a6cd8da79228e5f8b8d6/ruff-0.14.9-py3-none-win32.whl", hash = "sha256:df0937f30aaabe83da172adaf8937003ff28172f59ca9f17883b4213783df197", size = 13202651, upload-time = "2025-12-11T21:39:26.628Z" }, + { url = "https://files.pythonhosted.org/packages/32/f7/c78b060388eefe0304d9d42e68fab8cffd049128ec466456cef9b8d4f06f/ruff-0.14.9-py3-none-win_amd64.whl", hash = "sha256:c0b53a10e61df15a42ed711ec0bda0c582039cf6c754c49c020084c55b5b0bc2", size = 14702079, upload-time = "2025-12-11T21:39:11.954Z" }, + { url = "https://files.pythonhosted.org/packages/26/09/7a9520315decd2334afa65ed258fed438f070e31f05a2e43dd480a5e5911/ruff-0.14.9-py3-none-win_arm64.whl", hash = "sha256:8e821c366517a074046d92f0e9213ed1c13dbc5b37a7fc20b07f79b64d62cc84", size = 13744730, upload-time = "2025-12-11T21:39:29.659Z" }, ] [[package]] @@ -1005,6 +1366,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, ] +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + [[package]] name = "starlette" version = "0.50.0" @@ -1108,6 +1478,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, ] +[[package]] +name = "urllib3" +version = "2.6.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/24/a2a2ed9addd907787d7aa0355ba36a6cadf1768b934c652ea78acbd59dcd/urllib3-2.6.2.tar.gz", hash = "sha256:016f9c98bb7e98085cb2b4b17b87d2c702975664e4f060c6532e64d1c1a5e797", size = 432930, upload-time = "2025-12-11T15:56:40.252Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/b9/4095b668ea3678bf6a0af005527f39de12fb026516fb3df17495a733b7f8/urllib3-2.6.2-py3-none-any.whl", hash = "sha256:ec21cddfe7724fc7cb4ba4bea7aa8e2ef36f607a4bab81aa6ce42a13dc3f03dd", size = 131182, upload-time = "2025-12-11T15:56:38.584Z" }, +] + [[package]] name = "userpath" version = "1.9.2" @@ -1191,3 +1570,27 @@ sdist = { url = "https://files.pythonhosted.org/packages/20/28/e6f1a6f655d620846 wheels = [ { url = "https://files.pythonhosted.org/packages/79/0c/c05523fa3181fdf0c9c52a6ba91a23fbf3246cc095f26f6516f9c60e6771/virtualenv-20.35.4-py3-none-any.whl", hash = "sha256:c21c9cede36c9753eeade68ba7d523529f228a403463376cf821eaae2b650f1b", size = 6005095, upload-time = "2025-10-29T06:57:37.598Z" }, ] + +[[package]] +name = "watchdog" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" }, + { url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" }, + { url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" }, + { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" }, + { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" }, + { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" }, + { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" }, + { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" }, + { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" }, + { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" }, + { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" }, + { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" }, +]