tangle-cli 0.0.1a1__py3-none-any.whl

tangle_cli/pipelines_cli.py

@@ -0,0 +1,271 @@
+"""`tangle sdk pipelines` local pipeline commands."""
+
+from __future__ import annotations
+
+import pathlib
+from typing import Annotated, Any
+
+from cyclopts import App, Parameter
+
+from .cli_helpers import LazyTangleApiClient, load_config_or_exit, optional_path
+from .cli_options import (
+    AuthHeaderOption,
+    BaseUrlOption,
+    ConfigOption,
+    HeaderOption,
+    LogTypeOption,
+    TokenOption,
+)
+from .logger import logger_for_log_type
+from .pipelines import (
+    PipelineValidationError,
+    generate_mermaid,
+    hydrate_pipeline_file,
+    layout_pipeline_file,
+    validate_pipeline_file,
+)
+
+app = App(
+    name="pipelines",
+    help="Validate and visualize local Tangle pipeline specs.",
+)
+
+
+@app.command(name="validate")
+def pipelines_validate(
+    pipeline_path: pathlib.Path,
+    *,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Validate a local pipeline YAML file."""
+
+    logger, finalize_logs = logger_for_log_type(log_type)
+    try:
+        try:
+            validate_pipeline_file(pipeline_path)
+        except PipelineValidationError as exc:
+            raise SystemExit(str(exc)) from exc
+        print(f"Valid pipeline: {pipeline_path}")
+    finally:
+        finalize_logs()
+
+
+@app.command(name="diagram")
+def pipelines_diagram(
+    pipeline_path: pathlib.Path,
+    *,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Print a Mermaid dependency diagram for a local pipeline YAML file."""
+
+    logger, finalize_logs = logger_for_log_type(log_type)
+    try:
+        try:
+            pipeline = validate_pipeline_file(pipeline_path)
+        except PipelineValidationError as exc:
+            raise SystemExit(str(exc)) from exc
+        print(generate_mermaid(pipeline))
+    finally:
+        finalize_logs()
+
+
+def _optional_str(value: object) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _header_entries(cli_header: list[str] | None, config: dict[str, object]) -> list[str] | None:
+    if cli_header is not None:
+        return cli_header
+    config_header = config.get("header")
+    if isinstance(config_header, list):
+        return [str(entry) for entry in config_header]
+    if isinstance(config_header, str):
+        return [config_header]
+    return None
+
+
+def _trusted_hydration_config(config: dict[str, object]) -> dict[str, Any]:
+    trusted = config.get("trusted_hydration", {})
+    return trusted if isinstance(trusted, dict) else {}
+
+
+def _trusted_sources(
+    cli_sources: list[str] | None,
+    config: dict[str, object],
+) -> list[str]:
+    sources: list[str] = []
+    config_sources = _trusted_hydration_config(config).get("trusted_python_sources", [])
+    if isinstance(config_sources, str):
+        sources.append(config_sources)
+    elif isinstance(config_sources, list):
+        sources.extend(str(source) for source in config_sources)
+    if cli_sources:
+        sources.extend(cli_sources)
+    return [source for source in sources if source]
+
+
+def _allow_all_hydration(
+    trusted_hydration: bool | None,
+    config: dict[str, object],
+) -> bool:
+    return bool(trusted_hydration or _trusted_hydration_config(config).get("allow_all", False))
+
+
+def _parse_vars(values: list[str] | dict[str, object] | None) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    if isinstance(values, dict):
+        return {str(key): str(value) for key, value in values.items()}
+    for value in values or []:
+        if "=" not in value:
+            raise SystemExit("--var entries must use KEY=VALUE syntax")
+        key, parsed_value = value.split("=", 1)
+        if not key:
+            raise SystemExit("--var entries must use KEY=VALUE syntax")
+        parsed[key] = parsed_value
+    return parsed
+
+
+@app.command(name="hydrate")
+def pipelines_hydrate(
+    pipeline_path: pathlib.Path,
+    *,
+    output: Annotated[
+        pathlib.Path | None,
+        Parameter(
+            name="--output",
+            alias="-o",
+            help="Output path. Defaults to printing hydrated YAML to stdout.",
+        ),
+    ] = None,
+    var: Annotated[
+        list[str] | None,
+        Parameter(
+            name="--var",
+            help="Template override as KEY=VALUE. Repeat for multiple overrides.",
+            negative_iterable=(),
+        ),
+    ] = None,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    trusted_source: Annotated[
+        list[str] | None,
+        Parameter(
+            name="--trusted-source",
+            help="Trusted local_from_python source root or glob. Repeat for multiple.",
+            negative_iterable=(),
+        ),
+    ] = None,
+    trusted_hydration: Annotated[
+        bool | None,
+        Parameter(
+            name="--trusted-hydration",
+            help="Allow all local_from_python execution during hydration for trusted inputs.",
+        ),
+    ] = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Hydrate a local pipeline YAML file."""
+
+    config_values = load_config_or_exit(config)
+    config_base_url = _optional_str(config_values.get("base_url"))
+    resolved_base_url = base_url if base_url is not None else config_base_url
+    include_env_credentials = not (base_url is None and config_base_url is not None)
+    resolved_var = var if var is not None else config_values.get("var")
+    resolved_token = token
+    if resolved_token is None:
+        resolved_token = _optional_str(config_values.get("token"))
+
+    logger, finalize_logs = logger_for_log_type(log_type)
+    try:
+        result = hydrate_pipeline_file(
+            pipeline_path,
+            output=output or optional_path(config_values.get("output")),
+            overrides=_parse_vars(resolved_var),
+            base_url=resolved_base_url,
+            token=resolved_token,
+            auth_header=(
+                auth_header
+                if auth_header is not None
+                else _optional_str(config_values.get("auth_header"))
+            ),
+            header=_header_entries(header, config_values),
+            include_env_credentials=include_env_credentials,
+            logger=logger,
+            trusted_python_sources=_trusted_sources(trusted_source, config_values),
+            allow_all_hydration=_allow_all_hydration(trusted_hydration, config_values),
+            client=LazyTangleApiClient(
+                command_name="pipeline hydration with API-backed component references",
+                base_url=resolved_base_url,
+                token=resolved_token,
+                auth_header=(
+                    auth_header
+                    if auth_header is not None
+                    else _optional_str(config_values.get("auth_header"))
+                ),
+                header=_header_entries(header, config_values),
+                include_env_credentials=include_env_credentials,
+            ),
+        )
+    except PipelineValidationError as exc:
+        raise SystemExit(str(exc)) from exc
+    finally:
+        finalize_logs()
+
+    if result.output_path is None:
+        print(result.content, end="" if result.content.endswith("\n") else "\n")
+    else:
+        print(
+            f"Hydrated {pipeline_path} -> {result.output_path} "
+            f"({result.resolved_components} component(s) resolved)."
+        )
+
+
+@app.command(name="layout")
+def pipelines_layout(
+    pipeline_path: pathlib.Path,
+    *,
+    output: Annotated[
+        pathlib.Path | None,
+        Parameter(
+            name="--output",
+            alias="-o",
+            help="Output path. Defaults to overwriting the input file.",
+        ),
+    ] = None,
+    recursive: Annotated[
+        bool | None,
+        Parameter(help="Also layout nested graph component specs."),
+    ] = None,
+    x_spacing: Annotated[
+        int,
+        Parameter(help="Horizontal spacing between dependency layers."),
+    ] = 300,
+    y_spacing: Annotated[
+        int,
+        Parameter(help="Vertical spacing between tasks in the same layer."),
+    ] = 120,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Add or update editor.position annotations in a local pipeline YAML file."""
+
+    logger, finalize_logs = logger_for_log_type(log_type)
+    try:
+        result = layout_pipeline_file(
+            pipeline_path,
+            output=output,
+            recursive=bool(recursive),
+            x_spacing=x_spacing,
+            y_spacing=y_spacing,
+        )
+    except PipelineValidationError as exc:
+        raise SystemExit(str(exc)) from exc
+    finally:
+        finalize_logs()
+    print(
+        f"Positioned {result.tasks_positioned} task(s) across "
+        f"{result.graphs_positioned} graph(s)."
+    )
+    print(f"Wrote layout to: {result.output_path}")

tangle_cli/published_components_cli.py

@@ -0,0 +1,373 @@
+"""`tangle sdk published-components` command implementation."""
+
+from __future__ import annotations
+
+import pathlib
+from typing import Annotated, Any
+
+from cyclopts import App, Parameter
+
+from .cli_helpers import (
+    LazyTangleApiClient,
+    api_arg_specs,
+    include_env_credentials_for_args,
+    load_args_or_exit,
+    optional_path,
+    print_json,
+)
+from .cli_options import (
+    AuthHeaderOption,
+    BaseUrlOption,
+    ConfigOption,
+    HeaderOption,
+    LogTypeOption,
+    TokenOption,
+)
+from .component_publisher import ComponentPublisher, deprecate_component
+from .logger import logger_for_log_type
+
+
+def _client_from_options(
+    *,
+    base_url: str | None = None,
+    token: str | None = None,
+    auth_header: str | None = None,
+    header: list[str] | str | None = None,
+    include_env_credentials: bool = True,
+    command_name: str = "published-component commands",
+) -> LazyTangleApiClient:
+    """Create a lazy static client proxy for published-component commands.
+
+    Kept as a module-level seam so downstream wrappers/tests can monkeypatch
+    client construction without replacing the shared LazyTangleApiClient class.
+    """
+
+    return LazyTangleApiClient(
+        base_url=base_url,
+        token=token,
+        auth_header=auth_header,
+        header=header,
+        include_env_credentials=include_env_credentials,
+        command_name=command_name,
+    )
+
+
+app = App(
+    name="published-components",
+    help="Inspect and search published Tangle components from the registry.",
+)
+
+
+@app.command(name="search")
+def published_components_search(
+    name: str | None = None,
+    *,
+    include_deprecated: bool | None = None,
+    published_by: str | None = None,
+    digest: str | None = None,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Search published component metadata."""
+
+    for args in load_args_or_exit(
+        config,
+        name=(name, None),
+        include_deprecated=(include_deprecated, None),
+        published_by=(published_by, None),
+        digest=(digest, None),
+        log_type=(log_type, "console"),
+        **api_arg_specs(
+            base_url=base_url,
+            token=token,
+            auth_header=auth_header,
+            header=header,
+        ),
+    ):
+        logger, finalize_logs = logger_for_log_type(args.log_type)
+        try:
+            client = _client_from_options(
+                base_url=args.base_url,
+                token=args.token,
+                auth_header=args.auth_header,
+                header=args.header,
+                include_env_credentials=include_env_credentials_for_args(args, base_url),
+                command_name="published-component commands",
+            )
+            if require_available := getattr(client, "require_available", None):
+                require_available()
+
+            from .component_inspector import ComponentInspector
+
+            print_json(
+                ComponentInspector(client=client, logger=logger, base_url=args.base_url).search_components(
+                    name=args.name,
+                    include_deprecated=bool(args.include_deprecated),
+                    published_by=args.published_by,
+                    digest=args.digest,
+                )
+            )
+        finally:
+            finalize_logs()
+
+
+@app.command(name="inspect")
+def published_components_inspect(
+    name: str | None = None,
+    *,
+    digest: str | None = None,
+    all_versions: bool | None = None,
+    include_deprecated: bool | None = None,
+    follow_deprecated: bool | None = None,
+    full_spec: bool | None = None,
+    published_by: str | None = None,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Inspect a published component by exact name or digest."""
+
+    for args in load_args_or_exit(
+        config,
+        name=(name, None),
+        digest=(digest, None),
+        all_versions=(all_versions, None),
+        include_deprecated=(include_deprecated, None),
+        follow_deprecated=(follow_deprecated, None),
+        full_spec=(full_spec, None),
+        published_by=(published_by, None),
+        log_type=(log_type, "console"),
+        **api_arg_specs(
+            base_url=base_url,
+            token=token,
+            auth_header=auth_header,
+            header=header,
+        ),
+    ):
+        logger, finalize_logs = logger_for_log_type(args.log_type)
+        try:
+            if bool(args.name) == bool(args.digest):
+                raise SystemExit("Provide exactly one of NAME or --digest DIGEST")
+
+            client = _client_from_options(
+                base_url=args.base_url,
+                token=args.token,
+                auth_header=args.auth_header,
+                header=args.header,
+                include_env_credentials=include_env_credentials_for_args(args, base_url),
+                command_name="published-component commands",
+            )
+            if require_available := getattr(client, "require_available", None):
+                require_available()
+            from .component_inspector import ComponentInspector
+
+            inspector = ComponentInspector(client=client, logger=logger, base_url=args.base_url)
+            if args.digest:
+                result = inspector.inspect_by_digest(
+                    args.digest,
+                    full_spec=bool(args.full_spec),
+                    follow_deprecated=bool(args.follow_deprecated),
+                )
+            else:
+                result = inspector.inspect_by_name(
+                    args.name or "",
+                    include_all_versions=bool(args.all_versions),
+                    include_deprecated=bool(args.include_deprecated),
+                    full_spec=bool(args.full_spec),
+                    published_by=args.published_by,
+                )
+            print_json(result)
+        finally:
+            finalize_logs()
+
+
+@app.command(name="library")
+def published_components_library(
+    *,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Print the curated standard component library."""
+
+    for args in load_args_or_exit(
+        config,
+        log_type=(log_type, "console"),
+        **api_arg_specs(
+            base_url=base_url,
+            token=token,
+            auth_header=auth_header,
+            header=header,
+        ),
+    ):
+        logger, finalize_logs = logger_for_log_type(args.log_type)
+        try:
+            client = _client_from_options(
+                base_url=args.base_url,
+                token=args.token,
+                auth_header=args.auth_header,
+                header=args.header,
+                include_env_credentials=include_env_credentials_for_args(args, base_url),
+                command_name="published-component commands",
+            )
+            if require_available := getattr(client, "require_available", None):
+                require_available()
+
+            from .component_inspector import ComponentInspector
+
+            print_json(ComponentInspector(client=client, logger=logger, base_url=args.base_url).get_standard_library())
+        finally:
+            finalize_logs()
+
+
+@app.command(name="publish")
+def published_components_publish(
+    component_path: pathlib.Path | None = None,
+    *,
+    image: str | None = None,
+    name: str | None = None,
+    description: str | None = None,
+    annotations: Annotated[
+        str | None,
+        Parameter(help="Custom annotations as a JSON object."),
+    ] = None,
+    dry_run: bool | None = None,
+    git_remote_sha: str | None = None,
+    git_remote_branch: str | None = None,
+    git_remote_url: str | None = None,
+    git_root: pathlib.Path | None = None,
+    published_by: str | None = None,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Publish one component YAML file to a Tangle component registry."""
+
+    all_args = load_args_or_exit(
+        config,
+        component_path=("component_path", component_path, None, False, True, optional_path),
+        image=(image, None),
+        name=(name, None),
+        description=(description, None),
+        annotations=("annotations", annotations, None, True),
+        dry_run=(dry_run, None),
+        git_remote_sha=(git_remote_sha, None),
+        git_remote_branch=(git_remote_branch, None),
+        git_remote_url=(git_remote_url, None),
+        git_root=(git_root, None, optional_path),
+        published_by=(published_by, None),
+        log_type=(log_type, "console"),
+        **api_arg_specs(
+            base_url=base_url,
+            token=token,
+            auth_header=auth_header,
+            header=header,
+        ),
+    )
+    results: list[dict[str, Any]] = []
+    for args in all_args:
+        logger, finalize_logs = logger_for_log_type(args.log_type)
+        try:
+            client = None if args.dry_run else _client_from_options(
+                base_url=args.base_url,
+                token=args.token,
+                auth_header=args.auth_header,
+                header=args.header,
+                include_env_credentials=include_env_credentials_for_args(args, base_url),
+                command_name="published-component commands",
+            )
+            publisher = ComponentPublisher(
+                dry_run=bool(args.dry_run),
+                git_remote_sha=args.git_remote_sha,
+                git_remote_branch=args.git_remote_branch,
+                git_remote_url=args.git_remote_url,
+                git_root=args.git_root,
+                published_by=args.published_by,
+                client=client,
+                logger=logger,
+            )
+            result = publisher.publish_component(
+                args.component_path,
+                image=args.image,
+                name=args.name,
+                description=args.description,
+                annotations=args.annotations,
+            )
+            result_dict = result.to_dict() if hasattr(result, "to_dict") else dict(result)
+            results.append({"component_path": str(args.component_path), **result_dict})
+        finally:
+            finalize_logs()
+
+    error_count = sum(1 for result in results if result.get("status") in {"error", "failed"})
+    summary = {
+        "status": "failed" if error_count else "success",
+        "components_count": len(results),
+        "error_count": error_count,
+        "results": results,
+    }
+    print_json(summary)
+    if error_count:
+        raise SystemExit(1)
+
+
+@app.command(name="deprecate")
+def published_components_deprecate(
+    digest: str | None = None,
+    *,
+    superseded_by: str | None = None,
+    base_url: BaseUrlOption = None,
+    token: TokenOption = None,
+    auth_header: AuthHeaderOption = None,
+    header: HeaderOption = None,
+    config: ConfigOption = None,
+    log_type: LogTypeOption = "console",
+) -> None:
+    """Deprecate a published component by digest."""
+
+    for args in load_args_or_exit(
+        config,
+        digest=("digest", digest, None, False, True),
+        superseded_by=(superseded_by, None),
+        log_type=(log_type, "console"),
+        **api_arg_specs(
+            base_url=base_url,
+            token=token,
+            auth_header=auth_header,
+            header=header,
+        ),
+    ):
+        logger, finalize_logs = logger_for_log_type(args.log_type)
+        try:
+            client = _client_from_options(
+                base_url=args.base_url,
+                token=args.token,
+                auth_header=args.auth_header,
+                header=args.header,
+                include_env_credentials=include_env_credentials_for_args(args, base_url),
+                command_name="published-component commands",
+            )
+            result = deprecate_component(
+                client,
+                args.digest,
+                superseded_by=args.superseded_by,
+                logger=logger,
+            )
+            result_dict = result.to_dict() if hasattr(result, "to_dict") else result
+            print_json(result_dict)
+            if isinstance(result_dict, dict) and not result_dict.get("success", result_dict.get("status") != "failed"):
+                raise SystemExit(1)
+        finally:
+            finalize_logs()