pz-cli 5.0.0__py3-none-any.whl

pz_core/authoring/templates/shared/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .text import dedent
+
+__all__ = ["dedent"]

pz_core/authoring/templates/shared/text.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import textwrap
+
+
+def dedent(text: str) -> str:
+    return textwrap.dedent(text)
+
+
+__all__ = ["dedent"]

pz_core/authoring/venv_service.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from pz_core.runtime.errors import PzError
+
+
+_OWNER = "pz_core.authoring.env"
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectVirtualenvResult:
+    path: Path
+    created: bool
+
+
+def ensure_project_virtualenv(project_dir: Path, *, action: str) -> ProjectVirtualenvResult:
+    venv_path = project_dir / ".venv"
+    if _is_valid_virtualenv(venv_path):
+        return ProjectVirtualenvResult(path=venv_path.resolve(), created=False)
+    uv_binary = _require_uv_binary(action=action)
+    venv_path.parent.mkdir(parents=True, exist_ok=True)
+    completed = subprocess.run(
+        [uv_binary, "venv", str(venv_path)],
+        cwd=str(project_dir),
+        check=False,
+        capture_output=True,
+        text=True,
+        env=os.environ.copy(),
+    )
+    if completed.returncode == 0 and _is_valid_virtualenv(venv_path):
+        return ProjectVirtualenvResult(path=venv_path.resolve(), created=True)
+    detail = (completed.stderr or completed.stdout or "failed to create virtual environment").strip()
+    raise PzError(
+        code="PZ_ENV_PROJECT_VENV_FAILED",
+        message=f"failed to prepare project virtual environment for {project_dir}.",
+        stage="cli",
+        owner=_OWNER,
+        action=action,
+        detail=detail,
+    )
+
+
+def resolve_virtualenv_python(venv_path: Path, *, action: str) -> Path:
+    for candidate in (
+        venv_path / "bin" / "python",
+        venv_path / "bin" / "python3",
+        venv_path / "Scripts" / "python.exe",
+    ):
+        if candidate.is_file():
+            return candidate.absolute()
+    raise PzError(
+        code="PZ_ENV_PROJECT_VENV_INVALID",
+        message=f"virtual environment is missing a Python executable: {venv_path}",
+        stage="cli",
+        owner=_OWNER,
+        action=action,
+    )
+
+
+def _require_uv_binary(*, action: str) -> str:
+    uv_binary = shutil.which("uv")
+    if uv_binary:
+        return uv_binary
+    raise PzError(
+        code="PZ_ENV_UV_MISSING",
+        message="required dependency backend was not found on PATH.",
+        stage="cli",
+        owner=_OWNER,
+        action=action,
+    )
+
+
+def _is_valid_virtualenv(path: Path) -> bool:
+    candidates = (
+        path / "bin" / "python",
+        path / "bin" / "python3",
+        path / "Scripts" / "python.exe",
+    )
+    return any(candidate.is_file() for candidate in candidates)
+
+
+__all__ = ["ProjectVirtualenvResult", "ensure_project_virtualenv", "resolve_virtualenv_python"]

pz_core/authoring/workspace.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import tomllib
+
+
+@dataclass(frozen=True, slots=True)
+class WorkspacePackage:
+    key: str
+    dist: str
+    repo: Path
+
+    @property
+    def app_id(self) -> str:
+        return self.dist.replace("-", "_")
+
+
+def _read_pyproject_payload(pyproject_path: Path) -> dict[str, object] | None:
+    if not pyproject_path.is_file():
+        return None
+    try:
+        payload = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _read_project_name(pyproject_path: Path) -> str | None:
+    payload = _read_pyproject_payload(pyproject_path)
+    if payload is None:
+        return None
+    project = payload.get("project")
+    if not isinstance(project, dict):
+        return None
+    name = project.get("name")
+    if not isinstance(name, str) or not name.strip():
+        return None
+    return name.strip()
+
+
+def candidate_workspace_projects(*, anchors: tuple[Path, ...] = ()) -> tuple[Path, ...]:
+    candidates: list[Path] = []
+    seen: set[Path] = set()
+    resolved_anchors = anchors or (Path.cwd(), Path(__file__).resolve())
+    for anchor in resolved_anchors:
+        current = anchor if anchor.is_dir() else anchor.parent
+        for parent in (current, *current.parents):
+            pyproject_path = (parent / "pyproject.toml").resolve()
+            if pyproject_path in seen or not pyproject_path.is_file():
+                continue
+            seen.add(pyproject_path)
+            candidates.append(pyproject_path.parent)
+    return tuple(candidates)
+
+
+def _iter_workspace_packages_from_projects(
+    project_roots: tuple[Path, ...],
+) -> tuple[WorkspacePackage, ...]:
+    packages: list[WorkspacePackage] = []
+    seen_keys: set[str] = set()
+    seen_roots: set[Path] = set()
+
+    def _append_package(dist: str, repo: Path, *, key: str | None = None) -> None:
+        normalized_dist = dist.strip()
+        normalized_key = (key or normalized_dist).strip()
+        if not normalized_dist or not normalized_key:
+            return
+        dedupe_key = normalized_key.lower()
+        resolved_repo = repo.expanduser().resolve()
+        if dedupe_key in seen_keys:
+            return
+        seen_keys.add(dedupe_key)
+        packages.append(
+            WorkspacePackage(
+                key=normalized_key,
+                dist=normalized_dist,
+                repo=resolved_repo,
+            )
+        )
+
+    def _append_ancestor_workspace_roots(repo: Path, *, project_root: Path) -> None:
+        resolved_repo = repo.expanduser().resolve()
+        resolved_project_root = project_root.resolve()
+        for ancestor in resolved_repo.parents:
+            if ancestor == resolved_project_root:
+                break
+            if ancestor in seen_roots:
+                continue
+            dist = _read_project_name(ancestor / "pyproject.toml")
+            if dist is None:
+                continue
+            seen_roots.add(ancestor)
+            _append_package(dist, ancestor)
+
+    for project_root in project_roots:
+        project_root = project_root.expanduser().resolve()
+        pyproject_path = project_root / "pyproject.toml"
+        payload = _read_pyproject_payload(pyproject_path)
+        if payload is None:
+            continue
+        project_name = _read_project_name(pyproject_path)
+        if project_name is not None:
+            _append_package(project_name, project_root)
+        tool = payload.get("tool")
+        if not isinstance(tool, dict):
+            continue
+        uv = tool.get("uv")
+        if not isinstance(uv, dict):
+            continue
+        sources = uv.get("sources")
+        if not isinstance(sources, dict):
+            continue
+        for dist, raw_meta in sources.items():
+            if not isinstance(dist, str) or not isinstance(raw_meta, dict):
+                continue
+            raw_path = raw_meta.get("path")
+            if not isinstance(raw_path, str) or not raw_path.strip():
+                continue
+            repo = Path(raw_path.strip()).expanduser()
+            if not repo.is_absolute():
+                repo = (project_root / repo).resolve()
+            _append_package(dist, repo)
+            _append_ancestor_workspace_roots(repo, project_root=project_root)
+    return tuple(packages)
+
+
+def iter_workspace_packages(*, anchors: tuple[Path, ...] = ()) -> tuple[WorkspacePackage, ...]:
+    return _iter_workspace_packages_from_projects(
+        candidate_workspace_projects(anchors=anchors)
+    )
+
+
+def iter_workspace_packages_in_roots(
+    project_roots: tuple[Path, ...],
+) -> tuple[WorkspacePackage, ...]:
+    """Discover packages without walking outside the caller-provided roots."""
+    return _iter_workspace_packages_from_projects(project_roots)
+
+
+def resolve_workspace_package(
+    identifier: str,
+    *,
+    anchors: tuple[Path, ...] = (),
+) -> WorkspacePackage | None:
+    normalized = identifier.strip().lower()
+    if not normalized:
+        return None
+    for package in iter_workspace_packages(anchors=anchors):
+        candidates = {
+            package.key.lower(),
+            package.dist.lower(),
+            package.app_id.lower(),
+            package.repo.name.lower(),
+        }
+        if normalized in candidates:
+            return package
+    return None
+
+
+__all__ = [
+    "WorkspacePackage",
+    "candidate_workspace_projects",
+    "iter_workspace_packages",
+    "iter_workspace_packages_in_roots",
+    "resolve_workspace_package",
+]

pz_core/cli.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from pz_core.project_root_commands import discover_project_root_command_handlers, render_project_root_command_help
+from pz_core.authoring.root_cli import get_root_command_handlers as _builtin_root_command_handlers
+from pz_core.cli_options import option_shortcuts_help, resolve_program_name
+from pz_core.root_cli import CommandPath, RootCommandHandler, discover_root_command_handlers
+from pz_core.project_runtime_cli import handoff_to_project_runtime, provider_resolution_locked, resolve_cli_project_dir
+from pz_core.runtime.cli.main import main as _core_main
+from pz_core.runtime.environment_integrity import validate_current_environment
+from pz_core.runtime.errors import PzError
+
+
+def _is_help(value: str | None) -> bool:
+    return isinstance(value, str) and value.strip().lower() in {"-h", "--help", "help"}
+
+
+def _is_root_help_request(argv: Sequence[str] | None = None) -> bool:
+    args = [str(item).strip() for item in list(argv or sys.argv[1:]) if str(item).strip()]
+    if not args or _is_help(args[0]):
+        return True
+    saw_help = False
+    index = 0
+    while index < len(args):
+        item = args[index]
+        if _is_help(item):
+            saw_help = True
+            index += 1
+            continue
+        if item in {"--project-dir", "-d"}:
+            index += 2
+            continue
+        if item.startswith("--project-dir="):
+            index += 1
+            continue
+        if item.startswith("-d="):
+            index += 1
+            continue
+        return False
+    return saw_help
+
+
+def _should_handoff_to_project_runtime(argv: Sequence[str] | None = None) -> bool:
+    args = [str(item).strip().lower() for item in list(argv or sys.argv[1:]) if str(item).strip()]
+    if not args:
+        return False
+    if _is_root_help_request(args):
+        return False
+    if tuple(args[:2]) in {("init", "settings"), ("update", "settings")}:
+        return False
+    if args[0] == "init":
+        return False
+    if args[0] in {"env", "settings", "startapp", "app", "dev", "pub", "publish", "pullapp"}:
+        return False
+    return True
+
+
+def _resolve_program_name(argv0: str | None = None) -> str:
+    return resolve_program_name(argv0)
+
+
+def _usage(program_name: str, argv: Sequence[str] | None = None) -> str:
+    extension_help = _render_project_root_command_help(argv)
+    return f"""{program_name} CLI
+
+What You Usually Do:
+  1. {program_name} dev init
+     Create the project scaffold, import every official pz_apps leaf into business ownership, update settings, and install dependencies.
+  2. {program_name} env doctor
+     Check whether local authoring prerequisites such as the dependency backend and `git` are ready.
+  3. {program_name} run
+     Start the formal project host through the root `main.py` entrypoint.
+  4. {program_name} app init
+     Reconcile the typed source plan and install its exact released app versions.
+  5. {program_name} app add <app_id>
+     Install a released package into the current runtime and declare it in the project.
+  6. {program_name} dev add <app-or-source>
+     Import one minimal app into `apps/<app_id>` without nested Git metadata.
+  7. {program_name} dev link <repo-or-app>
+     Keep a Git checkout under `apps/.sources` and expose it through a binding.
+  8. {program_name} dev branch <repo-or-app>
+     Put a managed checkout on the project's business branch from `develop` by default.
+  9. {program_name} pub <app_id>
+     Commit, tag, build, and publish one versioned package.
+  10. {program_name} pub rm <app_id>
+     Remove one published package from the selected target.
+  11. {program_name} pub batch <app_id> [<app_id> ...]
+     Publish several packages in the exact order you give.
+
+Usage:
+  {program_name} --help
+  {program_name} env doctor [--json] [--project-dir PATH]
+  {program_name} env install [--json] [--project-dir PATH] [--group NAME] [--extra NAME] [--reinstall-package NAME] [--project-only]
+  {program_name} env init [--json] [--no-sync] [--project-dir PATH]
+  {program_name} env sync [--json] [--project-dir PATH] [--group NAME] [--extra NAME] [--reinstall-package NAME] [--project-only]
+  {program_name} settings init [--force] [--json] [--project-dir PATH]
+  {program_name} settings update [<target>] [--json] [--reset-middlewares-order] [--project-dir PATH]
+  {program_name} settings refresh-agents [--json] [--project-dir PATH]
+  {program_name} settings reset-agents [--json] [--project-dir PATH]
+  {program_name} run [develop|dev|test|product] [--project-dir PATH]
+  {program_name} startapp <name> [--json] [--target-dir PATH] [--project-dir PATH]
+  {program_name} app init [--json] [--no-sync] [--project-dir PATH]
+  {program_name} app add <app_id> [--json] [--version VERSION] [--project-dir PATH]
+  {program_name} app rm <app_id> [--json] [--project-dir PATH]
+  {program_name} app update <app_id> [--json] [--version VERSION] [--project-dir PATH]
+  {program_name} app versions <app_id> [--json] [--project-dir PATH]
+  {program_name} app declare <app_id> --version VERSION [--json] [--project-dir PATH]
+  {program_name} app undeclare <app_id> [--json] [--project-dir PATH]
+  {program_name} app install <app_id> --version VERSION [--json] [--project-dir PATH]
+  {program_name} dev init [--json] [--app-name NAME] [--no-sync] [--project-dir PATH]
+  {program_name} dev init --link (--clone-sources | --source-dir PATH) [--json] [--app-name NAME] [--base-branch develop|main] [--no-sync] [--project-dir PATH]
+  {program_name} dev add <app-or-source> [--json] [--branch NAME] [--project-dir PATH]
+  {program_name} dev link <repo-or-app> [--json] [--base-branch develop|main] [--project-dir PATH]
+  {program_name} dev branch <repo-or-app> [--json] [--base-branch develop|main] [--project-dir PATH]
+  {program_name} dev update <repo-or-app> [--json] [--project-dir PATH]
+  {program_name} dev unlink <binding> [--json] [--delete-checkout] [--project-dir PATH]
+  {program_name} dev source cache|import|link|branch|update|unlink ... [--json] [--project-dir PATH]
+  {program_name} dev ide sync [--json] [--project-dir PATH]
+  {program_name} pub <app_id> [--json] [--target NAME] [--dry-run] [--project-dir PATH]
+  {program_name} pub commit <app_id> [--json] [--project-dir PATH]
+  {program_name} pub tag <app_id> [--json] [--project-dir PATH]
+  {program_name} pub upload <app_id> [--json] [--version VERSION] [--target NAME] [--dry-run] [--project-dir PATH]
+  {program_name} pub rm <app_id> [--json] [--target NAME] [--dry-run] [--force] [--project-dir PATH]
+  {program_name} pub batch <app_id> [<app_id> ...] [--json] [--target NAME] [--dry-run] [--project-dir PATH]
+  {program_name} list [--json] [--project-dir PATH]
+  {program_name} check [--json] [--project-dir PATH]
+  {program_name} db <makemigrations|migrate|showmigrations> [--json] [--project-dir PATH]
+  {program_name} workers <list|status|stop|restart|run> [--project-dir PATH]
+  {program_name} resources images [--force] [--json] [--project-dir PATH]
+  {program_name} <app_id> <tool> [--project-dir PATH]
+
+{option_shortcuts_help()}
+
+Orchestration Commands:
+  {program_name} dev init | {program_name} dev add | {program_name} dev link | {program_name} dev branch | {program_name} dev update | {program_name} dev unlink
+  {program_name} env init | {program_name} app init | {program_name} app add | {program_name} app update | {program_name} app rm
+  {program_name} pub | {program_name} pub batch
+
+Atomic Commands:
+  {program_name} env doctor | {program_name} env install | {program_name} env sync
+  {program_name} settings init | {program_name} settings update | {program_name} settings refresh-agents | {program_name} settings reset-agents
+  {program_name} startapp | {program_name} app versions | {program_name} app declare | {program_name} app undeclare | {program_name} app install
+  {program_name} dev source cache | {program_name} dev source import | {program_name} dev source link | {program_name} dev source branch | {program_name} dev source update | {program_name} dev source unlink | {program_name} dev ide sync
+  {program_name} pub commit | {program_name} pub tag | {program_name} pub upload | {program_name} pub rm
+
+Runtime Commands:
+  {program_name} run | {program_name} list | {program_name} check | {program_name} db ...
+  {program_name} workers ... | {program_name} resources ... | {program_name} <app_id> <tool>
+
+The canonical command classification table is `docs/pz命令总览.md`.
+
+Examples:
+  {program_name} env doctor --project-dir .
+  {program_name} env install --project-dir .
+  {program_name} env init --project-dir .
+  {program_name} env sync --project-dir .
+  {program_name} settings init --project-dir .
+  {program_name} settings update --project-dir .
+  {program_name} settings refresh-agents --project-dir .
+  {program_name} settings reset-agents --project-dir .
+  {program_name} run --project-dir .
+  {program_name} run develop --project-dir .
+  {program_name} run dev --project-dir .
+  {program_name} run test --project-dir .
+  {program_name} run product --project-dir .
+  {program_name} resources images --force --project-dir .
+  {program_name} app init --project-dir .
+  {program_name} app add demo_auth --project-dir .
+  {program_name} dev init --app-name demo --project-dir .
+  {program_name} dev init --link --clone-sources --app-name demo --project-dir .
+  {program_name} dev add demo-auth --project-dir .
+  {program_name} dev link demo-auth --base-branch develop --project-dir .
+  {program_name} dev branch demo_auth --base-branch main --project-dir .
+  {program_name} dev update demo_auth --project-dir .
+  {program_name} dev unlink demo_auth --delete-checkout --project-dir .
+  {program_name} dev add ../demo_auth --project-dir .
+  {program_name} pub catalog --target devpi_dev --project-dir .
+  {program_name} pub rm catalog --target devpi_pub --force --project-dir .
+  {program_name} pub batch pz catalog --target devpi_dev --project-dir .
+{extension_help}"""
+
+
+def _has_help_flag(args: Sequence[object]) -> bool:
+    return any(_is_help(str(item)) for item in args)
+
+
+def _discover_root_command_handlers() -> dict[CommandPath, RootCommandHandler]:
+    return discover_root_command_handlers()
+
+
+def _builtin_root_handlers() -> dict[CommandPath, RootCommandHandler]:
+    return {handler.command_path: handler for handler in _builtin_root_command_handlers()}
+
+
+def _core_reserved_command_paths() -> tuple[CommandPath, ...]:
+    return (("init",), ("list",), ("check",), ("db",), ("resources",))
+
+
+def _discover_project_root_command_handlers(
+    reserved_paths: Sequence[CommandPath],
+    *,
+    argv: Sequence[str] | None = None,
+) -> dict[CommandPath, RootCommandHandler]:
+    return discover_project_root_command_handlers(
+        reserved_paths=reserved_paths,
+        project_dir=resolve_cli_project_dir(argv),
+    )
+
+
+def _render_project_root_command_help(argv: Sequence[str] | None = None) -> str:
+    reserved_paths = (*_builtin_root_handlers().keys(), *_core_reserved_command_paths())
+    try:
+        return render_project_root_command_help(
+            reserved_paths=reserved_paths,
+            project_dir=resolve_cli_project_dir(argv),
+        )
+    except Exception:
+        return ""
+
+
+def _matching_command(args: Sequence[str], command_paths: Sequence[CommandPath]) -> CommandPath | None:
+    normalized = tuple(str(item).strip().lower() for item in args[:2])
+    for command_path in sorted(command_paths, key=len, reverse=True):
+        if normalized[: len(command_path)] == command_path:
+            return command_path
+    return None
+
+
+def _dispatch_root_command(program_name: str, argv: Sequence[str]) -> int | None:
+    builtin_handlers = _builtin_root_handlers()
+    builtin_path = _matching_command(argv, tuple(builtin_handlers))
+    if builtin_path is not None:
+        return builtin_handlers[builtin_path].handler(list(argv[len(builtin_path) :]))
+    core_reserved_paths = _core_reserved_command_paths()
+    if _matching_command(argv, core_reserved_paths) is not None:
+        return None
+
+    try:
+        handlers = _discover_root_command_handlers()
+    except Exception as exc:
+        sys.stderr.write(f"{program_name} could not load external root CLI providers: {exc}\n")
+        return 1
+    command_path = _matching_command(argv, tuple(handlers))
+    if command_path is None:
+        try:
+            project_handlers = _discover_project_root_command_handlers(
+                (*builtin_handlers.keys(), *handlers.keys(), *core_reserved_paths),
+                argv=argv,
+            )
+        except Exception as exc:
+            sys.stderr.write(f"{program_name} could not load project root commands: {exc}\n")
+            return 1
+        command_path = _matching_command(argv, tuple(project_handlers))
+        if command_path is None:
+            return None
+        return project_handlers[command_path].handler(list(argv[len(command_path) :]))
+    return handlers[command_path].handler(list(argv[len(command_path) :]))
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(argv or sys.argv[1:])
+    program_name = _resolve_program_name(sys.argv[0] if sys.argv else None)
+    if _is_root_help_request(args):
+        sys.stdout.write(_usage(program_name, args))
+        return 0
+    if not _has_help_flag(args):
+        try:
+            validate_current_environment(os.environ)
+        except PzError as exc:
+            sys.stderr.write(f"{exc}\n")
+            return 2
+    if not provider_resolution_locked() and _should_handoff_to_project_runtime(argv) and handoff_to_project_runtime(
+        argv, current_package_root=Path(__file__).resolve().parent
+    ):
+        return 0
+
+    delegated = _dispatch_root_command(program_name, args)
+    if delegated is not None:
+        return delegated
+    return _core_main(list(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+__all__ = ["main"]

pz_core/cli_options.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+
+OPTION_SHORT_ALIASES: dict[str, str] = {
+    "--app-name": "-a",
+    "--base-branch": "-b",
+    "--concurrency": "-c",
+    "--clone-sources": "-C",
+    "--dry-run": "-n",
+    "--delete-checkout": "-X",
+    "--extra": "-x",
+    "--force": "-f",
+    "--group": "-g",
+    "--host": "-H",
+    "--json": "-j",
+    "--no-sync": "-S",
+    "--once": "-o",
+    "--poll-interval": "-I",
+    "--port": "-p",
+    "--prepare-workspace": "-w",
+    "--project-dir": "-d",
+    "--project-only": "-P",
+    "--reinstall-package": "-i",
+    "--reload": "-r",
+    "--replica-slot": "-l",
+    "--reset-middlewares-order": "-M",
+    "--shutdown-timeout": "-T",
+    "--status": "-s",
+    "--target": "-t",
+    "--target-dir": "-D",
+    "--workers": "-W",
+}
+
+
+def add_cli_option(
+    parser: argparse.ArgumentParser,
+    long_option: str,
+    *args: object,
+    **kwargs: object,
+) -> argparse.Action:
+    short_option = OPTION_SHORT_ALIASES.get(long_option)
+    if short_option is None:
+        raise ValueError(f"missing short option alias for {long_option}")
+    option_names = (short_option, long_option)
+    return parser.add_argument(*option_names, *args, **kwargs)
+
+
+def option_shortcuts_help() -> str:
+    lines = ["Common Option Shortcuts:"]
+    for long_option, short_option in sorted(OPTION_SHORT_ALIASES.items()):
+        lines.append(f"  {short_option}, {long_option}")
+    return "\n".join(lines)
+
+
+def resolve_program_name(argv0: str | None = None) -> str:
+    env_name = os.getenv("PZ_PROGRAM_NAME", "").strip().lower()
+    if env_name in {"pz", "pz"}:
+        return env_name
+    candidate = os.path.basename(str(argv0 or sys.argv[0] or "")).strip().lower()
+    if candidate in {"pz", "pz"}:
+        return candidate
+    return "pz"
+
+
+__all__ = [
+    "OPTION_SHORT_ALIASES",
+    "add_cli_option",
+    "option_shortcuts_help",
+    "resolve_program_name",
+]

pz_core/core/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__all__: list[str] = []

pz_core/core/errors/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .models import PzError, as_pz_error
+
+__all__ = ["PzError", "as_pz_error"]