tigrcorn-runtime 0.3.16.dev5__py3-none-any.whl

tigrcorn_runtime/server/shutdown.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+
+
+async def graceful_cancel(task: asyncio.Task | None) -> None:
+    if task is None:
+        return
+    task.cancel()
+    with suppress(asyncio.CancelledError):
+        await task

tigrcorn_runtime/server/signals.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import signal
+from collections.abc import Callable
+from types import FrameType
+from typing import Any
+
+
+SignalCallback = Callable[[int], None]
+
+
+def install_signal_handlers(loop: Any, callback: Callable[[], None]) -> None:
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, callback)
+        except (NotImplementedError, RuntimeError):  # pragma: no cover - platform dependent
+            try:
+                signal.signal(sig, lambda *_: callback())
+            except ValueError:
+                pass
+
+
+def install_sync_signal_handlers(callback: SignalCallback) -> dict[int, Any]:
+    previous: dict[int, Any] = {}
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        previous[sig] = signal.getsignal(sig)
+        signal.signal(sig, lambda signum, frame, cb=callback: cb(signum))
+    return previous
+
+
+def restore_signal_handlers(previous: dict[int, Any]) -> None:
+    for sig, handler in previous.items():
+        signal.signal(sig, handler)

tigrcorn_runtime/server/state.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from time import monotonic
+
+from tigrcorn_observability.metrics import Metrics
+
+
+@dataclass(slots=True)
+class ServerState:
+    started_at: float = field(default_factory=monotonic)
+    metrics: Metrics = field(default_factory=Metrics)
+    shutting_down: bool = False

tigrcorn_runtime/server/supervisor.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from tigrcorn_config.load import config_to_dict
+from tigrcorn_config.model import ServerConfig
+from tigrcorn_runtime.server.bootstrap import prebind_listener_sockets, run_worker_from_config_payload
+from tigrcorn_runtime.server.signals import install_sync_signal_handlers, restore_signal_handlers
+from tigrcorn_runtime.workers.process import ProcessWorker
+from tigrcorn_runtime.workers.supervisor import WorkerSupervisor
+
+
+@dataclass(slots=True)
+class ServerSupervisor:
+    app_target: str | None
+    config: ServerConfig
+    started: bool = False
+    hooks: list[Any] = field(default_factory=list)
+    poll_interval: float = 0.2
+    bound_sockets: list[Any] = field(default_factory=list)
+    workers: WorkerSupervisor = field(default_factory=lambda: WorkerSupervisor(auto_restart=True))
+    _stopping: bool = False
+
+    def add_shutdown_hook(self, hook) -> None:
+        self.hooks.append(hook)
+
+    def request_shutdown(self) -> None:
+        self._stopping = True
+
+    def _worker_payload(self) -> dict[str, Any]:
+        payload = config_to_dict(self.config)
+        if self.app_target is not None:
+            payload.setdefault('app', {})['target'] = self.app_target
+        return payload
+
+    def _build_workers(self) -> None:
+        worker_count = max(1, self.config.process.workers)
+        payload = self._worker_payload()
+        for index in range(worker_count):
+            worker = ProcessWorker(name=f'tigrcorn-worker-{index}', healthcheck_timeout=self.config.process.worker_healthcheck_timeout)
+            worker.start(run_worker_from_config_payload, payload)
+            self.workers.add(worker)
+
+    def start(self) -> None:
+        if self.started:
+            return
+        self.bound_sockets = prebind_listener_sockets(self.config)
+        if self.config.process.pid_file:
+            Path(self.config.process.pid_file).write_text(str(os.getpid()))
+        self._build_workers()
+        self.started = True
+
+    def replace_worker(self, index: int) -> None:
+        payload = self._worker_payload()
+        worker = self.workers.workers[index]
+        replacement = ProcessWorker(name=f'{worker.name}-replacement', healthcheck_timeout=self.config.process.worker_healthcheck_timeout)
+        replacement.start(run_worker_from_config_payload, payload)
+        self.workers.replace(index, replacement)
+
+    def poll_workers_once(self) -> list[dict[str, Any]]:
+        restarted: list[dict[str, Any]] = []
+        payload = self._worker_payload()
+        for index, worker in enumerate(list(self.workers.workers)):
+            if not isinstance(worker, ProcessWorker):
+                continue
+            worker.poll_ready()
+            should_restart = worker.process is not None and not worker.is_alive()
+            if worker.startup_timed_out() and not self._stopping:
+                worker.stop(timeout=min(5.0, self.config.process.worker_healthcheck_timeout))
+                should_restart = True
+            if should_restart and not self._stopping:
+                worker.restart_count += 1
+                replacement = ProcessWorker(name=worker.name, healthcheck_timeout=self.config.process.worker_healthcheck_timeout)
+                replacement.start(run_worker_from_config_payload, payload)
+                self.workers.workers[index] = replacement
+                restarted.append({'index': index, 'name': replacement.name, 'ready': replacement.ready})
+        return restarted
+
+    def stop(self) -> None:
+        self._stopping = True
+        self.workers.stop_all(timeout=self.config.http.shutdown_timeout)
+        for hook in self.hooks:
+            try:
+                hook()
+            except Exception:
+                pass
+        for sock in self.bound_sockets:
+            try:
+                sock.close()
+            except Exception:
+                pass
+        if self.config.process.pid_file:
+            with contextlib.suppress(Exception):
+                Path(self.config.process.pid_file).unlink()
+
+    def run(self) -> None:
+        self.start()
+        previous = install_sync_signal_handlers(lambda _sig: self.request_shutdown())
+        try:
+            while not self._stopping:
+                self.poll_workers_once()
+                time.sleep(self.poll_interval)
+        finally:
+            restore_signal_handlers(previous)
+            self.stop()

tigrcorn_runtime/workers/__init__.py

@@ -0,0 +1,6 @@
+from .local import LocalWorker
+from .model import WorkerConfig
+from .process import ProcessWorker
+from .supervisor import WorkerSupervisor
+
+__all__ = ["LocalWorker", "ProcessWorker", "WorkerConfig", "WorkerSupervisor"]

tigrcorn_runtime/workers/local.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from time import monotonic
+from typing import Any, Callable
+
+
+@dataclass(slots=True)
+class LocalWorker:
+    name: str = 'local'
+    running: bool = False
+    metadata: dict[str, Any] = field(default_factory=dict)
+    start_count: int = 0
+    stop_count: int = 0
+    last_started_at: float | None = None
+    callback: Callable[[], None] | None = None
+
+    def start(self) -> None:
+        self.running = True
+        self.start_count += 1
+        self.last_started_at = monotonic()
+        if self.callback is not None:
+            self.callback()
+
+    def stop(self) -> None:
+        self.running = False
+        self.stop_count += 1
+
+    def health(self) -> dict[str, Any]:
+        return {
+            'name': self.name,
+            'alive': self.running,
+            'start_count': self.start_count,
+            'stop_count': self.stop_count,
+            'last_started_at': self.last_started_at,
+        }

tigrcorn_runtime/workers/model.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class WorkerConfig:
+    processes: int = 1
+    graceful_shutdown_timeout: float = 30.0

tigrcorn_runtime/workers/process.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import multiprocessing
+import os
+import signal
+from dataclasses import dataclass, field
+from time import monotonic
+from typing import Any, Callable
+
+
+@dataclass(slots=True)
+class ProcessWorker:
+    name: str = 'process'
+    process: multiprocessing.Process | None = None
+    target: Callable[..., None] | None = None
+    args: tuple[Any, ...] = field(default_factory=tuple)
+    kwargs: dict[str, Any] = field(default_factory=dict)
+    start_count: int = 0
+    restart_count: int = 0
+    last_started_at: float | None = None
+    healthcheck_timeout: float = 30.0
+    ready: bool = False
+    ready_at: float | None = None
+    _ready_parent: Any | None = None
+
+    def _ctx(self) -> multiprocessing.context.BaseContext:
+        if os.name == 'posix':
+            try:
+                return multiprocessing.get_context('fork')
+            except ValueError:
+                pass
+        return multiprocessing.get_context()
+
+    def start(self, target: Callable[..., None] | None = None, *args: Any, **kwargs: Any) -> None:
+        if target is not None:
+            self.target = target
+            self.args = args
+            self.kwargs = kwargs
+        if self.target is None:
+            raise RuntimeError('process worker target is not configured')
+        if self.process is not None and self.process.is_alive():
+            return
+        ctx = self._ctx()
+        parent_ready, child_ready = ctx.Pipe(duplex=False)
+        child_kwargs = dict(self.kwargs)
+        child_kwargs['ready_pipe'] = child_ready
+        self.process = ctx.Process(target=self.target, args=self.args, kwargs=child_kwargs, name=self.name)
+        self.process.start()
+        self._ready_parent = parent_ready
+        self.ready = False
+        self.ready_at = None
+        self.start_count += 1
+        self.last_started_at = monotonic()
+
+    def poll_ready(self) -> None:
+        if self.ready or self._ready_parent is None:
+            return
+        try:
+            if self._ready_parent.poll():
+                self._ready_parent.recv()
+                self.ready = True
+                self.ready_at = monotonic()
+        except EOFError:
+            self._ready_parent = None
+
+    def startup_timed_out(self) -> bool:
+        self.poll_ready()
+        if self.ready or self.healthcheck_timeout <= 0 or self.last_started_at is None:
+            return False
+        return (monotonic() - self.last_started_at) > self.healthcheck_timeout
+
+    def stop(self, timeout: float = 5.0) -> None:
+        if self.process is None:
+            return
+        if self.process.is_alive():
+            try:
+                self.process.terminate()
+            except Exception:
+                pass
+            self.process.join(timeout=timeout)
+            if self.process.is_alive():
+                try:
+                    os.kill(self.process.pid, signal.SIGKILL)
+                except Exception:
+                    pass
+                self.process.join(timeout=1.0)
+        if self._ready_parent is not None:
+            try:
+                self._ready_parent.close()
+            except Exception:
+                pass
+            self._ready_parent = None
+        self.ready = False
+        self.ready_at = None
+
+    def restart(self, timeout: float = 5.0) -> None:
+        self.restart_count += 1
+        target = self.target
+        args = self.args
+        kwargs = dict(self.kwargs)
+        self.stop(timeout=timeout)
+        self.start(target, *args, **kwargs)
+
+    def is_alive(self) -> bool:
+        return bool(self.process is not None and self.process.is_alive())
+
+    def health(self) -> dict[str, Any]:
+        self.poll_ready()
+        return {
+            'name': self.name,
+            'pid': self.process.pid if self.process else None,
+            'alive': self.is_alive(),
+            'ready': self.ready,
+            'exitcode': self.process.exitcode if self.process else None,
+            'start_count': self.start_count,
+            'restart_count': self.restart_count,
+            'last_started_at': self.last_started_at,
+            'ready_at': self.ready_at,
+            'startup_timed_out': self.startup_timed_out(),
+        }

tigrcorn_runtime/workers/supervisor.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .local import LocalWorker
+from .process import ProcessWorker
+
+WorkerType = LocalWorker | ProcessWorker
+
+
+@dataclass(slots=True)
+class WorkerSupervisor:
+    workers: list[WorkerType] = field(default_factory=list)
+    auto_restart: bool = True
+
+    def add(self, worker: WorkerType) -> None:
+        self.workers.append(worker)
+
+    def start_all(self) -> None:
+        for worker in self.workers:
+            worker.start()  # type: ignore[arg-type]
+
+    def stop_all(self, *, timeout: float = 5.0) -> None:
+        for worker in self.workers:
+            if isinstance(worker, ProcessWorker):
+                worker.stop(timeout=timeout)
+            else:
+                worker.stop()
+
+    def replace(self, index: int, worker: WorkerType | None = None, *, timeout: float = 5.0) -> WorkerType:
+        current = self.workers[index]
+        replacement = worker or current
+        if replacement is current:
+            if isinstance(current, ProcessWorker):
+                current.restart(timeout=timeout)
+            else:
+                current.stop()
+                current.start()
+            return current
+        if isinstance(current, ProcessWorker):
+            current.stop(timeout=timeout)
+        else:
+            current.stop()
+        self.workers[index] = replacement
+        replacement.start()  # type: ignore[arg-type]
+        return replacement
+
+    def unhealthy(self) -> list[WorkerType]:
+        unhealthy: list[WorkerType] = []
+        for worker in self.workers:
+            if isinstance(worker, ProcessWorker):
+                if worker.process is not None and not worker.is_alive() and worker.process.exitcode not in (None, 0):
+                    unhealthy.append(worker)
+        return unhealthy
+
+    def snapshot(self) -> list[dict[str, Any]]:
+        return [worker.health() for worker in self.workers]

tigrcorn_runtime-0.3.16.dev5.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: tigrcorn-runtime
+Version: 0.3.16.dev5
+Summary: Server runner, app loading, lifecycle hooks, workers, reload, and embedded runtime for the Tigrcorn ASGI3 web server.
+Author-email: Jacob Stewart <jacob@swarmauri.com>
+License: Apache License
+        Version 2.0, January 2004
+        http://www.apache.org/licenses/
+        
+        TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+        1. Definitions.
+        
+           "License" shall mean the terms and conditions for use, reproduction, and
+           distribution as defined by Sections 1 through 9 of this document.
+        
+           "Licensor" shall mean the copyright owner or entity authorized by the
+           copyright owner that is granting the License.
+        
+           "Legal Entity" shall mean the union of the acting entity and all other
+           entities that control, are controlled by, or are under common control with
+           that entity. For the purposes of this definition, "control" means (i) the
+           power, direct or indirect, to cause the direction or management of such
+           entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+           (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+           such entity.
+        
+           "You" (or "Your") shall mean an individual or Legal Entity exercising
+           permissions granted by this License.
+        
+           "Source" form shall mean the preferred form for making modifications,
+           including but not limited to software source code, documentation source, and
+           configuration files.
+        
+           "Object" form shall mean any form resulting from mechanical transformation
+           or translation of a Source form, including but not limited to compiled object
+           code, generated documentation, and conversions to other media types.
+        
+           "Work" shall mean the work of authorship, whether in Source or Object form,
+           made available under the License, as indicated by a copyright notice that is
+           included in or attached to the work (an example is provided in the Appendix
+           below).
+        
+           "Derivative Works" shall mean any work, whether in Source or Object form,
+           that is based on (or derived from) the Work and for which the editorial
+           revisions, annotations, elaborations, or other modifications represent, as a
+           whole, an original work of authorship. For the purposes of this License,
+           Derivative Works shall not include works that remain separable from, or
+           merely link (or bind by name) to the interfaces of, the Work and Derivative
+           Works thereof.
+        
+           "Contribution" shall mean any work of authorship, including the original
+           version of the Work and any modifications or additions to that Work or
+           Derivative Works thereof, that is intentionally submitted to Licensor for
+           inclusion in the Work by the copyright owner or by an individual or Legal
+           Entity authorized to submit on behalf of the copyright owner. For the
+           purposes of this definition, "submitted" means any form of electronic,
+           verbal, or written communication sent to the Licensor or its representatives,
+           including but not limited to communication on electronic mailing lists,
+           source code control systems, and issue tracking systems that are managed by,
+           or on behalf of, the Licensor for the purpose of discussing and improving the
+           Work, but excluding communication that is conspicuously marked or otherwise
+           designated in writing by the copyright owner as "Not a Contribution."
+        
+           "Contributor" shall mean Licensor and any individual or Legal Entity on
+           behalf of whom a Contribution has been received by Licensor and subsequently
+           incorporated within the Work.
+        
+        2. Grant of Copyright License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+           reproduce, prepare Derivative Works of, publicly display, publicly perform,
+           sublicense, and distribute the Work and such Derivative Works in Source or
+           Object form.
+        
+        3. Grant of Patent License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+           section) patent license to make, have made, use, offer to sell, sell, import,
+           and otherwise transfer the Work, where such license applies only to those
+           patent claims licensable by such Contributor that are necessarily infringed by
+           their Contribution(s) alone or by combination of their Contribution(s) with
+           the Work to which such Contribution(s) was submitted. If You institute patent
+           litigation against any entity (including a cross-claim or counterclaim in a
+           lawsuit) alleging that the Work or a Contribution incorporated within the Work
+           constitutes direct or contributory patent infringement, then any patent
+           licenses granted to You under this License for that Work shall terminate as of
+           the date such litigation is filed.
+        
+        4. Redistribution. You may reproduce and distribute copies of the Work or
+           Derivative Works thereof in any medium, with or without modifications, and in
+           Source or Object form, provided that You meet the following conditions:
+        
+           (a) You must give any other recipients of the Work or Derivative Works a copy
+               of this License; and
+        
+           (b) You must cause any modified files to carry prominent notices stating that
+               You changed the files; and
+        
+           (c) You must retain, in the Source form of any Derivative Works that You
+               distribute, all copyright, patent, trademark, and attribution notices
+               from the Source form of the Work, excluding those notices that do not
+               pertain to any part of the Derivative Works; and
+        
+           (d) If the Work includes a "NOTICE" text file as part of its distribution,
+               then any Derivative Works that You distribute must include a readable copy
+               of the attribution notices contained within such NOTICE file, excluding
+               those notices that do not pertain to any part of the Derivative Works, in
+               at least one of the following places: within a NOTICE text file distributed
+               as part of the Derivative Works; within the Source form or documentation,
+               if provided along with the Derivative Works; or, within a display generated
+               by the Derivative Works, if and wherever such third-party notices normally
+               appear. The contents of the NOTICE file are for informational purposes only
+               and do not modify the License. You may add Your own attribution notices
+               within Derivative Works that You distribute, alongside or as an addendum to
+               the NOTICE text from the Work, provided that such additional attribution
+               notices cannot be construed as modifying the License.
+        
+           You may add Your own copyright statement to Your modifications and may provide
+           additional or different license terms and conditions for use, reproduction, or
+           distribution of Your modifications, or for any such Derivative Works as a
+           whole, provided Your use, reproduction, and distribution of the Work otherwise
+           complies with the conditions stated in this License.
+        
+        5. Submission of Contributions. Unless You explicitly state otherwise, any
+           Contribution intentionally submitted for inclusion in the Work by You to the
+           Licensor shall be under the terms and conditions of this License, without any
+           additional terms or conditions. Notwithstanding the above, nothing herein
+           shall supersede or modify the terms of any separate license agreement you may
+           have executed with Licensor regarding such Contributions.
+        
+        6. Trademarks. This License does not grant permission to use the trade names,
+           trademarks, service marks, or product names of the Licensor, except as
+           required for reasonable and customary use in describing the origin of the Work
+           and reproducing the content of the NOTICE file.
+        
+        7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+           writing, Licensor provides the Work (and each Contributor provides its
+           Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+           KIND, either express or implied, including, without limitation, any warranties
+           or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+           PARTICULAR PURPOSE. You are solely responsible for determining the
+           appropriateness of using or redistributing the Work and assume any risks
+           associated with Your exercise of permissions under this License.
+        
+        8. Limitation of Liability. In no event and under no legal theory, whether in
+           tort (including negligence), contract, or otherwise, unless required by
+           applicable law (such as deliberate and grossly negligent acts) or agreed to in
+           writing, shall any Contributor be liable to You for damages, including any
+           direct, indirect, special, incidental, or consequential damages of any
+           character arising as a result of this License or out of the use or inability
+           to use the Work (including but not limited to damages for loss of goodwill,
+           work stoppage, computer failure or malfunction, or any and all other
+           commercial damages or losses), even if such Contributor has been advised of
+           the possibility of such damages.
+        
+        9. Accepting Warranty or Additional Liability. While redistributing the Work or
+           Derivative Works thereof, You may choose to offer, and charge a fee for,
+           acceptance of support, warranty, indemnity, or other liability obligations
+           and/or rights consistent with this License. However, in accepting such
+           obligations, You may act only on Your own behalf and on Your sole
+           responsibility, not on behalf of any other Contributor, and only if You agree
+           to indemnify, defend, and hold each Contributor harmless for any liability
+           incurred by, or claims asserted against, such Contributor by reason of your
+           accepting any such warranty or additional liability.
+        
+        END OF TERMS AND CONDITIONS
+        
+        
+Keywords: tigrcorn,asgi-server,server-runtime,lifespan,workers,reload,python-web-server
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tigrcorn-core==0.3.16.dev5
+Requires-Dist: tigrcorn-config==0.3.16.dev5
+Requires-Dist: tigrcorn-asgi==0.3.16.dev5
+Requires-Dist: tigrcorn-transports==0.3.16.dev5
+Requires-Dist: tigrcorn-protocols==0.3.16.dev5
+Requires-Dist: tigrcorn-security==0.3.16.dev5
+Provides-Extra: uvloop
+Requires-Dist: uvloop>=0.19.0; platform_system != "Windows" and extra == "uvloop"
+Provides-Extra: trio
+Requires-Dist: trio>=0.25.0; extra == "trio"
+Dynamic: license-file
+
+<div align="center">
+<h1>tigrcorn-runtime</h1>
+
+<p><strong>Server runner, app loading, lifecycle hooks, workers, reload, and embedded runtime for the Tigrcorn ASGI3 web server.</strong></p>
+
+<a href="https://pypi.org/project/tigrcorn-runtime/"><img alt="PyPI version for tigrcorn-runtime" src="https://img.shields.io/pypi/v/tigrcorn-runtime?label=PyPI"></a>
+<a href="https://pypi.org/project/tigrcorn-runtime/"><img alt="tigrcorn-runtime package on PyPI" src="https://img.shields.io/badge/package-PyPI-blue"></a>
+<a href="LICENSE"><img alt="Apache 2.0 license" src="https://img.shields.io/badge/license-Apache%202.0-525252"></a>
+<a href="pyproject.toml"><img alt="Python 3.11 supported" src="https://img.shields.io/badge/python-3.11-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.12 supported" src="https://img.shields.io/badge/python-3.12-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.13 supported" src="https://img.shields.io/badge/python-3.13-3776ab"></a>
+<a href="src/tigrcorn_runtime/py.typed"><img alt="typed package" src="https://img.shields.io/badge/typed-py.typed-2f7ed8"></a>
+<a href="https://pypi.org/project/tigrcorn-runtime/"><img alt="runtime role package" src="https://img.shields.io/badge/role-runtime-0a7f5a"></a>
+</div>
+
+## Install
+
+~~~bash
+pip install tigrcorn-runtime
+~~~
+
+Use the aggregate [tigrcorn](https://pypi.org/project/tigrcorn/) distribution when you want the full ASGI3 Python web server stack. Install <code>tigrcorn-runtime</code> directly when you want only this package boundary and its declared dependencies.
+
+## What It Owns
+
+<code>tigrcorn-runtime</code> owns server runner, app loading, bootstrap, signals, shutdown, workers, embedding, reload, and CLI-facing runtime orchestration. Its import package is <code>tigrcorn_runtime</code>, and its declared package dependencies are: tigrcorn-core, tigrcorn-config, tigrcorn-asgi, tigrcorn-transports, tigrcorn-protocols, tigrcorn-security.
+
+This package page is written for developers searching for Tigrcorn ASGI3 server components, Python web server packages, HTTP/3 and QUIC support, WebSocket and WebTransport runtime surfaces, typed package boundaries, and Apache 2.0 licensed infrastructure.
+
+## Use It When
+
+Use <code>tigrcorn-runtime</code> when you need to run, embed, supervise, or lifecycle-manage Tigrcorn as an ASGI3 Python web server. It is part of Tigrcorn's split-package architecture, so it can be installed independently while remaining linked to the rest of the Tigrcorn package family on PyPI.
+
+## Import Surface
+
+~~~python
+import tigrcorn_runtime
+
+print(tigrcorn_runtime.__name__)
+~~~
+
+The package exposes its supported public surface through the <code>tigrcorn_runtime</code> namespace. The root [tigrcorn](https://pypi.org/project/tigrcorn/) package keeps compatibility shims for users who install the full server distribution.
+
+## Package Graph
+
+[tigrcorn](https://pypi.org/project/tigrcorn/) | [tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)