tangle-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: tangle-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: CLI for Tangle, the open-source ML pipeline orchestration platform
-Author: Alexey Volkov, Tangle authors
-Author-email: Alexey Volkov <alexey.volkov@ark-kun.com>
+Author: Alexey Volkov, Tangle authors, Volv Grebennikov
+Author-email: Alexey Volkov <alexey.volkov@ark-kun.com>, Volv Grebennikov <volv.grebennikov@shopify.com>
 Requires-Dist: cloud-pipelines>=0.26.3.12
 Requires-Dist: cyclopts>=4.16.1
 Requires-Dist: docstring-parser>=0.16
@@ -318,6 +318,8 @@ uv run tangle sdk pipeline-runs export RUN_ID --output pipeline.yaml
 
 `submit` hydrates refs by default and builds an API submit payload with `root_task.componentRef.spec`. Use `--no-hydrate` to submit the local YAML structure as-is. Use `--dry-run` to print the payload without creating a run.
 
+Before creating a run—or printing a `--dry-run` payload—`submit` runs the same authoring validation as `tangle sdk pipelines validate` on the hydrated/resolved pipeline spec (or on the as-is spec when `--no-hydrate` is used). Invalid specs fail locally with `Pipeline validation failed` errors before the run-submission API call. For example, the pipeline root must be a graph (`implementation.graph`), so a bare `implementation.container` root is rejected before the run is submitted.
+
 ## Programmatic client
 
 The stable public wrapper for downstream Python tools is:

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/README.md

@@ -293,6 +293,8 @@ uv run tangle sdk pipeline-runs export RUN_ID --output pipeline.yaml
 
 `submit` hydrates refs by default and builds an API submit payload with `root_task.componentRef.spec`. Use `--no-hydrate` to submit the local YAML structure as-is. Use `--dry-run` to print the payload without creating a run.
 
+Before creating a run—or printing a `--dry-run` payload—`submit` runs the same authoring validation as `tangle sdk pipelines validate` on the hydrated/resolved pipeline spec (or on the as-is spec when `--no-hydrate` is used). Invalid specs fail locally with `Pipeline validation failed` errors before the run-submission API call. For example, the pipeline root must be a graph (`implementation.graph`), so a bare `implementation.container` root is rejected before the run is submitted.
+
 ## Programmatic client
 
 The stable public wrapper for downstream Python tools is:

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/packages/tangle-cli/src/tangle_cli/__init__.py

@@ -14,6 +14,6 @@ from tangle_cli.dynamic_discovery_client import TangleDynamicDiscoveryClient
 try:
     __version__ = metadata_version("tangle-cli")
 except PackageNotFoundError:
-    __version__ = "0.1.1"
+    __version__ = "0.1.3"
 
 __all__ = ["TangleDynamicDiscoveryClient", "__version__"]

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/packages/tangle-cli/src/tangle_cli/component_from_func.py

@@ -181,11 +181,18 @@ class FunctionSpec:
 
 
 def _ensure_cloud_pipelines_shim() -> None:
-    """Register import-time shims used while introspecting authoring files.
-
-    This allows loading Python files that use `from cloud_pipelines import components`
-    and/or TD authoring decorators without requiring those authoring packages.
-    The TD authoring constructs are stripped from generated runtime code later.
+    """Register the import-time ``cloud_pipelines`` shim used while introspecting
+    authoring files.
+
+    This lets us load Python files that use ``from cloud_pipelines import
+    components`` without requiring that authoring package to be installed; the
+    authoring constructs are stripped from the generated runtime code later.
+
+    OSS deliberately does NOT fabricate a shim for any *downstream* authoring
+    surface (e.g. a module a downstream package exposes to re-export the
+    authoring objects under its own import path). A downstream package that
+    wants its own authoring path recognised both makes that module importable
+    itself and registers it via :func:`register_authoring_import_module`.
     """
     if "cloud_pipelines" not in sys.modules:
         components_mod = types.ModuleType("cloud_pipelines.components")
@@ -198,41 +205,6 @@ def _ensure_cloud_pipelines_shim() -> None:
         sys.modules["cloud_pipelines"] = cloud_pipelines_mod
         sys.modules["cloud_pipelines.components"] = components_mod
 
-    _ensure_tangle_deploy_authoring_shim()
-
-
-def _identity_decorator(*args, **kwargs):
-    def decorate(func):
-        return func
-
-    return decorate
-
-
-class _AuthoringGeneric:
-    def __class_getitem__(cls, item):
-        return cls
-
-    def __init__(self, *args, **kwargs):
-        pass
-
-
-def _ensure_tangle_deploy_authoring_shim() -> None:
-    """Register a tiny shim for TD pipeline authoring imports if absent."""
-    if "tangle_deploy.python_pipeline" in sys.modules:
-        return
-
-    tangle_deploy_mod = sys.modules.get("tangle_deploy") or types.ModuleType("tangle_deploy")
-    python_pipeline_mod = types.ModuleType("tangle_deploy.python_pipeline")
-    for name in ("task", "pipeline", "subpipeline", "registered"):
-        setattr(python_pipeline_mod, name, _identity_decorator)
-    for name in ("In", "Out", "Outputs", "TaskEnv"):
-        setattr(python_pipeline_mod, name, _AuthoringGeneric)
-    setattr(python_pipeline_mod, "ref", lambda *args, **kwargs: None)
-
-    setattr(tangle_deploy_mod, "python_pipeline", python_pipeline_mod)
-    sys.modules.setdefault("tangle_deploy", tangle_deploy_mod)
-    sys.modules["tangle_deploy.python_pipeline"] = python_pipeline_mod
-
 
 def load_python_module(file_path: Path, extra_sys_path: list[Path] | None = None) -> Any:
     """Dynamically import a Python module from a file path.
@@ -757,31 +729,66 @@ def _is_name_main_test(node: ast.expr) -> bool:
 # too, exactly like @task.
 _AUTHORING_DECORATOR_NAMES = frozenset({"task", "pipeline", "subpipeline", "registered"})
 
-# The python-pipeline authoring module. ONLY imports of this module (and its
-# submodules) are authoring-only and stripped from the baked source. We
-# deliberately do NOT strip other ``tangle_deploy.*`` packages (e.g.
-# ``tangle_deploy.utils``): those may be legitimate runtime helpers used inside a
-# ``@task`` body, and dropping them would raise ``NameError`` in the operation
-# container.
-_AUTHORING_IMPORT_MODULE = "tangle_deploy.python_pipeline"
+# The python-pipeline authoring modules. ONLY imports of these modules (and
+# their submodules) are authoring-only and stripped from the baked source. We
+# deliberately do NOT strip other packages that merely share a top-level name
+# (e.g. a downstream ``*.utils``): those may be legitimate runtime helpers used
+# inside a ``@task`` body, and dropping them would raise ``NameError`` in the
+# operation container.
+#
+# OSS recognises exactly one authoring surface out of the box: the canonical
+# ``tangle_cli.python_pipeline`` path. A downstream package that re-exports the
+# authoring objects under its own module path — so authors may write ``from
+# <downstream>.python_pipeline import task`` — registers that path via
+# :func:`register_authoring_import_module`; codegen then strips either import
+# the same way. OSS never hardcodes a downstream module name (the dependency
+# points inward), mirroring the resolver/reader registries in the hydrator.
+_AUTHORING_IMPORT_MODULES: list[str] = ["tangle_cli.python_pipeline"]
+
+
+def register_authoring_import_module(module: str) -> None:
+    """Register *module* as an additional python-pipeline authoring surface.
+
+    A downstream package that re-exports the ``tangle_cli.python_pipeline``
+    authoring objects under its own module path calls this (typically at import
+    time) so codegen strips ``from <module> import ...`` / ``import <module>``
+    lines — and their submodules — from baked runtime source exactly like the
+    canonical OSS surface. Idempotent: registering an already-known module is a
+    no-op, so repeated import-time registration is safe.
+    """
+    if module not in _AUTHORING_IMPORT_MODULES:
+        _AUTHORING_IMPORT_MODULES.append(module)
+
+
+def authoring_import_modules() -> tuple[str, ...]:
+    """Return the python-pipeline authoring modules recognised by codegen."""
+    return tuple(_AUTHORING_IMPORT_MODULES)
 
 # The authoring-only ``TaskEnv`` class name. A module-level ``X = TaskEnv(...)``
 # (or ``X = <alias>.TaskEnv(...)``) declaration is authoring-only by contract and
 # is stripped from the baked source by ``_strip_authoring_constructs``.
 # Matched by trailing NAME only (like the authoring decorators), because in
-# python-pipeline authoring files ``TaskEnv`` always
-# resolves to ``tangle_deploy.python_pipeline.TaskEnv``.
+# python-pipeline authoring files ``TaskEnv`` always resolves to the
+# python-pipeline authoring surface's ``TaskEnv``.
 _AUTHORING_ENV_CLASS_NAME = "TaskEnv"
 
 
 class AuthoringStripError(ValueError):
-    """Raised when env-only authoring code cannot be safely stripped.
+    """Raised when authoring code cannot be safely stripped from baked source.
+
+    ``_strip_authoring_constructs`` raises this rather than bake a broken
+    program when an authoring construct is entangled with runtime code and
+    cannot be removed by line range without corrupting the kept program:
 
-    The TaskEnv runtime-strip hardening (``_strip_authoring_constructs``)
-    raises this when a ``@task(env=...)`` env binding is entangled with
-    runtime code — e.g. a mixed ``from _envs import UPI, helper`` import whose
-    ``helper`` is used at runtime, or a collected env name referenced by the
-    kept task body. Failing fast here is intentional: silently baking a broken
+    - a comma-separated ``import tangle_cli.python_pipeline as tp, os`` that
+      mixes the authoring surface with a runtime module on one statement (the
+      authoring alias must be stripped, but line-deletion would take ``os`` with
+      it); or
+    - a ``@task(env=...)`` env binding entangled with runtime code — e.g. a
+      mixed ``from _envs import UPI, helper`` import whose ``helper`` is used at
+      runtime, or a collected env name referenced by the kept task body.
+
+    Failing fast here is intentional: silently baking a broken ``import os`` /
     ``from _envs import UPI`` / ``UPI = TaskEnv(...)`` would only surface as a
     ``NameError`` / ``ImportError`` at container start. The message tells the
     author how to split the import or keep TaskEnv values authoring-only.
@@ -793,7 +800,7 @@ def _decorator_called_name(node: ast.expr) -> str | None:
 
     Handles ``@name`` / ``@name(...)`` and ``@mod.name`` / ``@mod.name(...)``
     forms, returning the trailing attribute/name (e.g. ``task`` for both
-    ``@task(...)`` and ``@tangle_deploy.python_pipeline.task(...)``). Returns
+    ``@task(...)`` and ``@tangle_cli.python_pipeline.task(...)``). Returns
     ``None`` for shapes we do not recognise so callers leave them untouched.
 
     Limitation (v1, intentional): matching is by trailing NAME only, not by
@@ -812,36 +819,58 @@ def _decorator_called_name(node: ast.expr) -> str | None:
     return None
 
 
+def _is_authoring_module(name: str) -> bool:
+    """Return True if *name* is an authoring module or a submodule of one."""
+    return any(name == mod or name.startswith(mod + ".") for mod in _AUTHORING_IMPORT_MODULES)
+
+
 def _is_authoring_import(node: ast.stmt) -> bool:
     """Return True if *node* imports the python-pipeline authoring surface.
 
-    Matches ONLY the ``tangle_deploy.python_pipeline`` module (and its
-    submodules):
+    Matches ONLY the registered authoring modules (and their submodules) — the
+    canonical ``tangle_cli.python_pipeline`` plus any registered via
+    :func:`register_authoring_import_module`:
 
-    - ``from tangle_deploy.python_pipeline import ...`` (including the aliased
-      ``from tangle_deploy.python_pipeline import ref as operation_by_ref`` form
-      and submodules like ``from tangle_deploy.python_pipeline.x import y``);
-    - ``import tangle_deploy.python_pipeline`` / ``import
-      tangle_deploy.python_pipeline as tp``.
+    - ``from tangle_cli.python_pipeline import ...`` (including the aliased
+      ``from tangle_cli.python_pipeline import ref as operation_by_ref`` form
+      and submodules like ``from tangle_cli.python_pipeline.x import y``);
+    - ``import tangle_cli.python_pipeline`` / ``import
+      tangle_cli.python_pipeline as tp``;
+    - the equivalents for any registered downstream authoring path.
 
-    It does NOT match other ``tangle_deploy.*`` packages (e.g.
-    ``from tangle_deploy.utils import X``) — those can be genuine runtime helpers
+    It does NOT match other packages that merely share a top-level name (e.g. a
+    downstream ``*.utils`` module) — those can be genuine runtime helpers
     referenced inside a ``@task`` body and must survive into the baked program.
     Relative imports (``from . import x``) are never authoring imports.
     """
     if isinstance(node, ast.ImportFrom):
         if node.level:  # relative import — not the authoring package
             return False
-        module = node.module or ""
-        return module == _AUTHORING_IMPORT_MODULE or module.startswith(_AUTHORING_IMPORT_MODULE + ".")
+        return _is_authoring_module(node.module or "")
     if isinstance(node, ast.Import):
-        return any(
-            alias.name == _AUTHORING_IMPORT_MODULE or alias.name.startswith(_AUTHORING_IMPORT_MODULE + ".")
-            for alias in node.names
-        )
+        return any(_is_authoring_module(alias.name) for alias in node.names)
     return False
 
 
+def _mixed_authoring_import_aliases(node: ast.stmt) -> tuple[list[str], list[str]] | None:
+    """Classify a comma-separated ``import a, b`` that mixes import surfaces.
+
+    Only ``ast.Import`` (``import x, y``) can bind several modules in one
+    statement; a ``from X import ...`` binds a single module, so it is
+    all-or-nothing and never "mixed". Returns ``(authoring, runtime)`` alias
+    names when the statement mixes at least one authoring module with at least
+    one non-authoring one, else ``None`` (a pure-authoring or pure-runtime
+    ``import``, which the caller drops whole or leaves untouched respectively).
+    """
+    if not isinstance(node, ast.Import):
+        return None
+    authoring = [alias.name for alias in node.names if _is_authoring_module(alias.name)]
+    runtime = [alias.name for alias in node.names if not _is_authoring_module(alias.name)]
+    if authoring and runtime:
+        return authoring, runtime
+    return None
+
+
 def _attr_root_name(node: ast.expr) -> str | None:
     """Return the root ``Name`` id of an attribute chain (``a.b.c`` -> ``a``).
 
@@ -971,7 +1000,7 @@ def _strip_authoring_constructs(source_code: str) -> str:
     - re-running an ``@task`` / ``@pipeline`` / ``@subpipeline`` decorator
       replaces the function with a ``CallableRef`` recorder, which raises at
       call time because there is no active ``@pipeline`` trace context;
-    - on a thin image the ``from tangle_deploy.python_pipeline import ...``
+    - on a thin image the ``from tangle_cli.python_pipeline import ...``
       import itself can fail with ``ImportError``.
 
     This removes them via surgical AST line-range deletion (mirroring
@@ -986,9 +1015,12 @@ def _strip_authoring_constructs(source_code: str) -> str:
 
     Scope of the strip (intentional v1 boundaries):
 
-    - imports: only ``tangle_deploy.python_pipeline`` (and submodules) are
-      dropped — see ``_is_authoring_import``. Other ``tangle_deploy.*`` runtime
-      helpers are preserved.
+    - imports: only the registered authoring modules (and submodules) are
+      dropped — see ``_is_authoring_import``. Other runtime helpers that merely
+      share a top-level name are preserved. A comma-separated ``import a, b``
+      that mixes the authoring surface with a runtime module raises
+      :class:`AuthoringStripError` (it cannot be partially line-deleted) — see
+      ``_mixed_authoring_import_aliases``.
     - decorators: matched by trailing NAME (``task`` / ``pipeline`` /
       ``subpipeline``), not by import resolution — see ``_decorator_called_name``
       for the limitation. Unrelated decorators (``@functools.cache``,
@@ -1037,6 +1069,27 @@ def _strip_authoring_constructs(source_code: str) -> str:
     for node in ast.walk(tree):
         # Authoring imports — delete the whole (possibly multi-line) statement.
         if isinstance(node, (ast.Import, ast.ImportFrom)) and _is_authoring_import(node):
+            # A comma-separated ``import authoring_surface, os`` mixes the
+            # authoring surface with a runtime module on one statement. We drop
+            # authoring imports by line range, which cannot delete just part of
+            # a statement — dropping the whole line would take the runtime
+            # ``import os`` with it (silent NameError in the baked program),
+            # while keeping it would leave the authoring import un-stripped. Fail
+            # fast with split guidance rather than bake a broken program.
+            mixed = _mixed_authoring_import_aliases(node)
+            if mixed is not None:
+                authoring_names, runtime_names = mixed
+                raise AuthoringStripError(
+                    "import statement mixes the python-pipeline authoring "
+                    f"surface ({', '.join(authoring_names)}) with runtime "
+                    f"import(s) ({', '.join(runtime_names)}) on one line. The "
+                    "authoring import is stripped from the baked runtime "
+                    "program, but a comma-separated `import a, b` cannot be "
+                    "partially line-deleted without corrupting the kept import. "
+                    "Split the authoring import onto its own line (e.g. `import "
+                    "tangle_cli.python_pipeline as tp` separate from `import "
+                    "os`)."
+                )
             start = node.lineno
             end = node.end_lineno or node.lineno
             removed.update(range(start, end + 1))
@@ -1686,7 +1739,8 @@ def generate_component_yaml(
         path_annotation_mode: ``"oss"`` always records source/YAML paths relative
             to their common ancestor. ``"td_legacy"`` only uses that relative
             common-root behavior inside a git checkout; outside git it records
-            ``file_path.name`` / ``output_path.name`` like legacy tangle-deploy.
+            ``file_path.name`` / ``output_path.name`` to preserve the legacy
+            downstream driver's historical basename-only snapshots.
 
     Returns:
         True on success, False on failure.
@@ -1764,8 +1818,9 @@ def generate_component_yaml(
         # Use the common ancestor of source and output so both paths are clean
         # forward references (no ".."). This lets later local maintenance
         # commands find the source even when YAML is generated into a separate
-        # output directory. TD legacy compatibility keeps basename-only paths
-        # outside a git checkout to preserve historical snapshots.
+        # output directory. Legacy (``td_legacy``) compatibility keeps
+        # basename-only paths outside a git checkout to preserve historical
+        # snapshots.
         resolved_source = file_path.resolve()
         resolved_output = output_path.resolve()
         common_dir = Path(os.path.commonpath([resolved_source, resolved_output]))

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/packages/tangle-cli/src/tangle_cli/pipeline_run_manager.py

@@ -28,6 +28,7 @@ from .logger import Logger, get_default_logger
 from .pipeline_dehydrator import DehydrateChoice, PipelineDehydrator
 from .pipeline_hydrator import HydrationError, PipelineHydrator
 from .pipeline_run_details import PipelineRunDetails
+from .pipelines import collect_pipeline_spec_errors
 from .pipeline_run_search import PipelineRunSearch
 from .utils import dump_yaml
 
@@ -378,6 +379,26 @@ class PipelineRunHooks:
         """Hook for TD JOB_CONFIG time input / scheduled runtime behavior."""
         return run_args
 
+    def validate_pipeline_for_run(
+        self,
+        pipeline_spec: dict[str, Any],
+        *,
+        pipeline_path: str | Path | None,
+        effective_path: str | Path | None,
+        skip_validation: bool,
+    ) -> list[str]:
+        """Return submit-time validation errors for a prepared pipeline spec.
+
+        The OSS default enforces the same local authoring validator used by
+        ``tangle pipeline validate``. Downstreams can override or extend this
+        hook with stricter schema/input validators.
+        """
+
+        del pipeline_path, effective_path
+        if skip_validation:
+            return []
+        return collect_pipeline_spec_errors(pipeline_spec)
+
     def transform_run_name(
         self,
         run_name: str,
@@ -834,6 +855,11 @@ class PipelineRunManager(TangleCliHandler):
             for parameter in parameters.values()
         )
 
+    @staticmethod
+    def _raise_pipeline_validation_error(validation_errors: list[str]) -> None:
+        if validation_errors:
+            raise PipelineRunError("Pipeline validation failed:\n  - " + "\n  - ".join(validation_errors))
+
     def load_pipeline_for_submit(
         self,
         pipeline_path: str | Path,
@@ -909,13 +935,15 @@ class PipelineRunManager(TangleCliHandler):
         pipeline_path: str | Path | None = None,
         run_as: str | None = None,
         hydrate: bool = True,
+        skip_validation: bool = False,
     ) -> PipelineSubmitPayload:
         """Prepare the generic submit payload from a pipeline spec.
 
         The order here is the submit-body contract shared by OSS and TD:
         prepare the spec, prepare runtime arguments, expand run-name templates,
-        convert/sanitize the payload, then merge downstream/default annotations
-        before caller-supplied annotations override them.
+        validate the prepared authoring spec, convert/sanitize the payload, then
+        merge downstream/default annotations before caller-supplied annotations
+        override them.
         """
 
         prepared_spec = self.prepare_pipeline_spec_for_submit(
@@ -926,6 +954,13 @@ class PipelineRunManager(TangleCliHandler):
         )
         prepared_run_args = self.hooks.prepare_run_arguments(prepared_spec, run_args)
         prepared_spec = self.apply_run_name_template(prepared_spec, prepared_run_args)
+        validation_errors = self.hooks.validate_pipeline_for_run(
+            prepared_spec,
+            pipeline_path=pipeline_path,
+            effective_path=None,
+            skip_validation=skip_validation,
+        )
+        self._raise_pipeline_validation_error(validation_errors)
         payload = self.convert_yaml_to_payload(copy.deepcopy(prepared_spec), prepared_run_args)
         payload = self.sanitize_submit_payload(payload)
         root_task = payload["root_task"]
@@ -961,6 +996,7 @@ class PipelineRunManager(TangleCliHandler):
         pipeline_path: str | Path | None = None,
         run_as: str | None = None,
         hydrate: bool = True,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         """Build a submit body from an already-prepared pipeline spec."""
 
@@ -971,6 +1007,7 @@ class PipelineRunManager(TangleCliHandler):
             pipeline_path=pipeline_path,
             run_as=run_as,
             hydrate=hydrate,
+            skip_validation=skip_validation,
         ).to_body()
 
     def prepare_submit_payload(
@@ -982,6 +1019,7 @@ class PipelineRunManager(TangleCliHandler):
         hydrate: bool = True,
         run_as: str | None = None,
         resolution_overrides: dict[str, Any] | None = None,
+        skip_validation: bool = False,
     ) -> PipelineSubmitPayload:
         pipeline_spec = self.load_pipeline_for_submit(
             pipeline_path,
@@ -995,6 +1033,7 @@ class PipelineRunManager(TangleCliHandler):
             pipeline_path=pipeline_path,
             run_as=run_as,
             hydrate=hydrate,
+            skip_validation=skip_validation,
         )
 
     def build_submit_body(
@@ -1006,6 +1045,7 @@ class PipelineRunManager(TangleCliHandler):
         hydrate: bool = True,
         run_as: str | None = None,
         resolution_overrides: dict[str, Any] | None = None,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         return self.prepare_submit_payload(
             pipeline_path,
@@ -1014,6 +1054,7 @@ class PipelineRunManager(TangleCliHandler):
             hydrate=hydrate,
             run_as=run_as,
             resolution_overrides=resolution_overrides,
+            skip_validation=skip_validation,
         ).to_body()
 
     @staticmethod
@@ -1117,6 +1158,7 @@ class PipelineRunManager(TangleCliHandler):
         run_as: str | None = None,
         hydrate: bool = True,
         attempt: int = 1,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         payload = self.prepare_submit_payload_from_spec(
             pipeline_spec,
@@ -1125,6 +1167,7 @@ class PipelineRunManager(TangleCliHandler):
             pipeline_path=pipeline_path,
             run_as=run_as,
             hydrate=hydrate,
+            skip_validation=skip_validation,
         )
         return self.submit_prepared_payload(payload, pipeline_path=pipeline_path, attempt=attempt)
 
@@ -1138,6 +1181,7 @@ class PipelineRunManager(TangleCliHandler):
         run_as: str | None = None,
         resolution_overrides: dict[str, Any] | None = None,
         attempt: int = 1,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         payload = self.prepare_submit_payload(
             pipeline_path,
@@ -1146,6 +1190,7 @@ class PipelineRunManager(TangleCliHandler):
             hydrate=hydrate,
             run_as=run_as,
             resolution_overrides=resolution_overrides,
+            skip_validation=skip_validation,
         )
         return self.submit_prepared_payload(payload, pipeline_path=pipeline_path, attempt=attempt)
 
@@ -1909,6 +1954,7 @@ class PipelineRunManager(TangleCliHandler):
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
         submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         """Submit/wait/retry an already hydrated/validated in-memory spec."""
 
@@ -1924,6 +1970,7 @@ class PipelineRunManager(TangleCliHandler):
                 pipeline_path=pipeline_path,
                 run_as=run_as,
                 hydrate=hydrate,
+                skip_validation=skip_validation,
             ).to_body()
 
         return self._run_body_factory(
@@ -1960,6 +2007,7 @@ class PipelineRunManager(TangleCliHandler):
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
         submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
+        skip_validation: bool = False,
     ) -> dict[str, Any]:
         """Submit (and optionally wait for) a pipeline with lifecycle hooks.
 
@@ -1980,6 +2028,7 @@ class PipelineRunManager(TangleCliHandler):
                 hydrate=hydrate,
                 run_as=run_as,
                 resolution_overrides=resolution_overrides,
+                skip_validation=skip_validation,
             ).to_body()
 
         return self._run_body_factory(

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/packages/tangle-cli/src/tangle_cli/pipeline_runner.py

@@ -109,24 +109,6 @@ class PipelineRunnerHooks(PipelineRunHooks):
 
         return pipeline_spec
 
-    def validate_pipeline_for_run(
-        self,
-        pipeline_spec: dict[str, Any],
-        *,
-        pipeline_path: str | Path,
-        effective_path: str | Path | None,
-        skip_validation: bool,
-    ) -> list[str]:
-        """Return validation errors for a prepared pipeline spec.
-
-        The OSS default intentionally does not enforce the local authoring
-        validator here: submit-time API validation remains the source of truth,
-        while downstreams can plug in stricter schema/input validators.
-        """
-
-        del pipeline_spec, pipeline_path, effective_path, skip_validation
-        return []
-
     def has_layout(self, pipeline_spec: Mapping[str, Any]) -> bool:
         """Return True when a pipeline graph already has non-zero coordinates."""
 
@@ -547,6 +529,7 @@ class PipelineRunner(PipelineRunnerHooks, PipelineRunManager):
                 pipeline_path=pipeline_path,
                 run_as=run_as,
                 hydrate=False,
+                skip_validation=skip_validation,
             )
             submit_payloads[attempt] = submit_payload
             return submit_payload.to_body()

{tangle_cli-0.1.2 → tangle_cli-0.1.3}/packages/tangle-cli/src/tangle_cli/pipelines.py

@@ -89,8 +89,8 @@ def validate_pipeline_file(path: str | Path) -> dict[str, Any]:
     return pipeline
 
 
-def validate_pipeline_spec(pipeline: Mapping[str, Any]) -> None:
-    """Validate the OSS-compatible local pipeline shape.
+def collect_pipeline_spec_errors(pipeline: Mapping[str, Any]) -> list[str]:
+    """Return OSS-compatible local pipeline shape validation errors.
 
     This is a pragmatic validator for local authoring workflows. It focuses on
     the graph structure that the CLI commands consume rather than provider-specific
@@ -99,6 +99,13 @@ def validate_pipeline_spec(pipeline: Mapping[str, Any]) -> None:
 
     errors: list[str] = []
     _validate_root_pipeline(pipeline, errors)
+    return errors
+
+
+def validate_pipeline_spec(pipeline: Mapping[str, Any]) -> None:
+    """Validate the OSS-compatible local pipeline shape."""
+
+    errors = collect_pipeline_spec_errors(pipeline)
     if errors:
         details = "\n".join(f"- {error}" for error in errors)
         raise PipelineValidationError(f"Pipeline validation failed:\n{details}")

tangle_cli-0.1.3/packages/tangle-cli/src/tangle_cli/python_pipeline/__init__.py

@@ -0,0 +1,43 @@
+"""Python-first authoring surface for Tangle pipelines.
+
+End users write::
+
+    from tangle_cli.python_pipeline import pipeline, task, registered, ref, raw, subpipeline, TaskEnv, In, Out
+
+``cfg`` is NOT a top-level export — it is a parameter the framework
+injects into the user's pipeline function at trace time. Importing the
+:class:`tangle_cli.python_pipeline.cfg.Cfg` class is reserved for the
+compile driver.
+
+``import tangle_cli.python_pipeline`` is kept light: it does not
+eagerly import the heavy ``tangle_cli.component_generator`` codegen
+module or the tracer machinery.
+
+Module map: authoring entry points live in :mod:`.pipeline`,
+:mod:`.task`, :mod:`.subpipeline`, :mod:`.registered`, :mod:`.ref` and
+:mod:`.raw`; the trace-time IR is built in :mod:`.trace` / :mod:`.graph`
+and lowered to the dehydrated dict shape by :mod:`.emit`.
+"""
+from __future__ import annotations
+
+from .pipeline import pipeline
+from .raw import raw
+from .ref import ref
+from .registered import registered
+from .subpipeline import subpipeline
+from .task import task
+from .task_env import TaskEnv
+from .types import In, Out, Outputs
+
+__all__ = [
+    "pipeline",
+    "task",
+    "registered",
+    "ref",
+    "raw",
+    "subpipeline",
+    "TaskEnv",
+    "In",
+    "Out",
+    "Outputs",
+]