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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tangle-cli
-Version: 0.1.0
+Version: 0.1.2
 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.1.0
+Requires-Dist: tangle-api==0.1.1
 Requires-Dist: tomli>=2.0 ; python_full_version < '3.11'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://tangleml.com

{tangle_cli-0.1.0 → tangle_cli-0.1.2}/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.1.0 → tangle_cli-0.1.2}/packages/tangle-cli/src/tangle_cli/openapi/codegen.py

@@ -510,7 +510,7 @@ def _param_signature(
             body_names.append(name)
             if parameter.required:
                 required_body_names.add(name)
-    include_body = has_request_body and not body_names
+    include_body = has_request_body
     if include_body:
         body_annotation = "dict[str, Any] | None" if raw_body_override else "Any"
         signature_parts.append(f"body: {body_annotation} = None")
@@ -537,6 +537,12 @@ def _body_dict_literal(names: list[str], required_names: set[str]) -> str:
     return "{" + f"**{required_literal}, **{{{optional_expr}}}" + "}"
 
 
+def _merged_body_dict_literal(names: list[str], required_names: set[str]) -> str:
+    """Return request JSON with generic body fields overridden by named fields."""
+
+    return f"{{**(body or {{}}), **{_body_dict_literal(names, required_names)}}}"
+
+
 def _validate_operation_path(path: str) -> None:
     """Reject OpenAPI operation paths that could override the configured origin."""
 
@@ -625,7 +631,9 @@ def generate_operations(
             f"            path_params={_dict_literal(path_names)},",
             f"            params={_dict_literal(query_names)},",
         ])
-        if body_names:
+        if body_names and include_body:
+            lines.append(f"            json_data={_merged_body_dict_literal(body_names, required_body_names)},")
+        elif body_names:
             lines.append(f"            json_data={_body_dict_literal(body_names, required_body_names)},")
         elif include_body:
             lines.append("            json_data=body,")

{tangle_cli-0.1.0 → tangle_cli-0.1.2}/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.1.0 → tangle_cli-0.1.2}/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.1.0 → tangle_cli-0.1.2}/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.1.0 → tangle_cli-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tangle-cli"
-version = "0.1.0"
+version = "0.1.2"
 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.1.0",
+    "tangle-api==0.1.1",
     "tomli>=2.0; python_version < '3.11'",
 ]