django-compose 0.1.0.dev1__py3-none-any.whl

django_compose/__main__.py

@@ -0,0 +1,5 @@
+"""Run the same public command through ``python -m django_compose``."""
+
+from django_compose.cli import main
+
+raise SystemExit(main())

django_compose/addons.py

@@ -0,0 +1,205 @@
+"""Resolve installed addon metadata into an ordered selection of native Django apps."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from graphlib import CycleError, TopologicalSorter
+from importlib import metadata
+from types import MappingProxyType
+
+from django.apps import AppConfig
+from django.core.exceptions import ImproperlyConfigured
+from packaging.requirements import Requirement
+from packaging.utils import canonicalize_name
+
+from django_compose.snapshot import Entry, app_entries
+
+
+@dataclass(frozen=True)
+class Closure:
+    """Native app entries and app-name membership for one resolved selection.
+
+    App_entries captures native config identities in dependency order; entries
+    projects their compatible INSTALLED_APPS strings. Roots preserve the
+    project's authored order; required contains only dependency-selected apps.
+    Addons contains only selected members of the requested entry-point group.
+    Dependencies maps selected native app names to their direct dependencies,
+    also native app names, independent of the selected config entry strings.
+    App_configs retains the same selected native instances for app-owned behavior;
+    app_entries freezes their identity facts for composition inputs.
+    """
+
+    app_entries: tuple[Entry, ...]
+    roots: tuple[str, ...]
+    required: frozenset[str]
+    addons: frozenset[str]
+    dependencies: Mapping[str, tuple[str, ...]]
+    app_configs: tuple[AppConfig, ...] = field(compare=False, repr=False)
+
+    @property
+    def entries(self) -> tuple[str, ...]:
+        """Native INSTALLED_APPS strings, projected from canonical app identities."""
+        return tuple(entry.entry for entry in self.app_entries)
+
+
+@dataclass(frozen=True)
+class InstalledAddons:
+    """Read-only native metadata, indexed without importing apps or loading points.
+
+    Distributions and entry_points use canonical distribution names as keys.
+    Providers maps declared app keys to distribution names. Actual AppConfig
+    identity is checked only when enabled_apps activates the declaration. The
+    index containers are immutable; their values retain native metadata APIs.
+    """
+
+    distributions: Mapping[str, metadata.Distribution]
+    entry_points: Mapping[str, metadata.EntryPoint]
+    providers: Mapping[str, str]
+
+    def active_requirements(self, provider: str) -> tuple[Requirement, ...]:
+        """Return sorted native requirements active on this platform with extra=''.
+
+        Requested extras never activate optional requirements. Missing installed
+        dependencies are checked during activation, keeping disabled metadata inert.
+        """
+        return active_requirements(self.distributions[provider].requires or ())
+
+
+def active_requirements(requirements: Iterable[str]) -> tuple[Requirement, ...]:
+    """Project sorted native requirements active on this platform with extra=''.
+
+    Accept installed or source metadata without requiring installed providers.
+    Requested extras do not activate optional requirements; installation checks
+    remain with the caller that activates dependencies.
+    """
+    parsed = (Requirement(value) for value in sorted(requirements))
+    return tuple(
+        requirement
+        for requirement in parsed
+        if requirement.marker is None or requirement.marker.evaluate({"extra": ""})
+    )
+
+
+def installed_addons(group: str) -> InstalledAddons:
+    """Index group declarations and declared app-key collisions without imports.
+
+    Each participating distribution must declare exactly one group entry point.
+    Its value remains a native app/config string, never a loaded entry point.
+    Native metadata.distribution selects the winner for same-name installations.
+    """
+    if not isinstance(group, str) or not group:
+        raise ImproperlyConfigured("An explicit non-empty addon entry-point group is required")
+    distributions: dict[str, metadata.Distribution] = {}
+    points: dict[str, metadata.EntryPoint] = {}
+    app_providers: dict[str, str] = {}
+    names = {canonicalize_name(dist.metadata["Name"]) for dist in metadata.distributions()}
+    for name in sorted(names):
+        distribution = metadata.distribution(name)
+        entries = distribution.entry_points.select(group=group)
+        distributions[name] = distribution
+        if not entries:
+            continue
+        if len(entries) != 1:
+            raise ImproperlyConfigured(f"Distribution {name!r} must declare one entry point in {group!r}")
+        point = next(iter(entries))
+        if point.name in app_providers:
+            raise ImproperlyConfigured(
+                f"Competing providers for app {point.name!r}: {app_providers[point.name]!r} and {name!r}"
+            )
+        app_providers[point.name] = name
+        points[name] = point
+    return InstalledAddons(
+        MappingProxyType(distributions), MappingProxyType(points), MappingProxyType(app_providers)
+    )
+
+
+def enabled_apps(roots: Iterable[str], *, group: str | None = None) -> Closure:
+    """Expand explicit roots using installed providers and selected requires_apps.
+
+    Settings are never read. Without a group, only native requires_apps edges
+    apply and distribution metadata is not inspected. Its entry-point keys are
+    native app names and values are native INSTALLED_APPS strings, never loaded
+    entry-point objects. An addon's active Requires-Dist edges (extra='') activate
+    only distributions in this group. Ordinary roots have no metadata expansion.
+    Installation alone never activates an addon or an optional extra.
+
+    Root configs are preselected and override dependency/default config choices.
+    Conflicting dependency configs, duplicate native labels and cycles fail.
+    """
+    installed = installed_addons(group) if group is not None else None
+    root_entries = tuple(roots)
+    if any(not isinstance(entry, str) for entry in root_entries):
+        raise ImproperlyConfigured("Root INSTALLED_APPS entries must be native app strings")
+    root_configs = tuple((entry, AppConfig.create(entry)) for entry in root_entries)
+    normalized_roots = app_entries(Entry.from_config(config, entry) for entry, config in root_configs)
+    root_names = tuple(entry.name for entry in normalized_roots)
+    root_set = frozenset(root_names)
+    selected = {config.name: (entry, config) for entry, config in root_configs if config.name in root_set}
+    by_app = installed.providers if installed is not None else {}
+    graph: dict[str, tuple[str, ...]] = {}
+
+    def addon_entry(provider: str) -> str:
+        assert installed is not None
+        point = installed.entry_points[provider]
+        config = AppConfig.create(point.value)
+        if config.name != point.name:
+            raise ImproperlyConfigured(
+                f"Entry point {point.name!r} from {provider!r} selects app {config.name!r}"
+            )
+        return point.value
+
+    def choose(entry: str) -> str:
+        config = AppConfig.create(entry)
+        previous = selected.get(config.name)
+        if previous is None:
+            selected[config.name] = (entry, config)
+        elif config.name not in root_set and type(previous[1]) is not type(config):
+            raise ImproperlyConfigured(
+                f"Conflicting app configs for {config.name!r}: {previous[0]!r} and {entry!r}"
+            )
+        return config.name
+
+    def visit(name: str) -> None:
+        if name in graph:
+            return
+        graph[name] = ()  # Record before recursion so graphlib can diagnose cycles.
+        config = selected[name][1]
+        required_apps = getattr(config, "requires_apps", ())
+        if isinstance(required_apps, str) or not isinstance(required_apps, Iterable):
+            raise ImproperlyConfigured(f"{name}.requires_apps must be an iterable of native app strings")
+        dependencies = list(required_apps)
+        provider = by_app.get(name)
+        if provider is not None:
+            addon_entry(provider)
+            assert installed is not None
+            for parsed in installed.active_requirements(provider):
+                dependency = canonicalize_name(parsed.name)
+                if dependency not in installed.distributions:
+                    raise ImproperlyConfigured(
+                        f"Addon {name!r} requires missing installed distribution {parsed.name!r}"
+                    )
+                if dependency in installed.entry_points:
+                    dependencies.append(addon_entry(dependency))
+        if any(not isinstance(entry, str) for entry in dependencies):
+            raise ImproperlyConfigured(f"{name}.requires_apps entries must be native app strings")
+        graph[name] = tuple(sorted({choose(entry) for entry in sorted(dependencies)}))
+        for dependency_name in graph[name]:
+            visit(dependency_name)
+
+    for name in root_names:
+        visit(name)
+    try:
+        ordered = tuple(TopologicalSorter(graph).static_order())
+    except CycleError as error:
+        raise ImproperlyConfigured(f"App dependency cycle: {' -> '.join(error.args[1])}") from error
+    configs = tuple(selected[name][1] for name in ordered)
+    entries = app_entries(Entry.from_config(config, selected[config.name][0]) for config in configs)
+    return Closure(
+        entries,
+        root_names,
+        frozenset(ordered) - root_set,
+        frozenset(ordered).intersection(by_app),
+        MappingProxyType(graph),
+        app_configs=configs,
+    )

django_compose/apps.py

@@ -0,0 +1,103 @@
+"""Native command registration and the final compose-only phase-2 lifecycle."""
+
+from __future__ import annotations
+
+from django.apps import AppConfig
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+from django_compose import checks  # noqa: F401 -- register deferred native system checks
+from django_compose.serving import _close_startup_verification, _finish_startup_verification, mode, verify
+from django_compose.snapshot import Snapshot
+
+
+class ComposeConfig(AppConfig):
+    """Register management commands without importing build or source models."""
+
+    name = "django_compose"
+    default = True
+
+    def ready(self) -> None:
+        try:
+            if self.apps is None or tuple(self.apps.get_app_configs())[-1] is not self:
+                raise ImproperlyConfigured("ComposeConfig must be last in INSTALLED_APPS")
+            if mode() is not None:
+                raise ImproperlyConfigured("Compose mode requires BuildComposeConfig last in INSTALLED_APPS")
+            _finish_startup_verification(required=True)
+        finally:
+            _close_startup_verification()
+
+
+class BuildComposeConfig(AppConfig):
+    """Compile last in phase 2 so every ready callback sees concrete models."""
+
+    name = "django_compose"
+    default = False
+
+    def import_models(self) -> None:
+        super().import_models()
+        selected_mode = mode()
+        if selected_mode is None:
+            raise ImproperlyConfigured("BuildComposeConfig requires DJANGO_COMPOSE_MODE before settings load")
+        if self.apps is None or tuple(self.apps.get_app_configs())[-1] is not self:
+            raise ImproperlyConfigured("BuildComposeConfig must be last in INSTALLED_APPS")
+        self.compose_mode = selected_mode
+        from django_compose.build import ConcreteModels, emit
+        from django_compose.declarations import ArtifactHook, resolve_integrations
+
+        snap = getattr(settings, "COMPOSE_SNAPSHOT", None)
+        if not isinstance(snap, Snapshot):
+            raise ImproperlyConfigured("Settings must create COMPOSE_SNAPSHOT before population")
+        snap.check_mode()
+        output_dir = settings.COMPOSE_OUTPUT_DIR
+        output_module = getattr(settings, "COMPOSE_OUTPUT_MODULE", "runtime")
+        if selected_mode == "check":
+            verify(snap, output_module)
+        integrations = resolve_integrations(snap.integration_paths)
+        transitions = snap.transition_records
+        self.plan = emit(
+            snap,
+            self.apps.get_app_configs(),
+            mode=selected_mode,
+            integrations=integrations,
+            transitions=transitions,
+            output_dir=output_dir,
+            output_module=output_module,
+        )
+        try:
+            self.plan.render_artifacts(
+                ConcreteModels(self.plan.composition),
+                tuple(
+                    hook for hook in integrations if isinstance(hook, ArtifactHook) and hook.phase == "models"
+                ),
+            )
+        except BaseException:
+            self.plan.close()
+            raise
+
+    def ready(self) -> None:
+        try:
+            if mode() != self.compose_mode:
+                raise ImproperlyConfigured("DJANGO_COMPOSE_MODE changed after settings load")
+            from django_compose.declarations import ArtifactHook
+
+            assert self.apps is not None
+            self.plan.render_artifacts(
+                self.apps,
+                tuple(
+                    hook
+                    for hook in self.plan.integrations
+                    if isinstance(hook, ArtifactHook) and hook.phase == "ready"
+                ),
+            )
+            self.receipt = self.plan.finalize()
+            if self.compose_mode == "check":
+                from django_compose.migrations import TransitionBinding
+
+                binding = TransitionBinding(labels=self.plan.labels, declarations=self.plan.transitions)
+                assert self.apps is not None
+                binding.check_native_history(self.apps)
+            _finish_startup_verification()
+        finally:
+            self.plan.close()
+            _close_startup_verification()

django_compose/artifacts.py

@@ -0,0 +1,224 @@
+"""Guarded atomic generated files and the single receipt publication lock."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import stat
+import tempfile
+from collections.abc import Mapping
+from contextlib import nullcontext
+from dataclasses import dataclass
+from pathlib import Path
+
+from django.core.exceptions import ImproperlyConfigured
+
+from django_compose.serving import Receipt, _validate_output_root, read_receipt
+from django_compose.serving import receipt_lock as receipt_lock
+
+
+def atomic_write(path: Path, content: bytes) -> None:
+    # Native loaders may otherwise accept same-second, same-size stale bytecode.
+    caches: tuple[Path, ...] = ()
+    if path.suffix == ".py" and "migrations" not in path.parts:
+        cache_dir = path.parent / "__pycache__"
+        if cache_dir.is_symlink():
+            raise ValueError(f"Generated bytecode directory is a symlink: {cache_dir}")
+        caches = tuple(sorted(cache_dir.glob(f"{path.stem}.*.pyc")))
+        if any(cache.is_symlink() or not cache.is_file() for cache in caches):
+            raise ValueError(f"Unsafe generated bytecode cache for {path}")
+    try:
+        mode = stat.S_IMODE(path.stat().st_mode)
+    except FileNotFoundError:
+        mode = None
+    path.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(prefix=".compose-", dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(content)
+            stream.flush()
+            if mode is not None:
+                os.fchmod(stream.fileno(), mode)
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        for cache in caches:
+            cache.unlink(missing_ok=True)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+@dataclass
+class GeneratedTree:
+    """Only receipt-indexed outputs may be replaced; native history survives."""
+
+    root: Path
+    artifacts: Mapping[Path, bytes | str]
+
+    @staticmethod
+    def validate_artifacts(root: Path, artifacts: Mapping[Path, bytes | str]) -> None:
+        _validate_output_root(root)
+        paths = set(artifacts)
+        for relative, source in artifacts.items():
+            if (
+                not isinstance(relative, Path)
+                or relative.is_absolute()
+                or not relative.parts
+                or ".." in relative.parts
+            ):
+                raise ValueError(f"Generated artifacts require a root-relative path: {relative!r}")
+            if not isinstance(source, (str, bytes)):
+                raise ValueError(f"Generated artifact must be bytes or text: {relative}")
+            for part in (*relative.parents, relative):
+                target = root / part
+                if target.is_symlink() or (part != relative and target.exists() and not target.is_dir()):
+                    raise ValueError(f"Unsafe generated path: {relative}")
+            if (root / relative).is_dir() or any(parent in paths for parent in relative.parents):
+                raise ValueError(f"Competing file/directory artifact: {relative}")
+
+    def _validate_migration_scaffold(self) -> None:
+        """Admit durable native history only before the first receipt exists."""
+        if not self.root.exists():
+            return
+        for path in sorted(self.root.rglob("*")):
+            relative = path.relative_to(self.root)
+            parts = relative.parts
+            if path.is_symlink() or not (path.is_file() or path.is_dir()):
+                raise ValueError(f"Unsafe native migration scaffold: {relative}")
+            if relative == Path(".compose.lock") and path.is_file():
+                continue
+            if relative == Path("__init__.py") and path.is_file() and not path.read_bytes():
+                continue
+            label = self.root / parts[0]
+            if not parts[0].isidentifier() or not (label / "migrations").is_dir():
+                raise ValueError(f"{self.root} lacks the required generated-output marker: {relative}")
+            if len(parts) == 1 and path.is_dir():
+                continue
+            if len(parts) >= 2 and parts[1] == "migrations":
+                continue
+            if len(parts) == 2 and parts[1] == "__init__.py" and path.is_file() and not path.read_bytes():
+                continue
+            raise ValueError(f"{self.root} lacks the required generated-output marker: {relative}")
+
+    def _validate(self) -> Receipt | None:
+        self.validate_artifacts(self.root, self.artifacts)
+        receipt = read_receipt(self.root)
+        if receipt is None:
+            self._validate_migration_scaffold()
+        owned = receipt.OWNED_FILES if receipt else {}
+        self.validate_artifacts(self.root, {Path(path): b"" for path in owned})
+        for relative, source in self.artifacts.items():
+            target = self.root / relative
+            if (
+                "migrations" in relative.parts
+                and target.exists()
+                and target.read_bytes() != self._bytes(source)
+            ):
+                raise ValueError(f"Cannot overwrite native migration history: {relative}")
+            if (
+                target.exists()
+                and relative.as_posix() not in owned
+                and relative != Path("__init__.py")
+                and "migrations" not in relative.parts
+            ):
+                raise ValueError(f"Generated artifact collides with an unowned file: {relative}")
+        return receipt
+
+    @staticmethod
+    def _bytes(value: bytes | str) -> bytes:
+        return value.encode() if isinstance(value, str) else value
+
+    def drift(self) -> list[Path]:
+        previous = self._validate()
+        changed = {
+            p
+            for p, value in self.artifacts.items()
+            if not (self.root / p).is_file() or (self.root / p).read_bytes() != self._bytes(value)
+        }
+        old = {Path(p) for p in previous.OWNED_FILES} if previous else set()
+        return sorted(
+            changed
+            | {
+                p
+                for p in old - set(self.artifacts)
+                if "migrations" not in p.parts and (self.root / p).exists()
+            }
+        )
+
+    def reconcile(self, *, prune: bool = True) -> bool:
+        previous = self._validate()
+        changed = False
+        for relative, value in sorted(self.artifacts.items()):
+            target = self.root / relative
+            content = self._bytes(value)
+            if not target.is_file() or target.read_bytes() != content:
+                atomic_write(target, content)
+                changed = True
+        if prune and previous:
+            for name in sorted(set(previous.OWNED_FILES) - {p.as_posix() for p in self.artifacts}):
+                relative = Path(name)
+                if "migrations" not in relative.parts and (self.root / relative).is_file():
+                    (self.root / relative).unlink()
+                    changed = True
+        return changed
+
+    def hashes(self) -> dict[str, str]:
+        return {
+            p.as_posix(): hashlib.sha256(self._bytes(value)).hexdigest()
+            for p, value in sorted(self.artifacts.items())
+            if p != Path("__init__.py") and "migrations" not in p.parts
+        }
+
+    def clean(self) -> tuple[Path, ...]:
+        with receipt_lock(self.root):
+            receipt = self._validate()
+            if receipt is None:
+                return ()
+            invalid = Receipt(
+                receipt.HISTORY_LABELS,
+                receipt.RETIRED_LABELS,
+                receipt.DIGEST,
+                receipt.OWNED_FILES,
+                receipt.COMPILER,
+                receipt.MODEL_LABELS,
+                True,
+            )
+            atomic_write(self.root / "__init__.py", invalid.source().encode())
+            for name in sorted(receipt.OWNED_FILES):
+                path = Path(name)
+                if "migrations" not in path.parts and (self.root / path).is_file():
+                    (self.root / path).unlink()
+            return tuple(sorted(path.relative_to(self.root) for path in self.root.rglob("*")))
+
+
+def update_receipt(
+    output_dir: Path | str, *, retired_labels: tuple[str, ...], locked: bool = False
+) -> Receipt:
+    """Publish retirement under the same invalidate-first writer protocol."""
+    root = Path(output_dir)
+    with nullcontext() if locked else receipt_lock(root):
+        previous = read_receipt(root)
+        if previous is None or previous.IN_PROGRESS:
+            raise ImproperlyConfigured("History retirement requires a complete receipt; run compose")
+        GeneratedTree(root, {}).validate_artifacts(root, {Path(p): b"" for p in previous.OWNED_FILES})
+        invalid = Receipt(
+            previous.HISTORY_LABELS,
+            previous.RETIRED_LABELS,
+            previous.DIGEST,
+            previous.OWNED_FILES,
+            previous.COMPILER,
+            previous.MODEL_LABELS,
+            True,
+        )
+        atomic_write(root / "__init__.py", invalid.source().encode())
+        retired = tuple(sorted(set(previous.RETIRED_LABELS) | set(retired_labels)))
+        result = Receipt(
+            tuple(label for label in previous.HISTORY_LABELS if label not in retired),
+            retired,
+            previous.DIGEST,
+            previous.OWNED_FILES,
+            previous.COMPILER,
+            previous.MODEL_LABELS,
+        )
+        atomic_write(root / "__init__.py", result.source().encode())
+        return result

django_compose/asgi.py

@@ -0,0 +1,110 @@
+"""Post-setup ASGI composition over native Django HTTP and async contexts."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from contextlib import AbstractAsyncContextManager, AsyncExitStack
+from dataclasses import dataclass, field
+from typing import cast
+
+from asgiref.typing import ASGI3Application, ASGIReceiveCallable, ASGISendCallable, Scope
+from django.apps import apps
+from django.core.exceptions import ImproperlyConfigured
+from django.core.handlers.asgi import ASGIHandler
+
+
+@dataclass(frozen=True)
+class AsgiContribution:
+    """Mount paths and scope handlers; lifespan factories return fresh async contexts.
+
+    Mounts are absolute decoded paths without a trailing slash (except `/`).
+    The mounted app receives the original path with its mount added to root_path,
+    following ASGI's path/root_path convention. Query strings are unchanged.
+    HTTP and lifespan are reserved scope types.
+    """
+
+    http_mounts: Mapping[str, ASGI3Application] = field(default_factory=dict)
+    lifespans: tuple[Callable[[], AbstractAsyncContextManager[object]], ...] = ()
+    protocols: Mapping[str, ASGI3Application] = field(default_factory=dict)
+
+
+class _Application:
+    def __init__(self) -> None:
+        apps.check_apps_ready()
+        if not apps.ready:
+            raise RuntimeError("ASGI composition requires completed django.setup()")
+        self.http = cast(ASGI3Application, ASGIHandler())
+        self.mounts: dict[str, ASGI3Application] = {}
+        self.protocols: dict[str, ASGI3Application] = {}
+        self.lifespans: list[Callable[[], AbstractAsyncContextManager[object]]] = []
+        mount_owners: dict[str, str] = {}
+        protocol_owners = {"http": "Django HTTP fallback", "lifespan": "django-compose lifespan"}
+        for config in apps.get_app_configs():
+            factory = getattr(config, "compose_asgi", None)
+            if factory is None:
+                continue
+            contribution = factory()
+            if not isinstance(contribution, AsgiContribution):
+                raise ImproperlyConfigured(f"{config.name}.compose_asgi() must return AsgiContribution")
+            for prefix, handler in contribution.http_mounts.items():
+                if (
+                    not isinstance(prefix, str)
+                    or not prefix.startswith("/")
+                    or (prefix != "/" and prefix.endswith("/"))
+                ):
+                    raise ImproperlyConfigured(f"{config.name}: invalid HTTP mount {prefix!r}")
+                self._claim(mount_owners, prefix, config.name)
+                self.mounts[prefix] = handler
+            for protocol, handler in contribution.protocols.items():
+                self._claim(protocol_owners, protocol, config.name)
+                self.protocols[protocol] = handler
+            self.lifespans.extend(contribution.lifespans)
+        self.prefixes = sorted(self.mounts, key=lambda prefix: (-len(prefix), prefix))
+
+    @staticmethod
+    def _claim(owners: dict[str, str], key: str, owner: str) -> None:
+        if key in owners:
+            raise ImproperlyConfigured(f"ASGI {key!r} is claimed by {owners[key]} and {owner}")
+        owners[key] = owner
+
+    async def __call__(self, scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
+        kind = scope["type"]
+        if scope["type"] == "lifespan":
+            await self._lifespan(receive, send)
+        elif scope["type"] == "http":
+            root = scope.get("root_path", "")
+            relative = scope["path"].removeprefix(root)
+            for prefix in self.prefixes:
+                if prefix == "/" or relative == prefix or relative.startswith(prefix + "/"):
+                    mounted = scope.copy()
+                    mounted["root_path"] = root + ("" if prefix == "/" else prefix)
+                    await self.mounts[prefix](mounted, receive, send)
+                    return
+            await self.http(scope, receive, send)
+        elif kind in self.protocols:
+            await self.protocols[kind](scope, receive, send)
+        else:
+            raise ValueError(f"Unsupported ASGI scope type: {kind!r}")
+
+    async def _lifespan(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
+        if (await receive())["type"] != "lifespan.startup":
+            raise ValueError("Expected lifespan.startup")
+        started = False
+        try:
+            async with AsyncExitStack() as stack:
+                for factory in self.lifespans:
+                    await stack.enter_async_context(factory())
+                started = True
+                await send({"type": "lifespan.startup.complete"})
+                if (await receive())["type"] != "lifespan.shutdown":
+                    raise ValueError("Expected lifespan.shutdown")
+        except Exception as error:
+            if started:
+                await send({"type": "lifespan.shutdown.failed", "message": str(error)})
+            else:
+                await send({"type": "lifespan.startup.failed", "message": str(error)})
+        else:
+            await send({"type": "lifespan.shutdown.complete"})
+
+
+application = _Application()