tangle-cli 0.0.1a3__tar.gz → 0.1.1__tar.gz

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tangle-cli
-Version: 0.0.1a3
+Version: 0.1.1
 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>
@@ -13,7 +13,7 @@ Requires-Dist: platformdirs>=4.10.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.32.0
-Requires-Dist: tangle-api==0.0.1a3
+Requires-Dist: tangle-api==0.1.0
 Requires-Dist: tomli>=2.0 ; python_full_version < '3.11'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://tangleml.com
@@ -126,7 +126,11 @@ uv run tangle api --help
 uv run tangle sdk pipelines validate pipeline.yaml
 ```
 
-Custom API/codegen users can still run codegen from the fully capable install; generating bindings does not require removing the official `tangle-api` package. For project-local generated APIs, generate into a local source tree such as `src/tangle_api/generated` (and `src/tangle_api/schema/openapi.json` when you want `tangle api --schema-source official`) and run from that project so local `src/tangle_api` shadows site-packages. For packaged custom APIs, publish/provide a distribution named `tangle-api` with a version compatible with this `tangle-cli` release (for example `0.0.1a3+yourorg` for a `tangle-cli` dependency on `tangle-api==0.0.1a3`) via a private index, `--find-links`, or uv sources. As an expert escape hatch, `--no-deps` installs only `tangle-cli` and skips all dependencies, so that environment must manually provide every required runtime dependency plus its generated/custom `tangle_api`; this is acceptable for controlled codegen/custom scenarios but not normal UX.
+Custom API/codegen users can still run codegen from the fully capable install; generating bindings does not require removing the official `tangle-api` package. For project-local generated APIs, generate into a local source tree such as `src/tangle_api/generated` (and `src/tangle_api/schema/openapi.json` when you want `tangle api --schema-source official`) and run from that project so local `src/tangle_api` shadows site-packages. For packaged custom APIs, publish/provide a distribution named `tangle-api` with a version compatible with this `tangle-cli` release (for example `0.1.0+yourorg` for a `tangle-cli` dependency on `tangle-api==0.1.0`) via a private index, `--find-links`, or uv sources. As an expert escape hatch, `--no-deps` installs only `tangle-cli` and skips all dependencies, so that environment must manually provide every required runtime dependency plus its generated/custom `tangle_api`; this is acceptable for controlled codegen/custom scenarios but not normal UX.
+
+## Agent skills
+
+This repo includes the Tangent agent-skill bundle under `skills/tangent/`. The bundle was ported from `tangle-cli-lab` and now treats this repository as the canonical source. It drives the public `tangle` / `tangle-cli` command surface, assumes the default `tangle-cli` install includes `tangle-api`, and keeps relative references (`agents/*.md`, `references/*.md`) self-contained for Pi-style skill loaders. The source distribution includes `skills/**` so downstream source-based consumers can inspect or vendor the skill docs with the release.
 
 ## Quick command examples
 
@@ -371,7 +375,7 @@ uv run python -m tangle_cli.openapi.codegen \
   --out src/tangle_api/generated
 ```
 
-That project-local `tangle_api` package can be an editable/package source tree. If you ship the custom API bindings as a wheel or source distribution, use the distribution name `tangle-api` and a compatible version for the `tangle-cli` release you are using. A PEP 440 local version such as `0.0.1a3+yourorg` can satisfy a public `==0.0.1a3` dependency while distinguishing your private build. Provide that package through your private index, `--find-links`, or uv source configuration so the resolver chooses it instead of the public official package.
+That project-local `tangle_api` package can be an editable/package source tree. If you ship the custom API bindings as a wheel or source distribution, use the distribution name `tangle-api` and a compatible version for the `tangle-cli` release you are using. A PEP 440 local version such as `0.1.0+yourorg` can satisfy a public `==0.1.0` dependency while distinguishing your private build. Provide that package through your private index, `--find-links`, or uv source configuration so the resolver chooses it instead of the public official package.
 
 Generate from a backend checkout explicitly:
 

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/README.md

@@ -101,7 +101,11 @@ uv run tangle api --help
 uv run tangle sdk pipelines validate pipeline.yaml
 ```
 
-Custom API/codegen users can still run codegen from the fully capable install; generating bindings does not require removing the official `tangle-api` package. For project-local generated APIs, generate into a local source tree such as `src/tangle_api/generated` (and `src/tangle_api/schema/openapi.json` when you want `tangle api --schema-source official`) and run from that project so local `src/tangle_api` shadows site-packages. For packaged custom APIs, publish/provide a distribution named `tangle-api` with a version compatible with this `tangle-cli` release (for example `0.0.1a3+yourorg` for a `tangle-cli` dependency on `tangle-api==0.0.1a3`) via a private index, `--find-links`, or uv sources. As an expert escape hatch, `--no-deps` installs only `tangle-cli` and skips all dependencies, so that environment must manually provide every required runtime dependency plus its generated/custom `tangle_api`; this is acceptable for controlled codegen/custom scenarios but not normal UX.
+Custom API/codegen users can still run codegen from the fully capable install; generating bindings does not require removing the official `tangle-api` package. For project-local generated APIs, generate into a local source tree such as `src/tangle_api/generated` (and `src/tangle_api/schema/openapi.json` when you want `tangle api --schema-source official`) and run from that project so local `src/tangle_api` shadows site-packages. For packaged custom APIs, publish/provide a distribution named `tangle-api` with a version compatible with this `tangle-cli` release (for example `0.1.0+yourorg` for a `tangle-cli` dependency on `tangle-api==0.1.0`) via a private index, `--find-links`, or uv sources. As an expert escape hatch, `--no-deps` installs only `tangle-cli` and skips all dependencies, so that environment must manually provide every required runtime dependency plus its generated/custom `tangle_api`; this is acceptable for controlled codegen/custom scenarios but not normal UX.
+
+## Agent skills
+
+This repo includes the Tangent agent-skill bundle under `skills/tangent/`. The bundle was ported from `tangle-cli-lab` and now treats this repository as the canonical source. It drives the public `tangle` / `tangle-cli` command surface, assumes the default `tangle-cli` install includes `tangle-api`, and keeps relative references (`agents/*.md`, `references/*.md`) self-contained for Pi-style skill loaders. The source distribution includes `skills/**` so downstream source-based consumers can inspect or vendor the skill docs with the release.
 
 ## Quick command examples
 
@@ -346,7 +350,7 @@ uv run python -m tangle_cli.openapi.codegen \
   --out src/tangle_api/generated
 ```
 
-That project-local `tangle_api` package can be an editable/package source tree. If you ship the custom API bindings as a wheel or source distribution, use the distribution name `tangle-api` and a compatible version for the `tangle-cli` release you are using. A PEP 440 local version such as `0.0.1a3+yourorg` can satisfy a public `==0.0.1a3` dependency while distinguishing your private build. Provide that package through your private index, `--find-links`, or uv source configuration so the resolver chooses it instead of the public official package.
+That project-local `tangle_api` package can be an editable/package source tree. If you ship the custom API bindings as a wheel or source distribution, use the distribution name `tangle-api` and a compatible version for the `tangle-cli` release you are using. A PEP 440 local version such as `0.1.0+yourorg` can satisfy a public `==0.1.0` dependency while distinguishing your private build. Provide that package through your private index, `--find-links`, or uv source configuration so the resolver chooses it instead of the public official package.
 
 Generate from a backend checkout explicitly:
 

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/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.0"
+    __version__ = "0.1.1"
 
 __all__ = ["TangleDynamicDiscoveryClient", "__version__"]

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/packages/tangle-cli/src/tangle_cli/pipeline_run_manager.py

@@ -37,8 +37,8 @@ _FAILURE_EARLY_EXIT_STATUSES = ("FAILED", "SYSTEM_ERROR")
 _EXECUTION_STATE_TIMINGS_METADATA_KEY = "execution_state_timings"
 _EXECUTION_STATE_TIMING_MONOTONIC_METADATA_KEY = "_execution_state_timing_monotonic"
 _SUBMISSION_ID_ANNOTATION_KEY = "tangle-cli/submission-id"
-_SUBMIT_RECOVERY_LOOKUP_ATTEMPTS = 2
-_SUBMIT_RECOVERY_LOOKUP_DELAY_SECONDS = 0.1
+_SUBMIT_RECOVERY_BACKOFF_SECONDS = (0.5, 1.0, 2.0, 4.0, 8.0, 16.0)
+_DEFAULT_SUBMIT_RECOVERY_ATTEMPTS = 2
 
 
 class PipelineRunError(RuntimeError):
@@ -1529,6 +1529,11 @@ class PipelineRunManager(TangleCliHandler):
         submission_id = annotations.get(_SUBMISSION_ID_ANNOTATION_KEY)
         return str(submission_id) if submission_id else None
 
+    @staticmethod
+    def _submit_recovery_backoff_seconds(submit_recovery_attempts: int) -> tuple[float, ...]:
+        attempt_count = max(0, min(int(submit_recovery_attempts), len(_SUBMIT_RECOVERY_BACKOFF_SECONDS)))
+        return _SUBMIT_RECOVERY_BACKOFF_SECONDS[:attempt_count]
+
     def _submitted_runs_for_submission_id(self, submission_id: str) -> list[dict[str, Any]]:
         query = {
             "and": [
@@ -1554,14 +1559,32 @@ class PipelineRunManager(TangleCliHandler):
         self,
         *,
         submission_id: str | None,
+        submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     ) -> dict[str, Any] | None:
         if not submission_id:
             return None
-        for lookup_attempt in range(1, _SUBMIT_RECOVERY_LOOKUP_ATTEMPTS + 1):
+        backoff_seconds = self._submit_recovery_backoff_seconds(submit_recovery_attempts)
+        total_lookup_attempts = len(backoff_seconds)
+        if total_lookup_attempts == 0:
+            self.logger.warn(
+                "Submit recovery lookup disabled "
+                f"({_SUBMISSION_ID_ANNOTATION_KEY}={submission_id}, "
+                f"submit_recovery_attempts={submit_recovery_attempts}); "
+                "resubmitting the same frozen body with preserved inputs."
+            )
+            return None
+        for lookup_attempt, delay_seconds in enumerate(backoff_seconds, start=1):
+            self.logger.info(
+                "Waiting "
+                f"{delay_seconds:g}s before checking whether failed submit already created a pipeline run "
+                f"({_SUBMISSION_ID_ANNOTATION_KEY}={submission_id}, "
+                f"lookup_attempt={lookup_attempt}/{total_lookup_attempts})"
+            )
+            time.sleep(delay_seconds)
             self.logger.info(
                 "Checking whether failed submit already created a pipeline run "
                 f"({_SUBMISSION_ID_ANNOTATION_KEY}={submission_id}, "
-                f"lookup_attempt={lookup_attempt}/{_SUBMIT_RECOVERY_LOOKUP_ATTEMPTS})"
+                f"lookup_attempt={lookup_attempt}/{total_lookup_attempts})"
             )
             try:
                 matches = self._submitted_runs_for_submission_id(submission_id)
@@ -1598,8 +1621,6 @@ class PipelineRunManager(TangleCliHandler):
                     f"{_SUBMISSION_ID_ANNOTATION_KEY}={submission_id}: {', '.join(run_ids) or matches!r}. "
                     "Refusing to submit a duplicate."
                 )
-            if lookup_attempt < _SUBMIT_RECOVERY_LOOKUP_ATTEMPTS:
-                time.sleep(_SUBMIT_RECOVERY_LOOKUP_DELAY_SECONDS)
         self.logger.warn(
             "No existing pipeline run found after submit failure "
             f"({_SUBMISSION_ID_ANNOTATION_KEY}={submission_id}); "
@@ -1647,6 +1668,7 @@ class PipelineRunManager(TangleCliHandler):
         timeout_clock: str = "monotonic",
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
+        submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
         metadata_factory: Callable[
             [int, PipelineRunContext | None, Exception | None], dict[str, Any]
         ] | None = None,
@@ -1723,6 +1745,7 @@ class PipelineRunManager(TangleCliHandler):
                         if reused_after_submit_failure:
                             recovered_response = self._recover_submitted_run_after_submit_error(
                                 submission_id=self._submission_id_from_body(body),
+                                submit_recovery_attempts=submit_recovery_attempts,
                             )
                         if recovered_response is not None:
                             response = self._adopt_submitted_run(
@@ -1754,6 +1777,7 @@ class PipelineRunManager(TangleCliHandler):
                                 )
                                 recovered_response = self._recover_submitted_run_after_submit_error(
                                     submission_id=submission_id_for_recovery,
+                                    submit_recovery_attempts=submit_recovery_attempts,
                                 )
                                 if recovered_response is None:
                                     self.hooks.on_submit_error(submit_exc, context=context)
@@ -1834,6 +1858,7 @@ class PipelineRunManager(TangleCliHandler):
         timeout_clock: str = "monotonic",
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
+        submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     ) -> dict[str, Any]:
         """Submit/wait/retry an already prepared submit body.
 
@@ -1862,6 +1887,7 @@ class PipelineRunManager(TangleCliHandler):
             timeout_clock=timeout_clock,
             exit_on_first_failure=exit_on_first_failure,
             metadata=metadata,
+            submit_recovery_attempts=submit_recovery_attempts,
         )
 
     def run_pipeline_spec(
@@ -1882,6 +1908,7 @@ class PipelineRunManager(TangleCliHandler):
         timeout_clock: str = "monotonic",
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
+        submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     ) -> dict[str, Any]:
         """Submit/wait/retry an already hydrated/validated in-memory spec."""
 
@@ -1911,6 +1938,7 @@ class PipelineRunManager(TangleCliHandler):
             timeout_clock=timeout_clock,
             exit_on_first_failure=exit_on_first_failure,
             metadata=metadata,
+            submit_recovery_attempts=submit_recovery_attempts,
         )
 
     def run_pipeline(
@@ -1931,6 +1959,7 @@ class PipelineRunManager(TangleCliHandler):
         timeout_clock: str = "monotonic",
         exit_on_first_failure: bool = False,
         metadata: dict[str, Any] | None = None,
+        submit_recovery_attempts: int = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     ) -> dict[str, Any]:
         """Submit (and optionally wait for) a pipeline with lifecycle hooks.
 
@@ -1965,6 +1994,7 @@ class PipelineRunManager(TangleCliHandler):
             timeout_clock=timeout_clock,
             exit_on_first_failure=exit_on_first_failure,
             metadata=metadata,
+            submit_recovery_attempts=submit_recovery_attempts,
         )
 
 

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/packages/tangle-cli/src/tangle_cli/pipeline_runner.py

@@ -507,6 +507,7 @@ class PipelineRunner(PipelineRunnerHooks, PipelineRunManager):
         open_browser: bool = False,
         include_next_steps: bool = False,
         metadata: dict[str, Any] | None = None,
+        submit_recovery_attempts: int = 2,
     ) -> dict[str, Any]:
         """Run a pipeline path through generic preparation + lifecycle hooks.
 
@@ -603,6 +604,7 @@ class PipelineRunner(PipelineRunnerHooks, PipelineRunManager):
                 timeout_clock=timeout_clock,
                 exit_on_first_failure=exit_on_first_failure,
                 metadata_factory=metadata_factory,
+                submit_recovery_attempts=submit_recovery_attempts,
             )
             context = result.get("context")
             attempt = context.attempt if isinstance(context, PipelineRunContext) else max(preparations)

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/packages/tangle-cli/src/tangle_cli/pipeline_runs_cli.py

@@ -28,6 +28,7 @@ from .cli_options import (
 from .logger import Logger, logger_for_log_type
 from .pipeline_run_annotations import AnnotationManager
 from .pipeline_run_manager import (
+    _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     PipelineRunError,
     PipelineRunHooks,
     PipelineRunManager,
@@ -166,6 +167,15 @@ def pipeline_runs_submit(
     auth_header: AuthHeaderOption = None,
     header: HeaderOption = None,
     config: ConfigOption = None,
+    submit_recovery_attempts: Annotated[
+        int,
+        Parameter(
+            help=(
+                "Number of post-failed-submit recovery lookups before resubmitting; "
+                "higher values wait longer for delayed run registration."
+            )
+        ),
+    ] = _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS,
     log_type: LogTypeOption = "console",
 ) -> None:
     """Hydrate and submit a local pipeline YAML file as a run."""
@@ -181,6 +191,7 @@ def pipeline_runs_submit(
         "run_as": (run_as, None),
         "trusted_source": (trusted_source, None),
         "trusted_hydration_cli": ("trusted_hydration_cli", trusted_hydration, None, False),
+        "submit_recovery_attempts": (submit_recovery_attempts, _DEFAULT_SUBMIT_RECOVERY_ATTEMPTS),
         "log_type": (log_type, "console"),
         **api_arg_specs(base_url=base_url, token=token, auth_header=auth_header, header=header),
     }
@@ -194,7 +205,12 @@ def pipeline_runs_submit(
         }
         if args.dry_run:
             return manager.build_submit_body(args.pipeline_path, **kwargs)
-        return manager.submit_pipeline(args.pipeline_path, **kwargs)
+        result = manager.run_pipeline(
+            args.pipeline_path,
+            **kwargs,
+            submit_recovery_attempts=args.submit_recovery_attempts,
+        )
+        return result["response"]
 
     _run_manager_action(config, base_url, specs, action)
 

{tangle_cli-0.0.1a3 → tangle_cli-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tangle-cli"
-version = "0.0.1a3"
+version = "0.1.1"
 description = "CLI for Tangle, the open-source ML pipeline orchestration platform"
 readme = "README.md"
 authors = [
@@ -18,7 +18,7 @@ dependencies = [
     "pydantic>=2.0",
     "pyyaml>=6.0",
     "requests>=2.32.0",
-    "tangle-api==0.0.1a3",
+    "tangle-api==0.1.0",
     "tomli>=2.0; python_version < '3.11'",
 ]
 
@@ -42,6 +42,7 @@ build-backend = "uv_build"
 
 [tool.uv.build-backend]
 module-root = "packages/tangle-cli/src"
+source-include = ["skills/**"]
 
 [tool.uv.sources]
 cloud-pipelines-backend = { git = "https://github.com/TangleML/tangle", rev = "stable_cli" }