engin 0.0.17__py3-none-any.whl → 0.0.19__py3-none-any.whl

engin/__init__.py

@@ -1,9 +1,7 @@
-from engin import ext
 from engin._assembler import Assembler
 from engin._block import Block, invoke, provide
 from engin._dependency import Entrypoint, Invoke, Provide, Supply
 from engin._engin import Engin
-from engin._exceptions import ProviderError
 from engin._lifecycle import Lifecycle
 from engin._option import Option
 from engin._type_utils import TypeId
@@ -17,10 +15,8 @@ __all__ = [
     "Lifecycle",
     "Option",
     "Provide",
-    "ProviderError",
     "Supply",
     "TypeId",
-    "ext",
     "invoke",
     "provide",
 ]

engin/_assembler.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from collections import defaultdict
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from contextvars import ContextVar
 from dataclasses import dataclass
 from inspect import BoundArguments, Signature
@@ -9,8 +9,8 @@ from types import TracebackType
 from typing import Any, Generic, TypeVar, cast
 
 from engin._dependency import Dependency, Provide, Supply
-from engin._exceptions import NotInScopeError, ProviderError
 from engin._type_utils import TypeId
+from engin.exceptions import NotInScopeError, ProviderError
 
 LOG = logging.getLogger("engin")
 
@@ -65,6 +65,7 @@ class Assembler:
         self._multiproviders: dict[TypeId, list[Provide[list[Any]]]] = defaultdict(list)
         self._assembled_outputs: dict[TypeId, Any] = {}
         self._lock = asyncio.Lock()
+        self._graph_cache: dict[TypeId, set[Provide]] = defaultdict(set)
 
         for provider in providers:
             type_id = provider.return_type_id
@@ -75,6 +76,11 @@ class Assembler:
             else:
                 self._multiproviders[type_id].append(provider)
 
+    @property
+    def providers(self) -> Sequence[Provide[Any]]:
+        multi_providers = [p for multi in self._multiproviders.values() for p in multi]
+        return [*self._providers.values(), *multi_providers]
+
     async def assemble(self, dependency: Dependency[Any, T]) -> AssembledDependency[T]:
         """
         Assemble a dependency.
@@ -174,8 +180,8 @@ class Assembler:
         """
         Add a provider to the Assembler post-initialisation.
 
-        If this replaces an existing provider, this will clear any previously assembled
-        output for the existing Provider.
+        If this replaces an existing provider, this will clear all previously assembled
+        output. Note: multiproviders cannot be replaced, they are always appended.
 
         Args:
             provider: the Provide instance to add.
@@ -185,14 +191,13 @@ class Assembler:
         """
         type_id = provider.return_type_id
         if provider.is_multiprovider:
-            if type_id in self._assembled_outputs:
-                del self._assembled_outputs[type_id]
             self._multiproviders[type_id].append(provider)
         else:
-            if type_id in self._assembled_outputs:
-                del self._assembled_outputs[type_id]
             self._providers[type_id] = provider
 
+        self._assembled_outputs.clear()
+        self._graph_cache.clear()
+
     def scope(self, scope: str) -> "_ScopeContextManager":
         return _ScopeContextManager(scope=scope, assembler=self)
 
@@ -201,13 +206,14 @@ class Assembler:
             if provider.scope == scope:
                 self._assembled_outputs.pop(type_id, None)
 
-    def _resolve_providers(self, type_id: TypeId) -> Iterable[Provide]:
+    def _resolve_providers(self, type_id: TypeId, resolved: set[TypeId]) -> set[Provide]:
         """
         Resolves the chain of providers required to satisfy the provider of a given type.
         Ordering of the return value is very important!
-
-        # TODO: performance optimisation, do not recurse for already satisfied providers?
         """
+        if type_id in self._graph_cache:
+            return self._graph_cache[type_id]
+
         if type_id.multi:
             root_providers = self._multiproviders.get(type_id)
         else:
@@ -225,22 +231,28 @@ class Assembler:
                 raise LookupError(msg)
 
         # providers that must be satisfied to satisfy the root level providers
-        yield from (
+        resolved_providers = {
             child_provider
             for root_provider in root_providers
             for root_provider_param in root_provider.parameter_type_ids
-            for child_provider in self._resolve_providers(root_provider_param)
-        )
-        yield from root_providers
+            for child_provider in self._resolve_providers(root_provider_param, resolved)
+            if root_provider_param not in resolved
+        } | set(root_providers)
+
+        resolved.add(type_id)
+        self._graph_cache[type_id] = resolved_providers
+
+        return resolved_providers
 
     async def _satisfy(self, target: TypeId) -> None:
-        for provider in self._resolve_providers(target):
+        for provider in self._resolve_providers(target, set()):
             if (
                 not provider.is_multiprovider
                 and provider.return_type_id in self._assembled_outputs
             ):
                 continue
             type_id = provider.return_type_id
+
             bound_args = await self._bind_arguments(provider.signature)
             try:
                 value = await provider(*bound_args.args, **bound_args.kwargs)
@@ -248,6 +260,7 @@ class Assembler:
                 raise ProviderError(
                     provider=provider, error_type=type(err), error_message=str(err)
                 ) from err
+
             if provider.is_multiprovider:
                 if type_id in self._assembled_outputs:
                     self._assembled_outputs[type_id].extend(value)
@@ -264,8 +277,7 @@ class Assembler:
                 args.append(object())
                 continue
             param_key = TypeId.from_type(param.annotation)
-            has_dependency = param_key in self._assembled_outputs
-            if not has_dependency:
+            if param_key not in self._assembled_outputs:
                 await self._satisfy(param_key)
             val = self._assembled_outputs[param_key]
             if param.kind == param.POSITIONAL_ONLY:

engin/_block.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, ClassVar
 
 from engin._dependency import Dependency, Func, Invoke, Provide
 from engin._option import Option
+from engin.exceptions import InvalidBlockError
 
 if TYPE_CHECKING:
     from engin._engin import Engin
@@ -42,7 +43,7 @@ def invoke(func_: Func | None = None) -> Func | Callable[[Func], Func]:
         return _inner(func_)
 
 
-class Block(Option):
+class Block:
     """
     A Block is a collection of providers and invocations.
 
@@ -74,7 +75,7 @@ class Block(Option):
 
     @classmethod
     def apply(cls, engin: "Engin") -> None:
-        block_name = cls.name or f"{cls.__name__}"
+        block_name = cls.name or cls.__name__
         for option in chain(cls.options, cls._method_options()):
             if isinstance(option, Dependency):
                 option._block_name = block_name
@@ -82,8 +83,19 @@ class Block(Option):
 
     @classmethod
     def _method_options(cls) -> Iterable[Provide | Invoke]:
-        for _, method in inspect.getmembers(cls):
+        for name, method in inspect.getmembers(cls, inspect.isfunction):
             if option := getattr(method, "_opt", None):
                 if not isinstance(option, Provide | Invoke):
-                    raise RuntimeError("Block option is not an instance of Provide or Invoke")
+                    raise InvalidBlockError(
+                        block=cls,
+                        reason="Block option is not an instance of Provide or Invoke",
+                    )
                 yield option
+            else:
+                raise InvalidBlockError(
+                    block=cls,
+                    reason=(
+                        f"Method '{name}' is not a Provider or Invocation, did you "
+                        "forget to decorate it?"
+                    ),
+                )

engin/_cli/__init__.py

@@ -1,3 +1,6 @@
+import logging
+import sys
+
 try:
     import typer
 except ImportError:
@@ -7,7 +10,15 @@ except ImportError:
     ) from None
 
 from engin._cli._graph import cli as graph_cli
+from engin._cli._inspect import cli as inspect_cli
+
+# mute logging from importing of files + engin's debug logging.
+logging.disable()
+
+# add cwd to path to enable local package imports
+sys.path.insert(0, "")
 
 app = typer.Typer()
 
 app.add_typer(graph_cli)
+app.add_typer(inspect_cli)

engin/_cli/_common.py

@@ -0,0 +1,51 @@
+import importlib
+from typing import Never
+
+import typer
+from rich import print
+from rich.panel import Panel
+
+from engin import Engin
+
+
+def print_error(msg: str) -> Never:
+    print(
+        Panel(
+            title="Error",
+            renderable=msg,
+            title_align="left",
+            border_style="red",
+            highlight=True,
+        )
+    )
+    raise typer.Exit(code=1)
+
+
+COMMON_HELP = {
+    "app": (
+        "The import path of your Engin instance, in the form 'package:application'"
+        ", e.g. 'app.main:engin'"
+    )
+}
+
+
+def get_engin_instance(app: str) -> tuple[str, str, Engin]:
+    try:
+        module_name, engin_name = app.split(":", maxsplit=1)
+    except ValueError:
+        print_error("Expected an argument of the form 'module:attribute', e.g. 'myapp:engin'")
+
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError:
+        print_error(f"Unable to find module '{module_name}'")
+
+    try:
+        instance = getattr(module, engin_name)
+    except AttributeError:
+        print_error(f"Module '{module_name}' has no attribute '{engin_name}'")
+
+    if not isinstance(instance, Engin):
+        print_error(f"'{app}' is not an Engin instance")
+
+    return module_name, engin_name, instance

engin/_cli/_graph.py

@@ -1,8 +1,5 @@
 import contextlib
-import importlib
-import logging
 import socketserver
-import sys
 import threading
 from http.server import BaseHTTPRequestHandler
 from pathlib import Path
@@ -12,65 +9,37 @@ from typing import Annotated, Any
 import typer
 from rich import print
 
-from engin import Engin, Entrypoint, Invoke, TypeId
-from engin._cli._utils import print_error
+from engin import Entrypoint, Invoke, TypeId
+from engin._cli._common import COMMON_HELP, get_engin_instance
 from engin._dependency import Dependency, Provide, Supply
-from engin.ext.asgi import ASGIEngin
+from engin.extensions.asgi import ASGIEngin
 
 try:
-    from engin.ext.fastapi import APIRouteDependency
+    from engin.extensions.fastapi import APIRouteDependency
 except ImportError:
     APIRouteDependency = None  # type: ignore[assignment,misc]
 
 cli = typer.Typer()
 
-# mute logging from importing of files + engin's debug logging.
-logging.disable()
 
 _APP_ORIGIN = ""
 
-_CLI_HELP = {
-    "app": (
-        "The import path of your Engin instance, in the form 'package:application'"
-        ", e.g. 'app.main:engin'"
-    )
-}
-
 
 @cli.command(name="graph")
 def serve_graph(
     app: Annotated[
         str,
-        typer.Argument(help=_CLI_HELP["app"]),
+        typer.Argument(help=COMMON_HELP["app"]),
     ],
 ) -> None:
     """
     Creates a visualisation of your application's dependencies.
     """
-    # add cwd to path to enable local package imports
-    sys.path.insert(0, "")
-
-    try:
-        module_name, engin_name = app.split(":", maxsplit=1)
-    except ValueError:
-        print_error("Expected an argument of the form 'module:attribute', e.g. 'myapp:engin'")
+    module_name, _, instance = get_engin_instance(app)
 
     global _APP_ORIGIN
     _APP_ORIGIN = module_name.split(".", maxsplit=1)[0]
 
-    try:
-        module = importlib.import_module(module_name)
-    except ModuleNotFoundError:
-        print_error(f"unable to find module '{module_name}'")
-
-    try:
-        instance = getattr(module, engin_name)
-    except AttributeError:
-        print_error(f"module '{module_name}' has no attribute '{engin_name}'")
-
-    if not isinstance(instance, Engin):
-        print_error(f"'{app}' is not an Engin instance")
-
     nodes = instance.graph()
 
     # transform dependencies into mermaid syntax

engin/_cli/_inspect.py

@@ -0,0 +1,94 @@
+from typing import Annotated
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from engin import Supply
+from engin._cli._common import COMMON_HELP, get_engin_instance, print_error
+
+cli = typer.Typer()
+_CLI_HELP = {
+    "type": "Filter providers by the provided type, e.g. `AsyncClient` or `float[]`",
+    "module": "Filter providers by the provided types' module, e.g. `engin` or `httpx`",
+    "verbose": "Enables verbose output",
+}
+
+
+@cli.command(name="inspect")
+def serve_graph(
+    app: Annotated[
+        str,
+        typer.Argument(help=COMMON_HELP["app"]),
+    ],
+    type_: Annotated[
+        str | None,
+        typer.Option("--type", help=_CLI_HELP["type"]),
+    ] = None,
+    module: Annotated[
+        str | None,
+        typer.Option(help=_CLI_HELP["module"]),
+    ] = None,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-v", help=_CLI_HELP["verbose"])
+    ] = False,
+) -> None:
+    """
+    Shows metadata for all matching providers.
+
+    Examples:
+
+        1. `engin inspect examples.simple.main:engin --module httpx`
+
+        2. `engin inspect examples.simple.main:engin --type AsyncClient`
+    """
+    module_name, _, instance = get_engin_instance(app)
+
+    console = Console()
+
+    providers = []
+    for provider in instance.assembler.providers:
+        type_id = provider.return_type_id
+        if type_ is not None:
+            type_name = str(type_id).rsplit(".", maxsplit=1)[-1]
+            if type_ != type_name:
+                if verbose:
+                    console.print(
+                        f"Ignoring '{provider.return_type_id}' as `{type_} != {type_name}",
+                        style="dim",
+                    )
+                continue
+        if module is not None:
+            module_name = str(type_id).split(".", maxsplit=1)[0]
+            if module != module_name:
+                if verbose:
+                    console.print(
+                        f"Ignoring '{provider.return_type_id}' as `{module} != {module_name}",
+                        style="dim",
+                    )
+                continue
+        providers.append(provider)
+
+    matching_provider_count = len(providers)
+    if matching_provider_count == 0:
+        available = sorted(map(str, instance.assembler.providers))
+        print_error(f"No matching providers, available: {available}")
+
+    if matching_provider_count > 1:
+        console.print(f"Found {matching_provider_count} matching providers", style="dim")
+
+    table = Table(show_header=False, show_lines=False, box=box.ASCII)
+
+    for provider in sorted(providers, key=lambda p: p.source_module):
+        is_supply = isinstance(provider, Supply)
+
+        table.add_row("name", str(provider), style="bold", end_section=True)
+        table.add_row("scope", provider.scope or "N/A")
+        table.add_row("func", provider.func_name if not is_supply else "N/A")
+        table.add_row("block", provider.block_name or "N/A")
+        table.add_row("source module", provider.source_module or "N/A")
+        table.add_row("source package", provider.source_package or "N/A")
+        table.add_section()
+
+    console.print(table)

engin/_dependency.py

@@ -175,47 +175,37 @@ class Provide(Dependency[Any, T]):
         self._scope = scope
         self._override = override
         self._explicit_type = as_type
+        self._return_type = self._resolve_return_type()
+        self._return_type_id = TypeId.from_type(self._return_type)
 
         if self._explicit_type is not None:
             self._signature = self._signature.replace(return_annotation=self._explicit_type)
 
-        self._is_multi = typing.get_origin(self.return_type) is list
+        self._is_multi = typing.get_origin(self._return_type) is list
 
         # Validate that the provider does to depend on its own output value, as this will
         # cause a recursion error and is undefined behaviour wise.
         if any(
-            self.return_type == param.annotation
+            self._return_type == param.annotation
             for param in self._signature.parameters.values()
         ):
             raise ValueError("A provider cannot depend on its own return type")
 
         # Validate that multiproviders only return a list of one type.
         if self._is_multi:
-            args = typing.get_args(self.return_type)
+            args = typing.get_args(self._return_type)
             if len(args) != 1:
                 raise ValueError(
-                    f"A multiprovider must be of the form list[X], not '{self.return_type}'"
+                    f"A multiprovider must be of the form list[X], not '{self._return_type}'"
                 )
 
     @property
     def return_type(self) -> type[T]:
-        if self._explicit_type is not None:
-            return self._explicit_type
-        if isclass(self._func):
-            return_type = self._func  # __init__ returns self
-        else:
-            try:
-                return_type = get_type_hints(self._func, include_extras=True)["return"]
-            except KeyError as err:
-                raise RuntimeError(
-                    f"Dependency '{self.name}' requires a return typehint"
-                ) from err
-
-        return return_type
+        return self._return_type
 
     @property
     def return_type_id(self) -> TypeId:
-        return TypeId.from_type(self.return_type)
+        return self._return_type_id
 
     @property
     def is_multiprovider(self) -> bool:
@@ -255,6 +245,21 @@ class Provide(Dependency[Any, T]):
     def __str__(self) -> str:
         return f"Provide({self.return_type_id})"
 
+    def _resolve_return_type(self) -> type[T]:
+        if self._explicit_type is not None:
+            return self._explicit_type
+        if isclass(self._func):
+            return_type = self._func  # __init__ returns self
+        else:
+            try:
+                return_type = get_type_hints(self._func, include_extras=True)["return"]
+            except KeyError as err:
+                raise RuntimeError(
+                    f"Dependency '{self.name}' requires a return typehint"
+                ) from err
+
+        return return_type
+
 
 class Supply(Provide, Generic[T]):
     def __init__(
@@ -276,8 +281,7 @@ class Supply(Provide, Generic[T]):
         self._value = value
         super().__init__(builder=self._get_val, as_type=as_type, override=override)
 
-    @property
-    def return_type(self) -> type[T]:
+    def _resolve_return_type(self) -> type[T]:
         if self._explicit_type is not None:
             return self._explicit_type
         if isinstance(self._value, list):

engin/{_exceptions.py → exceptions.py}

@@ -1,7 +1,10 @@
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from engin._dependency import Provide
 
+if TYPE_CHECKING:
+    from engin._block import Block
+
 
 class EnginError(Exception):
     """
@@ -15,6 +18,20 @@ class AssemblerError(EnginError):
     """
 
 
+class InvalidBlockError(EnginError):
+    """
+    Raised when an invalid block is instantiated.
+    """
+
+    def __init__(self, block: "type[Block]", reason: str) -> None:
+        self.block = block
+        self.block_name = block.name or block.__name__
+        self.message = f"block '{self.block_name}' is invalid, reason: '{reason}'"
+
+    def __str__(self) -> str:
+        return self.message
+
+
 class ProviderError(AssemblerError):
     """
     Raised when a Provider errors during Assembly.
@@ -52,3 +69,12 @@ class NotInScopeError(AssemblerError):
 
     def __str__(self) -> str:
         return self.message
+
+
+__all__ = [
+    "AssemblerError",
+    "EnginError",
+    "InvalidBlockError",
+    "NotInScopeError",
+    "ProviderError",
+]

engin/{ext → extensions}/fastapi.py

@@ -10,7 +10,7 @@ from engin import Assembler, Engin, Entrypoint, Invoke, Option
 from engin._dependency import Dependency, Supply, _noop
 from engin._graph import DependencyGrapher, Node
 from engin._type_utils import TypeId
-from engin.ext.asgi import ASGIEngin
+from engin.extensions.asgi import ASGIEngin
 
 try:
     from fastapi import APIRouter, FastAPI

{engin-0.0.17.dist-info → engin-0.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engin
-Version: 0.0.17
+Version: 0.0.19
 Summary: An async-first modular application framework
 Project-URL: Homepage, https://github.com/invokermain/engin
 Project-URL: Documentation, https://engin.readthedocs.io/en/latest/

engin-0.0.19.dist-info/RECORD

@@ -0,0 +1,25 @@
+engin/__init__.py,sha256=A8TE_ci7idoR683535YoBrWZbYTgXXS-q7Y2y51nZ5M,486
+engin/_assembler.py,sha256=-ENSrXPMWacionIYrTSQO7th9DDBOPyAT8ybPbBRtQw,11318
+engin/_block.py,sha256=IacP4PoJKRhSQCbQSdoyCtmu362a4vj6qoUQKyaJwzI,3062
+engin/_dependency.py,sha256=Nfq6L92LN4X53QpiMCIF3MjmWfuntYVOnZmmoPYYJEw,9165
+engin/_engin.py,sha256=yIpZdeqvm8hv0RxOV0veFuvyu9xQ054JSaeuUWwHdOQ,7380
+engin/_graph.py,sha256=y1g7Lm_Zy5GPEgRsggCKV5DDaDzcwUl8v3IZCK8jyGI,1631
+engin/_introspect.py,sha256=VdREX6Lhhga5SnEP9G7mjHkgJR4mpqk_SMnmL2zTcqY,966
+engin/_lifecycle.py,sha256=cSWe3euZkmpxmUPFvph2lsTtvuZbxttEfBL-RnOI7lo,5325
+engin/_option.py,sha256=nZcdrehp1QwgxMUoIpsM0PJuu1q1pbXzhcVsetbsHpc,223
+engin/_type_utils.py,sha256=Pmm4m1_WdevT5KTe8tzY_BseNxPyhu_nKsLGgyNcPpo,2247
+engin/exceptions.py,sha256=-VPwPReZb9YEIkrWMR9TW2K5HEwmHHgEO7QWH6wfV8c,1946
+engin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+engin/_cli/__init__.py,sha256=koD5WTkZXb8QQIiVU5bJiSR1wwPGb5rv2iwd-v-BA7A,564
+engin/_cli/_common.py,sha256=zMYb1Bs1yUuR3qf3r6WuVozYzDwHJvTVthVbTQfTF9w,1261
+engin/_cli/_graph.html,sha256=rR5dnDKoz7KtSff0ERCi2UKuoH_Z03MRYiXI_W03G5k,2430
+engin/_cli/_graph.py,sha256=HMC91nWvTOr6_czPBNx1RU55Ib3qesJRCmbnL2DsdDk,4659
+engin/_cli/_inspect.py,sha256=0jm25d4wcbXVNJkyaeECSKY-irsxd-EIYBH1GDW_Yjc,3163
+engin/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+engin/extensions/asgi.py,sha256=d5Z6gtMVWDZdAlvrTaMt987sKyiq__A0X4gJQ7IETmA,3247
+engin/extensions/fastapi.py,sha256=e8F4L_nZ9dU9j8mb9lXKwJG6CTu5aIk4N5faRj4EyUA,6369
+engin-0.0.19.dist-info/METADATA,sha256=Rb1VPxLjnzVxhnq8Llie5XRxpI0GANR-dK31BEcPAqg,2354
+engin-0.0.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+engin-0.0.19.dist-info/entry_points.txt,sha256=sW247zZUMxm0b5UKYvPuqQQljYDtU-j2zK3cu7gHwM0,41
+engin-0.0.19.dist-info/licenses/LICENSE,sha256=XHh5LPUPKZWTBqBv2xxN2RU7D59nHoiJGb5RIt8f45w,1070
+engin-0.0.19.dist-info/RECORD,,

engin/_cli/_utils.py

@@ -1,18 +0,0 @@
-from typing import Never
-
-import typer
-from rich import print
-from rich.panel import Panel
-
-
-def print_error(msg: str) -> Never:
-    print(
-        Panel(
-            title="Error",
-            renderable=msg.capitalize(),
-            title_align="left",
-            border_style="red",
-            highlight=True,
-        )
-    )
-    raise typer.Exit(code=1)

engin-0.0.17.dist-info/RECORD

@@ -1,24 +0,0 @@
-engin/__init__.py,sha256=rBTteMLAVKg4TJSaMElJUwz72BA_X7nBTREg-I-bWhA,584
-engin/_assembler.py,sha256=r2Vr9UO7pHYvj71087PIJYT9lFBNPni3x34MtjMHN7A,10952
-engin/_block.py,sha256=8ysWrmHkWpTm6bmSc6jZVoO0Ax5Svu1HwxpZwAtIF_o,2617
-engin/_dependency.py,sha256=5x4_0QvHtqv6R_brKHRc-INKE4oMh1JU8-9RCmulp4Q,8976
-engin/_engin.py,sha256=yIpZdeqvm8hv0RxOV0veFuvyu9xQ054JSaeuUWwHdOQ,7380
-engin/_exceptions.py,sha256=UzMppJWDk_Hx3qWAypcPVLw9OYCibqiZjLYeTl22zaE,1355
-engin/_graph.py,sha256=y1g7Lm_Zy5GPEgRsggCKV5DDaDzcwUl8v3IZCK8jyGI,1631
-engin/_introspect.py,sha256=VdREX6Lhhga5SnEP9G7mjHkgJR4mpqk_SMnmL2zTcqY,966
-engin/_lifecycle.py,sha256=cSWe3euZkmpxmUPFvph2lsTtvuZbxttEfBL-RnOI7lo,5325
-engin/_option.py,sha256=nZcdrehp1QwgxMUoIpsM0PJuu1q1pbXzhcVsetbsHpc,223
-engin/_type_utils.py,sha256=Pmm4m1_WdevT5KTe8tzY_BseNxPyhu_nKsLGgyNcPpo,2247
-engin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-engin/_cli/__init__.py,sha256=lp1KiBpcgk_dZU5V9DjgLPwmp0ja444fwLH2CYCscNc,302
-engin/_cli/_graph.html,sha256=rR5dnDKoz7KtSff0ERCi2UKuoH_Z03MRYiXI_W03G5k,2430
-engin/_cli/_graph.py,sha256=YZ0awBLtWD5W6xrHO9ueMnk_EIsYM4_j_bmquiLsb2Y,5542
-engin/_cli/_utils.py,sha256=AQFtLO8qjYRCTQc9A8Z1HVf7eZr8iGWogxbYzsgIkS4,360
-engin/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-engin/ext/asgi.py,sha256=d5Z6gtMVWDZdAlvrTaMt987sKyiq__A0X4gJQ7IETmA,3247
-engin/ext/fastapi.py,sha256=TGNf0LFLaTLMLlAycH7GgP_GcBld262v9xboGOwhvgE,6362
-engin-0.0.17.dist-info/METADATA,sha256=1SUQZwsFr3neO0WJ_gLLv90kgJCcBNUbwWWi2zZZ77Q,2354
-engin-0.0.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-engin-0.0.17.dist-info/entry_points.txt,sha256=sW247zZUMxm0b5UKYvPuqQQljYDtU-j2zK3cu7gHwM0,41
-engin-0.0.17.dist-info/licenses/LICENSE,sha256=XHh5LPUPKZWTBqBv2xxN2RU7D59nHoiJGb5RIt8f45w,1070
-engin-0.0.17.dist-info/RECORD,,