pz-cli 5.0.0__py3-none-any.whl

pz_core/assembly/settings/host_project_overrides.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .host_runtime_endpoint import HostRuntimeEndpointResolver
+
+
+_HOST_PROJECT_ENV_FIELD_NAMES: dict[str, str] = {
+    "APP_HOST": "app_host",
+    "APP_PORT": "app_port",
+    "APP_WORKERS": "app_workers",
+    "APP_RELOAD": "app_reload",
+    "BASE_URL": "base_url",
+    "STATIC_TARGET_PATH": "static_target_path",
+    "STATIC_TARGET_OWNER": "static_target_owner",
+}
+
+def _env_string_override(env: dict[str, str], name: str) -> str | None:
+    raw = env.get(name)
+    if raw is None:
+        return None
+    value = str(raw).strip()
+    if not value:
+        return None
+    return value
+
+
+def _env_int_override(env: dict[str, str], name: str) -> int | None:
+    raw = _env_string_override(env, name)
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except Exception:
+        return None
+
+
+def _env_bool_override(env: dict[str, str], name: str) -> bool | None:
+    raw = env.get(name)
+    if raw is None:
+        return None
+    return str(raw).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def apply_host_project_env_overrides(data: dict[str, Any], env: dict[str, str]) -> None:
+    if not isinstance(data.get("project"), dict):
+        data["project"] = {}
+    project = data["project"]
+    if not isinstance(project, dict):
+        return
+
+    app_workers = _env_int_override(env, "APP_WORKERS")
+    if app_workers is not None:
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["APP_WORKERS"]] = app_workers
+
+    app_reload = _env_bool_override(env, "APP_RELOAD")
+    if app_reload is not None:
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["APP_RELOAD"]] = app_reload
+
+    resolution = HostRuntimeEndpointResolver(
+        current_base_url=project.get(_HOST_PROJECT_ENV_FIELD_NAMES["BASE_URL"], ""),
+        current_app_host=project.get(_HOST_PROJECT_ENV_FIELD_NAMES["APP_HOST"], "0.0.0.0"),
+        current_app_port=project.get(_HOST_PROJECT_ENV_FIELD_NAMES["APP_PORT"], 8000),
+        explicit_base_url=_env_string_override(env, "BASE_URL") or "",
+        explicit_app_host=_env_string_override(env, "APP_HOST") or "",
+        explicit_app_port=env.get("APP_PORT", ""),
+    ).resolve()
+    if resolution is not None:
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["APP_HOST"]] = resolution.app_host
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["APP_PORT"]] = resolution.app_port
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["BASE_URL"]] = resolution.settings_base_url
+
+    static_target_path = _env_string_override(env, "STATIC_TARGET_PATH")
+    if static_target_path is not None:
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["STATIC_TARGET_PATH"]] = static_target_path
+
+    static_target_owner = _env_string_override(env, "STATIC_TARGET_OWNER")
+    if static_target_owner is not None:
+        project[_HOST_PROJECT_ENV_FIELD_NAMES["STATIC_TARGET_OWNER"]] = static_target_owner
+
+
+__all__ = ["HostRuntimeEndpointResolver", "apply_host_project_env_overrides"]

pz_core/assembly/settings/host_runtime_endpoint.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from ipaddress import ip_address
+from urllib.parse import urlparse, urlunparse
+
+
+_BIND_ALL_HOSTS = frozenset({"0.0.0.0", "::"})
+_LOCAL_HOSTS = frozenset({"127.0.0.1", "localhost", "0.0.0.0", "::", "::1"})
+
+
+@dataclass(frozen=True, slots=True)
+class HostRuntimeEndpoint:
+    host: str
+    port: int
+    scheme: str = "http"
+    path: str = ""
+    port_was_explicit: bool = True
+
+    @classmethod
+    def from_host_port(cls, *, host: object, port: object, scheme: object = "http") -> "HostRuntimeEndpoint | None":
+        resolved_port = _clean_port(port)
+        if resolved_port is None:
+            return None
+        resolved_host = _clean_host(host) or "0.0.0.0"
+        resolved_scheme = str(scheme or "").strip() or "http"
+        return cls(host=resolved_host, port=resolved_port, scheme=resolved_scheme, port_was_explicit=True)
+
+    @classmethod
+    def from_base_url(cls, value: object) -> "HostRuntimeEndpoint | None":
+        text = str(value or "").strip()
+        if not text:
+            return None
+        parsed = urlparse(text if "://" in text else f"http://{text}")
+        host = str(parsed.hostname or "").strip()
+        if not host:
+            return None
+        port_was_explicit = ":" in parsed.netloc.rsplit("@", 1)[-1]
+        port = parsed.port
+        if port is None:
+            port = 443 if parsed.scheme == "https" else 80
+        path = parsed.path if parsed.path and parsed.path != "/" else ""
+        return cls(
+            host=host,
+            port=int(port),
+            scheme=parsed.scheme or "http",
+            path=path,
+            port_was_explicit=port_was_explicit,
+        )
+
+    @property
+    def connect_host(self) -> str:
+        normalized = self.host.strip()
+        if not normalized or normalized in _BIND_ALL_HOSTS:
+            return "127.0.0.1"
+        return normalized
+
+    @property
+    def base_url(self) -> str:
+        return self._url_for_host(self.host)
+
+    @property
+    def connect_base_url(self) -> str:
+        return self._url_for_host(self.connect_host)
+
+    @property
+    def allows_runtime_base_url_override(self) -> bool:
+        return _is_runtime_overridable_host(self.host)
+
+    def with_host(self, host: object) -> "HostRuntimeEndpoint":
+        resolved_host = _clean_host(host)
+        if not resolved_host:
+            return self
+        return HostRuntimeEndpoint(
+            host=resolved_host,
+            port=self.port,
+            scheme=self.scheme,
+            path=self.path,
+            port_was_explicit=self.port_was_explicit,
+        )
+
+    def with_port(self, port: object) -> "HostRuntimeEndpoint":
+        resolved_port = _clean_port(port)
+        if resolved_port is None:
+            return self
+        return HostRuntimeEndpoint(
+            host=self.host,
+            port=resolved_port,
+            scheme=self.scheme,
+            path=self.path,
+            port_was_explicit=True,
+        )
+
+    def _url_for_host(self, host: str) -> str:
+        resolved_host = str(host or "").strip()
+        if ":" in resolved_host and not resolved_host.startswith("["):
+            resolved_host = f"[{resolved_host}]"
+        netloc = resolved_host
+        if self.port_was_explicit or int(self.port) not in {80, 443}:
+            netloc = f"{resolved_host}:{int(self.port)}"
+        return urlunparse((self.scheme, netloc, self.path, "", "", "")).rstrip("/")
+
+
+@dataclass(frozen=True, slots=True)
+class HostRuntimeEndpointResolution:
+    endpoint: HostRuntimeEndpoint
+    app_host: str
+    app_port: int
+    settings_base_url: str
+
+    @property
+    def connect_base_url(self) -> str:
+        return self.endpoint.connect_base_url
+
+    def env(self, *, reload_enabled: bool, workers: int) -> dict[str, str]:
+        return {
+            "APP_HOST": str(self.app_host),
+            "APP_PORT": str(int(self.app_port)),
+            "APP_RELOAD": "true" if bool(reload_enabled) else "false",
+            "APP_WORKERS": str(int(workers)),
+            "BASE_URL": self.connect_base_url,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class HostRuntimeEndpointResolver:
+    current_base_url: object = ""
+    current_app_host: object = "0.0.0.0"
+    current_app_port: object = 8000
+    explicit_base_url: object = ""
+    explicit_app_host: object = ""
+    explicit_app_port: object = ""
+
+    def resolve(self) -> HostRuntimeEndpointResolution | None:
+        endpoint = HostRuntimeEndpoint.from_base_url(self.explicit_base_url) or HostRuntimeEndpoint.from_base_url(
+            self.current_base_url
+        )
+        explicit_host = _clean_host(self.explicit_app_host)
+        explicit_port = _clean_port(self.explicit_app_port)
+
+        if endpoint is None:
+            endpoint = HostRuntimeEndpoint.from_host_port(
+                host=explicit_host or self.current_app_host,
+                port=explicit_port or self.current_app_port,
+            )
+            if endpoint is None:
+                return None
+            return HostRuntimeEndpointResolution(
+                endpoint=endpoint,
+                app_host=endpoint.host,
+                app_port=endpoint.port,
+                settings_base_url=endpoint.connect_base_url,
+            )
+
+        endpoint_for_settings = endpoint
+        if endpoint.allows_runtime_base_url_override:
+            if explicit_host:
+                endpoint_for_settings = endpoint_for_settings.with_host(explicit_host)
+            if explicit_port is not None:
+                endpoint_for_settings = endpoint_for_settings.with_port(explicit_port)
+
+        app_host = explicit_host or endpoint_for_settings.host
+        app_port = int(explicit_port or endpoint_for_settings.port)
+        settings_base_url = (
+            endpoint_for_settings.connect_base_url
+            if endpoint_for_settings.allows_runtime_base_url_override
+            else endpoint_for_settings.base_url
+        )
+        return HostRuntimeEndpointResolution(
+            endpoint=endpoint_for_settings,
+            app_host=app_host,
+            app_port=app_port,
+            settings_base_url=settings_base_url,
+        )
+
+
+def _clean_host(value: object) -> str:
+    return str(value or "").strip().strip("[]")
+
+
+def _clean_port(value: object) -> int | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        port = int(text)
+    except (TypeError, ValueError):
+        return None
+    if port <= 0:
+        return None
+    return port
+
+
+def _is_runtime_overridable_host(host: object) -> bool:
+    normalized = _clean_host(host).lower()
+    if normalized in _LOCAL_HOSTS:
+        return True
+    try:
+        ip_address(normalized)
+    except ValueError:
+        return False
+    return True
+
+
+__all__ = ["HostRuntimeEndpoint", "HostRuntimeEndpointResolution", "HostRuntimeEndpointResolver"]

pz_core/authoring/__init__.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+from .project_defaults import (
+    PROJECT_DEFAULT_JSONC_NAME,
+    load_project_default_jsonc_payload,
+    project_default_jsonc_path,
+)
+from .project_settings_cli import (
+    init_settings_main,
+    refresh_agents_main,
+    reset_agents_main,
+    update_settings_main,
+)
+from .project_settings_checks import build_settings_update_check_items
+from .project_settings_service import inspect_settings_update_drift
+
+
+_CLI_EXPORTS = frozenset(
+    {
+        "app_add_main",
+        "app_rm_main",
+        "app_update_main",
+        "dev_add_main",
+        "dev_branch_main",
+        "dev_link_main",
+        "dev_rm_main",
+        "dev_source_main",
+        "dev_unlink_main",
+        "dev_update_main",
+        "main",
+        "publish_main",
+        "publish_batch_main",
+        "publish_commit_main",
+        "publish_rm_main",
+        "publish_tag_main",
+        "publish_upload_main",
+        "startapp_main",
+    }
+)
+
+
+def __getattr__(name: str) -> Any:
+    if name not in _CLI_EXPORTS:
+        raise AttributeError(name)
+    return getattr(import_module(".cli", __name__), name)
+
+
+__all__ = [
+    "PROJECT_DEFAULT_JSONC_NAME",
+    "app_add_main",
+    "app_rm_main",
+    "app_update_main",
+    "build_settings_update_check_items",
+    "dev_add_main",
+    "dev_branch_main",
+    "dev_link_main",
+    "dev_rm_main",
+    "dev_source_main",
+    "dev_unlink_main",
+    "dev_update_main",
+    "init_settings_main",
+    "inspect_settings_update_drift",
+    "load_project_default_jsonc_payload",
+    "main",
+    "publish_main",
+    "publish_batch_main",
+    "publish_commit_main",
+    "publish_rm_main",
+    "publish_tag_main",
+    "publish_upload_main",
+    "project_default_jsonc_path",
+    "refresh_agents_main",
+    "reset_agents_main",
+    "startapp_main",
+    "update_settings_main",
+]