pyplines-cli 2026.7.0a1__tar.gz

pyplines_cli-2026.7.0a1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: pyplines-cli
+Version: 2026.7.0a1
+Summary: The official command-line interface for Pyplines
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: dynaconf[yaml]<4,>=3.2.7
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: platformdirs<5,>=4
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: typer<1,>=0.24
+
+# pyplines-cli
+
+`pyplines-cli` is the command-line interface for Pyplines. The initial command
+surface supports local Function development through a running Pyplines Function
+development container. Server commands will use the same CLI in later releases.
+
+## Install
+
+```console
+pip install pyplines-cli
+```
+
+## Configuration
+
+Configuration is YAML stored in the platform-native user configuration directory.
+Find the exact path with:
+
+```console
+pyplines config path
+```
+
+Initial shape:
+
+```yaml
+mode: interactive
+
+function_development:
+  url: http://127.0.0.1:7331
+  connect_timeout: 5
+  operation_timeout: 1800
+
+function:
+  template:
+    repository: https://github.com/pyplines/function-template.git
+    ref: v1
+```
+
+Every setting can be overridden with a `PYPLINES_` environment variable. Use
+double underscores for nested keys:
+
+```console
+export PYPLINES_MODE=automation
+export PYPLINES_FUNCTION_DEVELOPMENT__URL=http://127.0.0.1:7331
+export PYPLINES_FUNCTION_DEVELOPMENT_TOKEN="<local-container-token>"
+```
+
+The token is environment-only and is not written to the configuration file.
+
+## Output
+
+Table output is the interactive default. JSON is selected by either:
+
+```console
+pyplines --json function status
+PYPLINES_MODE=automation pyplines function status
+```
+
+Streaming operations emit NDJSON in JSON mode.
+
+## Function Development
+
+Initialize from the configured, pinned Git template:
+
+```console
+pyplines function init hello-world
+```
+
+Check, invoke, and package the Function mounted into the development container:
+
+```console
+cd hello-world
+pyplines function status
+pyplines function check
+pyplines function invoke --input name=Ada
+pyplines function invoke --input-file inputs.yaml
+pyplines function package
+```
+
+`function init` uses the system Git client and honors existing credential helpers,
+SSH agents, proxies, and enterprise Git configuration. It does not execute template
+hooks or retain the template repository's `.git` directory.

pyplines_cli-2026.7.0a1/README.md

@@ -0,0 +1,81 @@
+# pyplines-cli
+
+`pyplines-cli` is the command-line interface for Pyplines. The initial command
+surface supports local Function development through a running Pyplines Function
+development container. Server commands will use the same CLI in later releases.
+
+## Install
+
+```console
+pip install pyplines-cli
+```
+
+## Configuration
+
+Configuration is YAML stored in the platform-native user configuration directory.
+Find the exact path with:
+
+```console
+pyplines config path
+```
+
+Initial shape:
+
+```yaml
+mode: interactive
+
+function_development:
+  url: http://127.0.0.1:7331
+  connect_timeout: 5
+  operation_timeout: 1800
+
+function:
+  template:
+    repository: https://github.com/pyplines/function-template.git
+    ref: v1
+```
+
+Every setting can be overridden with a `PYPLINES_` environment variable. Use
+double underscores for nested keys:
+
+```console
+export PYPLINES_MODE=automation
+export PYPLINES_FUNCTION_DEVELOPMENT__URL=http://127.0.0.1:7331
+export PYPLINES_FUNCTION_DEVELOPMENT_TOKEN="<local-container-token>"
+```
+
+The token is environment-only and is not written to the configuration file.
+
+## Output
+
+Table output is the interactive default. JSON is selected by either:
+
+```console
+pyplines --json function status
+PYPLINES_MODE=automation pyplines function status
+```
+
+Streaming operations emit NDJSON in JSON mode.
+
+## Function Development
+
+Initialize from the configured, pinned Git template:
+
+```console
+pyplines function init hello-world
+```
+
+Check, invoke, and package the Function mounted into the development container:
+
+```console
+cd hello-world
+pyplines function status
+pyplines function check
+pyplines function invoke --input name=Ada
+pyplines function invoke --input-file inputs.yaml
+pyplines function package
+```
+
+`function init` uses the system Git client and honors existing credential helpers,
+SSH agents, proxies, and enterprise Git configuration. It does not execute template
+hooks or retain the template repository's `.git` directory.

pyplines_cli-2026.7.0a1/cli/__init__.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import Annotated
+
+import typer
+
+from cli.apps.config import app as config_app
+from cli.apps.function import app as function_app
+from cli.config.loader import ConfigurationError, create_settings, get_config_path
+from cli.context import AppContext
+from cli.errors import exit_with_error
+from cli.output.mode import OutputMode, resolve_output_mode
+from cli.output.render import emit_data
+
+app = typer.Typer(
+    name="pyplines",
+    help="Build and operate Pyplines automation",
+    add_completion=False,
+    no_args_is_help=True,
+)
+app.add_typer(config_app, name="config")
+app.add_typer(function_app, name="function")
+
+
+@app.callback()
+def root_callback(
+    ctx: typer.Context,
+    output_json: Annotated[
+        bool,
+        typer.Option("--json", help="Emit machine-readable JSON output"),
+    ] = False,
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="Show verbose diagnostics"),
+    ] = False,
+) -> None:
+    try:
+        config_path = get_config_path()
+        settings = create_settings(config_path)
+        output_mode = resolve_output_mode(
+            force_json=output_json,
+            configured_mode=str(settings.get("mode", "interactive")),
+        )
+        ctx.obj = AppContext(
+            settings=settings,
+            config_path=config_path,
+            output_mode=output_mode,
+            verbose=verbose,
+        )
+    except Exception as exc:
+        mode = OutputMode.JSON if output_json else OutputMode.TABLE
+        exit_with_error(exc, mode, kind="configuration")
+
+
+@app.command("version")
+def version_command(ctx: typer.Context) -> None:
+    context: AppContext = ctx.find_root().obj
+    try:
+        cli_version = version("pyplines-cli")
+    except PackageNotFoundError:
+        cli_version = "development"
+    emit_data({"pyplines-cli": cli_version}, context.output_mode)
+
+
+__all__ = ["app"]

pyplines_cli-2026.7.0a1/cli/apps/__init__.py

@@ -0,0 +1 @@
+"""CLI command groups."""

pyplines_cli-2026.7.0a1/cli/apps/config.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+import yaml
+
+from cli.config.loader import effective_settings
+from cli.config.mutation import delete_dotted, set_dotted
+from cli.context import AppContext
+from cli.errors import exit_with_error
+from cli.output.render import emit_data
+
+app = typer.Typer(help="Manage Pyplines CLI configuration", no_args_is_help=True)
+
+
+def _context(ctx: typer.Context) -> AppContext:
+    return ctx.find_root().obj
+
+
+@app.command("path")
+def path_command(ctx: typer.Context) -> None:
+    context = _context(ctx)
+    emit_data({"path": str(context.config_path)}, context.output_mode)
+
+
+@app.command("show")
+def show_command(ctx: typer.Context) -> None:
+    context = _context(ctx)
+    emit_data(effective_settings(context.settings), context.output_mode)
+
+
+@app.command("get")
+def get_command(ctx: typer.Context, key: str) -> None:
+    context = _context(ctx)
+    sentinel = object()
+    value = context.settings.get(key, sentinel)
+    if value is sentinel:
+        exit_with_error(KeyError(f"setting does not exist: {key}"), context.output_mode)
+    emit_data({key: value}, context.output_mode)
+
+
+@app.command("set")
+def set_command(ctx: typer.Context, key: str, value: str) -> None:
+    context = _context(ctx)
+    try:
+        parsed: Any = yaml.safe_load(value)
+        set_dotted(context.config_path, key, parsed)
+        emit_data({key: parsed}, context.output_mode)
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="configuration")
+
+
+@app.command("rm")
+def remove_command(ctx: typer.Context, key: str) -> None:
+    context = _context(ctx)
+    try:
+        delete_dotted(context.config_path, key)
+        emit_data({"removed": key}, context.output_mode)
+    except KeyError:
+        exit_with_error(
+            ValueError(f"setting does not exist in config file: {key}"),
+            context.output_mode,
+            kind="configuration",
+        )
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="configuration")

pyplines_cli-2026.7.0a1/cli/apps/function.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from cli.context import AppContext
+from cli.development.client import FunctionDevelopmentClient
+from cli.development.events import DevelopmentEvent
+from cli.errors import CliError, exit_with_error
+from cli.function.inputs import load_inputs
+from cli.function.scaffold import initialize_function
+from cli.output.mode import OutputMode
+from cli.output.render import emit_data, emit_json_event
+
+app = typer.Typer(help="Develop Pyplines Functions", no_args_is_help=True)
+
+
+class RemoteOperationFailed(Exception):
+    pass
+
+
+def _context(ctx: typer.Context) -> AppContext:
+    return ctx.find_root().obj
+
+
+def _client(context: AppContext) -> FunctionDevelopmentClient:
+    settings = context.settings
+    return FunctionDevelopmentClient(
+        base_url=str(settings.get("function_development.url")),
+        connect_timeout=float(settings.get("function_development.connect_timeout")),
+        operation_timeout=float(settings.get("function_development.operation_timeout")),
+    )
+
+
+@app.command("init")
+def init_command(
+    ctx: typer.Context,
+    name: str,
+    path: Annotated[
+        Path, typer.Option(help="Parent directory for the Function")
+    ] = Path("."),
+    template: Annotated[
+        str | None, typer.Option(help="Git repository containing the Function template")
+    ] = None,
+    template_ref: Annotated[
+        str | None, typer.Option(help="Template Git tag, branch, or commit")
+    ] = None,
+) -> None:
+    context = _context(ctx)
+    repository = template or str(context.settings.get("function.template.repository"))
+    ref = template_ref or str(context.settings.get("function.template.ref"))
+    try:
+        destination = initialize_function(
+            slug=name,
+            parent=path,
+            repository=repository,
+            ref=ref,
+        )
+        emit_data(
+            {
+                "function": name,
+                "path": str(destination),
+                "template": repository,
+                "template_ref": ref,
+            },
+            context.output_mode,
+        )
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="function-init")
+
+
+@app.command("status")
+def status_command(ctx: typer.Context) -> None:
+    context = _context(ctx)
+    try:
+        with _client(context) as client:
+            emit_data(client.status(), context.output_mode)
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="function-development")
+
+
+@app.command("check")
+def check_command(
+    ctx: typer.Context,
+    path: Annotated[Path, typer.Argument(help="Mounted Function project path")] = Path(
+        "."
+    ),
+) -> None:
+    context = _context(ctx)
+    try:
+        _require_project(path)
+        with _client(context) as client:
+            _render_stream(client.check(), context.output_mode)
+    except RemoteOperationFailed:
+        raise typer.Exit(code=1)
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="function-check")
+
+
+@app.command("invoke")
+def invoke_command(
+    ctx: typer.Context,
+    path: Annotated[Path, typer.Argument(help="Mounted Function project path")] = Path(
+        "."
+    ),
+    inputs: Annotated[
+        list[str] | None,
+        typer.Option("--input", help="Function input in key=value form"),
+    ] = None,
+    input_file: Annotated[
+        Path | None,
+        typer.Option(help="JSON or YAML input file"),
+    ] = None,
+    sensitive_paths: Annotated[
+        list[str] | None,
+        typer.Option("--sensitive-path", help="Sensitive input JSON pointer"),
+    ] = None,
+) -> None:
+    context = _context(ctx)
+    try:
+        _require_project(path)
+        payload = load_inputs(
+            assignments=inputs or [],
+            input_file=input_file,
+        )
+        with _client(context) as client:
+            _render_stream(
+                client.invoke(payload, sensitive_paths or []),
+                context.output_mode,
+            )
+    except RemoteOperationFailed:
+        raise typer.Exit(code=1)
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="function-invoke")
+
+
+@app.command("package")
+def package_command(
+    ctx: typer.Context,
+    path: Annotated[Path, typer.Argument(help="Mounted Function project path")] = Path(
+        "."
+    ),
+) -> None:
+    context = _context(ctx)
+    try:
+        project = _require_project(path)
+        with _client(context) as client:
+            result = _render_stream(client.package(), context.output_mode)
+        if isinstance(result, dict) and isinstance(result.get("path"), str):
+            local_archive = project / "dist" / Path(result["path"]).name
+            if not local_archive.is_file():
+                raise CliError(
+                    f"Function Package was not created locally: {local_archive}"
+                )
+    except RemoteOperationFailed:
+        raise typer.Exit(code=1)
+    except Exception as exc:
+        exit_with_error(exc, context.output_mode, kind="function-package")
+
+
+def _render_stream(events: Any, mode: OutputMode) -> Any:
+    terminal_result: Any = None
+    failed = False
+    for event in events:
+        if mode is OutputMode.JSON:
+            emit_json_event(event.raw)
+        else:
+            _render_table_event(event)
+        if event.type == "result":
+            terminal_result = event.payload
+        elif event.type == "error":
+            failed = True
+    if failed:
+        raise RemoteOperationFailed()
+    if terminal_result is None:
+        raise CliError("development operation ended without a result")
+    return terminal_result
+
+
+def _render_table_event(event: DevelopmentEvent) -> None:
+    payload = event.payload
+    if event.type == "progress":
+        stage = (
+            payload.get("stage", "progress") if isinstance(payload, dict) else payload
+        )
+        typer.echo(f"[{stage}]")
+    elif event.type == "log":
+        if isinstance(payload, dict):
+            level = payload.get("level", "info")
+            message = payload.get("message", "")
+            fields = payload.get("fields") or {}
+            suffix = " ".join(f"{key}={value}" for key, value in fields.items())
+            typer.echo(f"[{level}] {message}" + (f" {suffix}" if suffix else ""))
+        else:
+            typer.echo(str(payload))
+    elif event.type == "diagnostic":
+        message = (
+            payload.get("message", payload) if isinstance(payload, dict) else payload
+        )
+        typer.echo(str(message), err=True)
+    elif event.type == "error":
+        message = (
+            payload.get("message", payload) if isinstance(payload, dict) else payload
+        )
+        typer.echo(f"Error: {message}", err=True)
+    elif event.type == "result":
+        emit_data(payload, OutputMode.TABLE)
+
+
+def _require_project(path: Path) -> Path:
+    project = path.expanduser().resolve()
+    if not (project / "pyproject.toml").is_file():
+        raise CliError(f"Function project does not contain pyproject.toml: {project}")
+    return project

pyplines_cli-2026.7.0a1/cli/config/__init__.py

@@ -0,0 +1,3 @@
+from cli.config.loader import create_settings, get_config_path
+
+__all__ = ["create_settings", "get_config_path"]

pyplines_cli-2026.7.0a1/cli/config/loader.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from dynaconf import Dynaconf
+from platformdirs import user_config_dir
+
+DEFAULTS: dict[str, Any] = {
+    "mode": "interactive",
+    "function_development": {
+        "url": "http://127.0.0.1:7331",
+        "connect_timeout": 5,
+        "operation_timeout": 1800,
+    },
+    "function": {
+        "template": {
+            "repository": "https://github.com/pyplines/function-template.git",
+            "ref": "v1",
+        }
+    },
+}
+
+
+class ConfigurationError(ValueError):
+    pass
+
+
+def get_config_path() -> Path:
+    override = os.getenv("PYPLINES_CONFIG_FILE")
+    if override:
+        return Path(override).expanduser().resolve()
+    return Path(user_config_dir("pyplines")) / "config.yaml"
+
+
+def create_settings(path: Path | None = None, *, load_env: bool = True) -> Dynaconf:
+    config_path = (path or get_config_path()).expanduser().resolve()
+    settings = Dynaconf(
+        envvar_prefix="PYPLINES" if load_env else False,
+        settings_files=[str(config_path)],
+        environments=False,
+        load_dotenv=False,
+        core_loaders=["YAML"],
+        merge_enabled=True,
+    )
+    _apply_defaults(settings, DEFAULTS)
+    validate_settings(settings)
+    return settings
+
+
+def validate_settings(settings: Dynaconf) -> None:
+    mode = str(settings.get("mode", "interactive")).lower()
+    if mode not in {"interactive", "automation"}:
+        raise ConfigurationError("mode must be interactive or automation")
+
+    url = str(settings.get("function_development.url", ""))
+    parsed = urlparse(url)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ConfigurationError(
+            "function_development.url must be an HTTP or HTTPS URL"
+        )
+
+    for key in (
+        "function_development.connect_timeout",
+        "function_development.operation_timeout",
+    ):
+        value = settings.get(key)
+        if isinstance(value, bool) or not isinstance(value, (int, float)) or value <= 0:
+            raise ConfigurationError(f"{key} must be a positive number")
+
+    repository = str(settings.get("function.template.repository", "")).strip()
+    if not repository:
+        raise ConfigurationError("function.template.repository must not be empty")
+    template_ref = str(settings.get("function.template.ref", "")).strip()
+    if not template_ref:
+        raise ConfigurationError("function.template.ref must not be empty")
+
+
+def effective_settings(settings: Dynaconf) -> dict[str, Any]:
+    ignored = {"LOAD_DOTENV", "CONFIG_FILE"}
+    return {
+        str(key).lower(): _normalize_effective(value)
+        for key, value in settings.as_dict().items()
+        if key not in ignored
+    }
+
+
+def _apply_defaults(
+    settings: Dynaconf, values: dict[str, Any], prefix: str = ""
+) -> None:
+    missing = object()
+    for key, value in values.items():
+        dotted = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, dict):
+            _apply_defaults(settings, value, dotted)
+        elif settings.get(dotted, missing) is missing:
+            settings.set(dotted, value)
+
+
+def _normalize_effective(value: Any) -> Any:
+    if isinstance(value, dict):
+        normalized = {}
+        for key, item in value.items():
+            name = str(key).lower()
+            if any(marker in name for marker in ("token", "password", "secret")):
+                normalized[name] = "[REDACTED]"
+            else:
+                normalized[name] = _normalize_effective(item)
+        return normalized
+    if isinstance(value, list):
+        return [_normalize_effective(item) for item in value]
+    return value