stackgen-sdk 0.4.0rc5__tar.gz → 0.4.0rc7__tar.gz

{stackgen_sdk-0.4.0rc5 → stackgen_sdk-0.4.0rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stackgen-sdk
-Version: 0.4.0rc5
+Version: 0.4.0rc7
 Summary: StackGen SDK — Aiden, SRE, and Vault from one client
 Project-URL: Homepage, https://appcd-dev.github.io/stackgen-sdk/
 Project-URL: Documentation, https://appcd-dev.github.io/stackgen-sdk/

{stackgen_sdk-0.4.0rc5 → stackgen_sdk-0.4.0rc7}/src/stackgen/_http.py

@@ -12,7 +12,26 @@ from typing import Any, Callable
 
 from stackgen.errors import HttpError, TimeoutError
 
-_RETRYABLE = {429, 502, 503, 504}
+
+def is_retryable_http_status(status: int) -> bool:
+    """GET statuses that self-heal: rate limit and any 5xx (rollout blips, gateway errors)."""
+    return status == 429 or 500 <= status <= 599
+
+
+def is_transient_http_error(err: BaseException) -> bool:
+    """True for retryable HTTP statuses and transport failures wrapped as HttpError."""
+    if not isinstance(err, HttpError):
+        return False
+    if err.status_code is None:
+        return True
+    return is_retryable_http_status(err.status_code)
+
+
+def http_status_snippet(err: BaseException | None) -> str:
+    """Label fragment for TimeoutError / subscribe snippets."""
+    if isinstance(err, HttpError) and err.status_code is not None:
+        return f"status={err.status_code}"
+    return "status=network_error"
 
 
 def query(org_id: str) -> str:
@@ -50,7 +69,7 @@ def request(
                 return json.loads(raw.decode("utf-8"))
         except urllib.error.HTTPError as err:
             detail = err.read().decode("utf-8", errors="replace")
-            if method == "GET" and err.code in _RETRYABLE and attempt < retries:
+            if method == "GET" and is_retryable_http_status(err.code) and attempt < retries:
                 time.sleep(min(2**attempt, 8))
                 continue
             raise HttpError(

{stackgen_sdk-0.4.0rc5 → stackgen_sdk-0.4.0rc7}/src/stackgen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.0rc5'
-__version_tuple__ = version_tuple = (0, 4, 0, 'rc5')
+__version__ = version = '0.4.0rc7'
+__version_tuple__ = version_tuple = (0, 4, 0, 'rc7')
 
 __commit_id__ = commit_id = None

{stackgen_sdk-0.4.0rc5 → stackgen_sdk-0.4.0rc7}/src/stackgen/aiden/ask.py

@@ -12,7 +12,7 @@ from stackgen import _http
 from stackgen.aiden import sessions as session_helpers
 from stackgen.aiden.run_status import ExecutionStatus
 from stackgen.config import StackgenConfig
-from stackgen.errors import StackgenError, TimeoutError
+from stackgen.errors import HttpError, StackgenError, TimeoutError
 
 
 @dataclass(frozen=True)
@@ -150,26 +150,43 @@ class AskArtifactJourney:
             f"{cfg.aiden_url()}/api/v1/executions/{trace_id}"
             f"{_http.query(cfg.org_id)}"
         )
+        # One attempt per tick: the poll loop owns the deadline. Inner GET
+        # backoff would burn a short CI budget. 5xx / 429 / network blips
+        # retry on the next tick; 4xx fails immediately.
+        last_transient = ""
         while time.monotonic() < deadline:
-            data = _http.request(url, cfg.api_token)
-            if not isinstance(data, dict):
-                raise StackgenError(f"unexpected getExecutionTrace payload: {data!r}")
-            execution = data.get("execution") or {}
-            status = ExecutionStatus.parse(_http.text(execution.get("status")))
-            # Prefer explicit settle when the mothership sends it. Some builds
-            # omit trace_settled on the thin getExecutionTrace summary; treat
-            # terminal status alone as done so callers are not stuck forever.
-            settled = execution.get("trace_settled")
-            ready = (
-                status is not None
-                and status.is_terminal()
-                and settled is not False
-            )
-            if ready:
-                if status in {ExecutionStatus.ERROR, ExecutionStatus.FAILED}:
+            try:
+                data = _http.request(url, cfg.api_token, retries=1)
+                if not isinstance(data, dict):
                     raise StackgenError(
-                        f"execution {trace_id} ended with status {status.value}"
+                        f"unexpected getExecutionTrace payload: {data!r}"
                     )
-                return data
-            time.sleep(cfg.poll_interval_seconds)
-        raise TimeoutError("execution", cfg.timeout_seconds)
+                last_transient = ""
+                execution = data.get("execution") or {}
+                status = ExecutionStatus.parse(_http.text(execution.get("status")))
+                # Prefer explicit settle when the mothership sends it. Some builds
+                # omit trace_settled on the thin getExecutionTrace summary; treat
+                # terminal status alone as done so callers are not stuck forever.
+                settled = execution.get("trace_settled")
+                ready = (
+                    status is not None
+                    and status.is_terminal()
+                    and settled is not False
+                )
+                if ready:
+                    if status in {ExecutionStatus.ERROR, ExecutionStatus.FAILED}:
+                        raise StackgenError(
+                            f"execution {trace_id} ended with status {status.value}"
+                        )
+                    return data
+            except StackgenError as err:
+                if isinstance(err, HttpError) and _http.is_transient_http_error(err):
+                    last_transient = _http.http_status_snippet(err)
+                else:
+                    raise
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                break
+            time.sleep(min(cfg.poll_interval_seconds, remaining))
+        label = f"execution ({last_transient})" if last_transient else "execution"
+        raise TimeoutError(label, cfg.timeout_seconds)

{stackgen_sdk-0.4.0rc5 → stackgen_sdk-0.4.0rc7}/src/stackgen/aiden/sessions.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from stackgen import _http
 from stackgen.config import StackgenConfig
-from stackgen.errors import TimeoutError
+from stackgen.errors import HttpError, TimeoutError
 
 
 def wait_for_artifact(
@@ -23,12 +23,29 @@ def wait_for_artifact(
     )
     want = artifact_name.casefold()
     artifacts: list[dict[str, Any]] = []
+    last_transient = ""
     while time.monotonic() < deadline:
-        artifacts = _http.as_list(_http.request(url, config.api_token))
-        if any(_http.text(item.get("name")).casefold() == want for item in artifacts):
-            return artifacts
-        time.sleep(config.poll_interval_seconds)
-    raise TimeoutError(artifact_name, config.timeout_seconds)
+        try:
+            artifacts = _http.as_list(
+                _http.request(url, config.api_token, retries=1)
+            )
+            last_transient = ""
+            if any(
+                _http.text(item.get("name")).casefold() == want for item in artifacts
+            ):
+                return artifacts
+        except HttpError as err:
+            if not _http.is_transient_http_error(err):
+                raise
+            last_transient = _http.http_status_snippet(err)
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            break
+        time.sleep(min(config.poll_interval_seconds, remaining))
+    label = (
+        f"{artifact_name} ({last_transient})" if last_transient else artifact_name
+    )
+    raise TimeoutError(label, config.timeout_seconds)
 
 
 def download_artifact(

stackgen_sdk-0.4.0rc7/src/stackgen/aiden/subscribe.py

@@ -0,0 +1,174 @@
+"""SSE subscribeExecution helper."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from stackgen import _http
+from stackgen.aiden.run_status import ExecutionStatus
+from stackgen.config import StackgenConfig
+from stackgen.errors import HttpError, TimeoutError as SdkTimeoutError
+
+
+@dataclass
+class SubscribeCompleteResult:
+    ok: bool
+    event_count: int
+    raw_snippet: str
+
+
+class ExecutionSubscribe:
+    def __init__(self, config: StackgenConfig) -> None:
+        self._config = config
+
+    def wait_for_complete(
+        self, trace_id: str, *, timeout_ms: int = 10 * 60 * 1000
+    ) -> SubscribeCompleteResult:
+        started = time.monotonic()
+        url = (
+            f"{self._config.aiden_url()}/api/v1/executions/{trace_id}/subscribe"
+            + _http.query(self._config.org_id)
+        )
+        req = Request(
+            url,
+            headers={
+                "Authorization": f"Bearer {self._config.api_token}",
+                "Accept": "text/event-stream",
+            },
+            method="GET",
+        )
+        chunks: list[str] = []
+        event_count = 0
+        ok = False
+        try:
+            with urlopen(req, timeout=timeout_ms / 1000) as resp:  # noqa: S310
+                buffer = ""
+                while True:
+                    line = resp.readline()
+                    if not line:
+                        break
+                    buffer += line.decode("utf-8", errors="replace")
+                    if "\n\n" not in buffer:
+                        continue
+                    frames = buffer.split("\n\n")
+                    buffer = frames.pop()
+                    for frame in frames:
+                        if not frame.strip():
+                            continue
+                        event_count += 1
+                        chunks.append(frame[:500])
+                        lower = frame.lower()
+                        if "execution_complete" in lower:
+                            ok = True
+                            break
+                        if "subscribe_end" in lower and "error" not in lower:
+                            ok = True
+                    if ok:
+                        break
+        except SdkTimeoutError:
+            raise
+        except TimeoutError as err:
+            raise SdkTimeoutError("subscribeExecution", int(timeout_ms / 1000)) from err
+        except HTTPError as err:
+            detail = err.read().decode("utf-8", errors="replace") if err.fp else ""
+            raise HttpError(
+                f"subscribeExecution -> HTTP {err.code}: {detail}",
+                status_code=err.code,
+            ) from err
+        except URLError as err:
+            raise HttpError(f"subscribeExecution -> {err}") from err
+
+        stream_snippet = "\n---\n".join(chunks[-5:])
+        if not ok:
+            return SubscribeCompleteResult(
+                ok=False,
+                event_count=event_count,
+                raw_snippet=stream_snippet,
+            )
+
+        remaining_ms = timeout_ms - int((time.monotonic() - started) * 1000)
+        if remaining_ms <= 100:
+            return SubscribeCompleteResult(
+                ok=False,
+                event_count=event_count,
+                raw_snippet="execution status=deadline",
+            )
+
+        confirmed = self._confirm_execution_settled(trace_id, remaining_ms)
+        if not confirmed.ok:
+            return SubscribeCompleteResult(
+                ok=False,
+                event_count=event_count,
+                raw_snippet=confirmed.raw_snippet,
+            )
+        return SubscribeCompleteResult(
+            ok=True,
+            event_count=event_count,
+            raw_snippet=stream_snippet or "successful run terminal",
+        )
+
+    def _confirm_execution_settled(
+        self, trace_id: str, timeout_ms: int
+    ) -> SubscribeCompleteResult:
+        """Poll GET /executions/{traceId} until settled inside the remaining deadline."""
+        deadline = time.monotonic() + timeout_ms / 1000
+        url = (
+            f"{self._config.aiden_url()}/api/v1/executions/{trace_id}"
+            f"{_http.query(self._config.org_id)}"
+        )
+        poll_interval = self._config.poll_interval_seconds
+        last_transient = ""
+        while time.monotonic() < deadline:
+            try:
+                data = _http.request(url, self._config.api_token, retries=1)
+                if not isinstance(data, dict):
+                    last_transient = "execution status=invalid_payload"
+                else:
+                    last_transient = ""
+                    execution = data.get("execution") or {}
+                    status = ExecutionStatus.parse(
+                        _http.text(execution.get("status"))
+                    )
+                    settled = execution.get("trace_settled")
+                    ready = (
+                        status is not None
+                        and status.is_terminal()
+                        and settled is not False
+                    )
+                    if ready:
+                        if status in {
+                            ExecutionStatus.ERROR,
+                            ExecutionStatus.FAILED,
+                            ExecutionStatus.CANCELLED,
+                        }:
+                            return SubscribeCompleteResult(
+                                ok=False,
+                                event_count=0,
+                                raw_snippet=f"execution status={status.value}",
+                            )
+                        return SubscribeCompleteResult(
+                            ok=True,
+                            event_count=0,
+                            raw_snippet="successful run terminal",
+                        )
+            except HttpError as err:
+                if not _http.is_transient_http_error(err):
+                    code = err.status_code if err.status_code is not None else "error"
+                    return SubscribeCompleteResult(
+                        ok=False,
+                        event_count=0,
+                        raw_snippet=f"execution status={code}",
+                    )
+                last_transient = f"execution {_http.http_status_snippet(err)}"
+            remaining = deadline - time.monotonic()
+            if remaining <= 0.1:
+                break
+            time.sleep(min(poll_interval, remaining - 0.1))
+        return SubscribeCompleteResult(
+            ok=False,
+            event_count=0,
+            raw_snippet=last_transient or f"subscribe aborted after {timeout_ms}ms",
+        )

stackgen_sdk-0.4.0rc5/src/stackgen/aiden/subscribe.py

@@ -1,87 +0,0 @@
-"""SSE subscribeExecution helper."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from urllib.error import HTTPError, URLError
-from urllib.request import Request, urlopen
-
-from stackgen import _http
-from stackgen.config import StackgenConfig
-from stackgen.errors import HttpError, TimeoutError as SdkTimeoutError
-
-
-@dataclass
-class SubscribeCompleteResult:
-    ok: bool
-    event_count: int
-    raw_snippet: str
-
-
-class ExecutionSubscribe:
-    def __init__(self, config: StackgenConfig) -> None:
-        self._config = config
-
-    def wait_for_complete(
-        self, trace_id: str, *, timeout_ms: int = 10 * 60 * 1000
-    ) -> SubscribeCompleteResult:
-        url = (
-            f"{self._config.aiden_url()}/api/v1/executions/{trace_id}/subscribe"
-            + _http.query(self._config.org_id)
-        )
-        req = Request(
-            url,
-            headers={
-                "Authorization": f"Bearer {self._config.api_token}",
-                "Accept": "text/event-stream",
-            },
-            method="GET",
-        )
-        chunks: list[str] = []
-        event_count = 0
-        ok = False
-        try:
-            with urlopen(req, timeout=timeout_ms / 1000) as resp:  # noqa: S310
-                buffer = ""
-                while True:
-                    line = resp.readline()
-                    if not line:
-                        break
-                    buffer += line.decode("utf-8", errors="replace")
-                    if "\n\n" not in buffer:
-                        continue
-                    frames = buffer.split("\n\n")
-                    buffer = frames.pop()
-                    for frame in frames:
-                        if not frame.strip():
-                            continue
-                        event_count += 1
-                        chunks.append(frame[:500])
-                        lower = frame.lower()
-                        if "execution_complete" in lower:
-                            ok = True
-                            return SubscribeCompleteResult(
-                                ok=True,
-                                event_count=event_count,
-                                raw_snippet="\n---\n".join(chunks[-5:]),
-                            )
-                        if "subscribe_end" in lower and "error" not in lower:
-                            ok = True
-        except SdkTimeoutError:
-            raise
-        except TimeoutError as err:
-            raise SdkTimeoutError("subscribeExecution", int(timeout_ms / 1000)) from err
-        except HTTPError as err:
-            detail = err.read().decode("utf-8", errors="replace") if err.fp else ""
-            raise HttpError(
-                f"subscribeExecution -> HTTP {err.code}: {detail}",
-                status_code=err.code,
-            ) from err
-        except URLError as err:
-            raise HttpError(f"subscribeExecution -> {err}") from err
-
-        return SubscribeCompleteResult(
-            ok=ok,
-            event_count=event_count,
-            raw_snippet="\n---\n".join(chunks[-5:]),
-        )