tigrcorn-config 0.3.16.dev12__tar.gz → 0.3.17.dev1__tar.gz

{tigrcorn_config-0.3.16.dev12 → tigrcorn_config-0.3.17.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrcorn-config
-Version: 0.3.16.dev12
+Version: 0.3.17.dev1
 Summary: Typed configuration models, profiles, environment loading, and validation for the Tigrcorn ASGI/HTTP server stack.
 Author-email: Jacob Stewart <jacob@swarmauri.com>
 License: Apache License
@@ -186,7 +186,7 @@ Classifier: Typing :: Typed
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: tigrcorn-core==0.3.16.dev12
+Requires-Dist: tigrcorn-core==0.3.17.dev1
 Provides-Extra: yaml
 Requires-Dist: PyYAML>=6.0; extra == "yaml"
 Dynamic: license-file

{tigrcorn_config-0.3.16.dev12 → tigrcorn_config-0.3.17.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tigrcorn-config"
-version = "0.3.16.dev12"
+version = "0.3.17.dev1"
 description = "Typed configuration models, profiles, environment loading, and validation for the Tigrcorn ASGI/HTTP server stack."
 readme = "README.md"
 requires-python = ">=3.10,<3.15"
@@ -28,7 +28,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Typing :: Typed",
 ]
-dependencies = ["tigrcorn-core==0.3.16.dev12"]
+dependencies = ["tigrcorn-core==0.3.17.dev1"]
 
 [project.optional-dependencies]
 yaml = ["PyYAML>=6.0"]

{tigrcorn_config-0.3.16.dev12 → tigrcorn_config-0.3.17.dev1}/src/tigrcorn_config/governance_surface.py

@@ -223,8 +223,11 @@ APPROVED_LEGACY_UNITTEST_FILES = (
     'tests/test_stream_probe_fixtures.py',
     'tests/test_websocket_uix_demo.py',
     'tests/test_webtransport_bidi_stream_context.py',
+    'tests/test_webtransport_feature_demo_app.py',
     'tests/test_webtransport_feature_coverage.py',
     'tests/test_webtransport_mtls_demo.py',
+    'tests/test_webtransport_mtls_demo_cleanup.py',
+    'tests/test_webtransport_mtls_demo_runtime.py',
     'tests/test_webtransport_operator_surface.py',
     'tests/test_aioquic_performance_matrix.py',
     'tests/test_ws_wss_probe_fixture.py',

tigrcorn_config-0.3.17.dev1/src/tigrcorn_config/load/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from .mapping import config_from_mapping, config_from_source, config_to_dict
+from .namespace import namespace_to_overrides
+from .public_api import build_config
+from .sources import build_config_from_namespace, build_config_from_sources
+
+__all__ = [
+    "build_config",
+    "build_config_from_namespace",
+    "build_config_from_sources",
+    "config_from_mapping",
+    "config_from_source",
+    "config_to_dict",
+    "namespace_to_overrides",
+]

tigrcorn_config-0.3.17.dev1/src/tigrcorn_config/load/helpers.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+
+def listify(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        result: list[Any] = []
+        for item in value:
+            if isinstance(item, str) and "," in item:
+                result.extend(part.strip() for part in item.split(",") if part.strip())
+            else:
+                result.append(item)
+        return result
+    if isinstance(value, str):
+        return [part.strip() for part in value.split(",") if part.strip()]
+    return [value]
+
+
+def mapping_get(source: Mapping[str, Any], *path: str) -> Any:
+    cursor: Any = source
+    for segment in path:
+        if not isinstance(cursor, Mapping):
+            return None
+        cursor = cursor.get(segment)
+    return cursor

tigrcorn_config-0.3.17.dev1/src/tigrcorn_config/load/listeners.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from argparse import Namespace
+from typing import Any
+
+from tigrcorn_core.constants import DEFAULT_HOST, DEFAULT_PORT
+
+from .helpers import listify
+
+
+def parse_bind(value: str, *, kind: str) -> dict[str, Any]:
+    if value.startswith("fd://"):
+        return {"kind": kind, "fd": int(value.removeprefix("fd://"))}
+    if value.startswith("unix:"):
+        return {"kind": "unix", "path": value.split(":", 1)[1]}
+    if value.startswith("udp://"):
+        kind = "udp"
+        value = value.removeprefix("udp://")
+    elif value.startswith("tcp://"):
+        kind = "tcp"
+        value = value.removeprefix("tcp://")
+    elif value.startswith("quic://"):
+        kind = "udp"
+        value = value.removeprefix("quic://")
+    if value.startswith("[") and "]:" in value:
+        host, port = value.rsplit(":", 1)
+        host = host[1:-1]
+    elif ":" in value:
+        host, port = value.rsplit(":", 1)
+    else:
+        host, port = DEFAULT_HOST, value
+    return {"kind": kind, "host": host, "port": int(port)}
+
+
+def listener_overrides_from_namespace(ns: Namespace) -> list[dict[str, Any]] | None:
+    listeners: list[dict[str, Any]] = []
+    for item in list(ns.bind or []):
+        listeners.append(parse_bind(item, kind="tcp"))
+    for item in list(ns.quic_bind or []):
+        listener = parse_bind(item, kind="udp")
+        listener["quic_bind"] = item
+        listeners.append(listener)
+    for item in list(ns.insecure_bind or []):
+        listener = parse_bind(item, kind="tcp")
+        listener["insecure_bind"] = item
+        listeners.append(listener)
+    for item in list(ns.fd or []):
+        listeners.append({"kind": ns.transport or "tcp", "fd": int(item)})
+    for item in list(ns.endpoint or []):
+        listeners.append({"kind": ns.transport or "tcp", "endpoint": item})
+
+    if not listeners:
+        if ns.uds:
+            kind = "pipe" if ns.transport == "pipe" else "unix"
+            listeners.append({"kind": kind, "path": ns.uds})
+        else:
+            listeners.append({"kind": ns.transport or "tcp", "host": ns.host or DEFAULT_HOST, "port": ns.port or DEFAULT_PORT})
+
+    for listener in listeners:
+        _apply_common_listener_fields(ns, listener)
+    return listeners
+
+
+def _apply_common_listener_fields(ns: Namespace, listener: dict[str, Any]) -> None:
+    for attr in ("backlog", "reuse_port", "reuse_address"):
+        value = getattr(ns, attr, None)
+        if value is not None:
+            listener[attr] = value
+    if ns.pipe_mode is not None and listener.get("kind") == "pipe":
+        listener["pipe_mode"] = ns.pipe_mode
+    if ns.user is not None and listener.get("kind") == "unix":
+        listener["user"] = ns.user
+    if ns.group is not None and listener.get("kind") == "unix":
+        listener["group"] = ns.group
+    if ns.umask is not None and listener.get("kind") == "unix":
+        listener["umask"] = ns.umask
+    if ns.http_versions:
+        listener["http_versions"] = list(ns.http_versions)
+    if ns.protocols:
+        listener["protocols"] = list(ns.protocols)
+    if ns.disable_websocket is not None:
+        listener["websocket"] = not ns.disable_websocket
+    _apply_listener_tls_fields(ns, listener)
+    _apply_listener_quic_fields(ns, listener)
+
+
+def _apply_listener_tls_fields(ns: Namespace, listener: dict[str, Any]) -> None:
+    if listener.get("insecure_bind"):
+        return
+    mapping = {
+        "ssl_certfile": "ssl_certfile",
+        "ssl_keyfile": "ssl_keyfile",
+        "ssl_keyfile_password": "ssl_keyfile_password",
+        "ssl_ca_certs": "ssl_ca_certs",
+        "ssl_require_client_cert": "ssl_require_client_cert",
+        "ssl_ocsp_mode": "ocsp_mode",
+        "ssl_ocsp_soft_fail": "ocsp_soft_fail",
+        "ssl_ocsp_cache_size": "ocsp_cache_size",
+        "ssl_ocsp_max_age": "ocsp_max_age",
+        "ssl_crl_mode": "crl_mode",
+        "ssl_crl": "ssl_crl",
+    }
+    for source, dest in mapping.items():
+        value = getattr(ns, source, None)
+        if value is not None:
+            listener[dest] = value
+    if ns.ssl_alpn:
+        listener["alpn_protocols"] = listify(ns.ssl_alpn)
+    if getattr(ns, "ssl_revocation_fetch", None) is not None:
+        value = ns.ssl_revocation_fetch
+        listener["revocation_fetch"] = value == "on" if isinstance(value, str) else bool(value)
+
+
+def _apply_listener_quic_fields(ns: Namespace, listener: dict[str, Any]) -> None:
+    if listener.get("kind") != "udp":
+        return
+    if ns.quic_require_retry is not None:
+        listener["quic_require_retry"] = ns.quic_require_retry
+    if ns.quic_max_datagram_size is not None:
+        listener["max_datagram_size"] = ns.quic_max_datagram_size
+    if ns.quic_secret is not None:
+        listener["quic_secret"] = ns.quic_secret.encode("utf-8") if isinstance(ns.quic_secret, str) else ns.quic_secret

tigrcorn_config-0.3.17.dev1/src/tigrcorn_config/load/mapping.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import Any, Mapping
+
+from tigrcorn_config.defaults import default_config
+from tigrcorn_config.files import load_config_source
+from tigrcorn_config.merge import merge_config_dicts
+from tigrcorn_config.model import ListenerConfig, ServerConfig
+from tigrcorn_config.normalize import normalize_config
+from tigrcorn_config.profiles import resolve_effective_profile_mapping, resolve_requested_profile
+from tigrcorn_config.validate import validate_config
+
+
+def _dataclass_to_dict(value: Any) -> Any:
+    if dataclasses.is_dataclass(value):
+        return {field.name: _dataclass_to_dict(getattr(value, field.name)) for field in dataclasses.fields(value)}
+    if isinstance(value, list):
+        return [_dataclass_to_dict(item) for item in value]
+    if isinstance(value, tuple):
+        return [_dataclass_to_dict(item) for item in value]
+    return value
+
+
+def config_to_dict(config: ServerConfig) -> dict[str, Any]:
+    return _dataclass_to_dict(config)
+
+
+def _apply_mapping(target: Any, data: Mapping[str, Any]) -> None:
+    for key, value in data.items():
+        if not hasattr(target, key):
+            continue
+        current = getattr(target, key)
+        if isinstance(current, list) and key == "listeners" and isinstance(value, list):
+            listeners: list[ListenerConfig] = []
+            for entry in value:
+                if isinstance(entry, Mapping):
+                    listener = ListenerConfig()
+                    _apply_mapping(listener, entry)
+                    listeners.append(listener)
+            setattr(target, key, listeners)
+        elif dataclasses.is_dataclass(current) and isinstance(value, Mapping):
+            _apply_mapping(current, value)
+        else:
+            setattr(target, key, value)
+
+
+def config_from_mapping(data: Mapping[str, Any]) -> ServerConfig:
+    profile_name = resolve_requested_profile(data)
+    effective_mapping = merge_config_dicts(resolve_effective_profile_mapping(profile_name), data)
+    config = default_config()
+    _apply_mapping(config, effective_mapping)
+    normalize_config(config)
+    validate_config(config)
+    return config
+
+
+def config_from_source(source: str | Path | Mapping[str, Any] | Any | None) -> ServerConfig:
+    return config_from_mapping(load_config_source(source))

tigrcorn_config-0.3.17.dev1/src/tigrcorn_config/load/namespace.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from argparse import Namespace
+from typing import Any
+
+from .helpers import listify
+from .listeners import listener_overrides_from_namespace
+
+
+def namespace_to_overrides(ns: Namespace) -> dict[str, Any]:
+    overrides: dict[str, Any] = {}
+    blocks = {
+        "app": {},
+        "process": {},
+        "tls": {},
+        "proxy": {},
+        "http": {},
+        "websocket": {},
+        "static": {},
+        "quic": {},
+        "webtransport": {},
+        "logging": {},
+        "metrics": {},
+        "scheduler": {},
+    }
+
+    _populate_app_block(ns, blocks["app"])
+    logging_explicit_fields = _populate_mapped_blocks(ns, blocks)
+    _populate_special_blocks(ns, blocks, logging_explicit_fields)
+
+    listeners = listener_overrides_from_namespace(ns)
+    if listeners:
+        overrides["listeners"] = listeners
+    if logging_explicit_fields:
+        blocks["logging"]["explicit_fields"] = sorted(set(logging_explicit_fields))
+
+    for name, block in blocks.items():
+        if block:
+            overrides[name] = block
+    return overrides
+
+
+def _populate_app_block(ns: Namespace, app_block: dict[str, Any]) -> None:
+    if ns.app is not None:
+        app_block["target"] = ns.app
+    for key, dest in (
+        ("factory", "factory"),
+        ("app_interface", "interface"),
+        ("app_dir", "app_dir"),
+        ("lifespan", "lifespan"),
+        ("reload", "reload"),
+        ("config", "config_file"),
+        ("env_prefix", "env_prefix"),
+        ("env_file", "env_file"),
+    ):
+        value = getattr(ns, key, None)
+        if value is not None:
+            app_block[dest] = value
+    if ns.reload_dir:
+        app_block["reload_dirs"] = list(ns.reload_dir)
+    if ns.reload_include:
+        app_block["reload_include"] = list(ns.reload_include)
+    if ns.reload_exclude:
+        app_block["reload_exclude"] = list(ns.reload_exclude)
+
+
+def _populate_mapped_blocks(ns: Namespace, blocks: dict[str, dict[str, Any]]) -> list[str]:
+    logging_explicit_fields: list[str] = []
+    for key, (block_name, dest) in _NAMESPACE_MAPPING.items():
+        value = getattr(ns, key, None)
+        if value is not None:
+            block = blocks[block_name]
+            block[dest] = value
+            if block_name == "logging" and dest in _LOGGING_EXPLICIT_DESTS:
+                logging_explicit_fields.append(dest)
+    return logging_explicit_fields
+
+
+def _populate_special_blocks(
+    ns: Namespace,
+    blocks: dict[str, dict[str, Any]],
+    logging_explicit_fields: list[str],
+) -> None:
+    if ns.ssl_alpn:
+        blocks["tls"]["alpn_protocols"] = listify(ns.ssl_alpn)
+    if ns.log_config is not None:
+        logging_explicit_fields.append("log_config")
+    if getattr(ns, "ssl_revocation_fetch", None) is not None:
+        value = ns.ssl_revocation_fetch
+        blocks["tls"]["revocation_fetch"] = value == "on" if isinstance(value, str) else bool(value)
+    if ns.forwarded_allow_ips:
+        blocks["proxy"]["forwarded_allow_ips"] = listify(ns.forwarded_allow_ips)
+    if ns.server_header is not None:
+        blocks["proxy"]["server_header"] = ns.server_header
+        blocks["proxy"]["include_server_header"] = True
+    if ns.no_server_header:
+        blocks["proxy"]["include_server_header"] = False
+        blocks["proxy"]["server_header"] = ""
+    if ns.date_header is not None:
+        blocks["proxy"]["include_date_header"] = ns.date_header
+    if ns.headers:
+        blocks["proxy"]["default_headers"] = list(ns.headers)
+    if ns.server_name:
+        blocks["proxy"]["server_names"] = listify(ns.server_name)
+    if ns.http_versions:
+        blocks["http"]["http_versions"] = list(ns.http_versions)
+    if getattr(ns, "alt_svc", None):
+        blocks["http"]["alt_svc_headers"] = listify(ns.alt_svc)
+    if ns.content_codings:
+        blocks["http"]["content_codings"] = listify(ns.content_codings)
+    if getattr(ns, "connect_allow", None):
+        blocks["http"]["connect_allow"] = listify(ns.connect_allow)
+    if ns.disable_h2c is not None:
+        blocks["http"]["enable_h2c"] = not ns.disable_h2c
+    if ns.disable_websocket is not None:
+        blocks["websocket"]["enabled"] = not ns.disable_websocket
+    if ns.quic_secret is not None:
+        blocks["quic"]["quic_secret"] = ns.quic_secret.encode("utf-8") if isinstance(ns.quic_secret, str) else ns.quic_secret
+    if getattr(ns, "webtransport_origin", None):
+        blocks["webtransport"]["origins"] = listify(ns.webtransport_origin)
+
+
+_LOGGING_EXPLICIT_DESTS = {
+    "level",
+    "access_log",
+    "access_log_file",
+    "access_log_format",
+    "error_log_file",
+    "structured",
+    "use_colors",
+    "log_config",
+}
+
+_NAMESPACE_MAPPING: dict[str, tuple[str, str]] = {
+    "workers": ("process", "workers"),
+    "worker_class": ("process", "worker_class"),
+    "runtime": ("process", "runtime"),
+    "pid": ("process", "pid_file"),
+    "worker_healthcheck_timeout": ("process", "worker_healthcheck_timeout"),
+    "limit_max_requests": ("process", "limit_max_requests"),
+    "max_requests_jitter": ("process", "max_requests_jitter"),
+    "ssl_certfile": ("tls", "certfile"),
+    "ssl_keyfile": ("tls", "keyfile"),
+    "ssl_keyfile_password": ("tls", "keyfile_password"),
+    "ssl_ca_certs": ("tls", "ca_certs"),
+    "ssl_require_client_cert": ("tls", "require_client_cert"),
+    "ssl_ciphers": ("tls", "ciphers"),
+    "ssl_ocsp_mode": ("tls", "ocsp_mode"),
+    "ssl_ocsp_soft_fail": ("tls", "ocsp_soft_fail"),
+    "ssl_ocsp_cache_size": ("tls", "ocsp_cache_size"),
+    "ssl_ocsp_max_age": ("tls", "ocsp_max_age"),
+    "ssl_crl_mode": ("tls", "crl_mode"),
+    "ssl_crl": ("tls", "crl"),
+    "proxy_headers": ("proxy", "proxy_headers"),
+    "root_path": ("proxy", "root_path"),
+    "timeout_keep_alive": ("http", "keep_alive_timeout"),
+    "read_timeout": ("http", "read_timeout"),
+    "write_timeout": ("http", "write_timeout"),
+    "timeout_graceful_shutdown": ("http", "shutdown_timeout"),
+    "idle_timeout": ("http", "idle_timeout"),
+    "max_body_size": ("http", "max_body_size"),
+    "max_header_size": ("http", "max_header_size"),
+    "http1_max_incomplete_event_size": ("http", "http1_max_incomplete_event_size"),
+    "http1_buffer_size": ("http", "http1_buffer_size"),
+    "http1_header_read_timeout": ("http", "http1_header_read_timeout"),
+    "http1_keep_alive": ("http", "http1_keep_alive"),
+    "http2_max_concurrent_streams": ("http", "http2_max_concurrent_streams"),
+    "http2_max_headers_size": ("http", "http2_max_headers_size"),
+    "http2_max_frame_size": ("http", "http2_max_frame_size"),
+    "http2_adaptive_window": ("http", "http2_adaptive_window"),
+    "http2_initial_connection_window_size": ("http", "http2_initial_connection_window_size"),
+    "http2_initial_stream_window_size": ("http", "http2_initial_stream_window_size"),
+    "http2_keep_alive_interval": ("http", "http2_keep_alive_interval"),
+    "http2_keep_alive_timeout": ("http", "http2_keep_alive_timeout"),
+    "connect_policy": ("http", "connect_policy"),
+    "trailer_policy": ("http", "trailer_policy"),
+    "content_coding_policy": ("http", "content_coding_policy"),
+    "alt_svc_auto": ("http", "alt_svc_auto"),
+    "alt_svc_ma": ("http", "alt_svc_max_age"),
+    "alt_svc_persist": ("http", "alt_svc_persist"),
+    "websocket_max_message_size": ("websocket", "max_message_size"),
+    "websocket_max_queue": ("websocket", "max_queue"),
+    "websocket_ping_interval": ("websocket", "ping_interval"),
+    "websocket_ping_timeout": ("websocket", "ping_timeout"),
+    "websocket_compression": ("websocket", "compression"),
+    "static_path_route": ("static", "route"),
+    "static_path_mount": ("static", "mount"),
+    "static_path_dir_to_file": ("static", "dir_to_file"),
+    "static_path_index_file": ("static", "index_file"),
+    "static_path_expires": ("static", "expires"),
+    "quic_require_retry": ("quic", "require_retry"),
+    "quic_max_datagram_size": ("quic", "max_datagram_size"),
+    "quic_idle_timeout": ("quic", "idle_timeout"),
+    "quic_early_data_policy": ("quic", "early_data_policy"),
+    "webtransport_max_sessions": ("webtransport", "max_sessions"),
+    "webtransport_max_streams": ("webtransport", "max_streams"),
+    "webtransport_max_datagram_size": ("webtransport", "max_datagram_size"),
+    "webtransport_path": ("webtransport", "path"),
+    "log_level": ("logging", "level"),
+    "access_log": ("logging", "access_log"),
+    "access_log_file": ("logging", "access_log_file"),
+    "access_log_format": ("logging", "access_log_format"),
+    "error_log_file": ("logging", "error_log_file"),
+    "log_config": ("logging", "log_config"),
+    "structured_log": ("logging", "structured"),
+    "use_colors": ("logging", "use_colors"),
+    "metrics": ("metrics", "enabled"),
+    "metrics_bind": ("metrics", "bind"),
+    "statsd_host": ("metrics", "statsd_host"),
+    "otel_endpoint": ("metrics", "otel_endpoint"),
+    "limit_concurrency": ("scheduler", "limit_concurrency"),
+    "max_connections": ("scheduler", "max_connections"),
+    "max_tasks": ("scheduler", "max_tasks"),
+    "max_streams": ("scheduler", "max_streams"),
+}