stackgen-sdk 0.4.0rc35__tar.gz → 0.4.0rc37__tar.gz

{stackgen_sdk-0.4.0rc35 → stackgen_sdk-0.4.0rc37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stackgen-sdk
-Version: 0.4.0rc35
+Version: 0.4.0rc37
 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.0rc35 → stackgen_sdk-0.4.0rc37}/src/stackgen/_http.py

@@ -113,16 +113,17 @@ def request(
     retries: int = 3,
     timeout_seconds: float | None = None,
     transient_retry_budget_ms: float | int | None = None,
-    retry_gateway_outage: bool = False,
+    retry_gateway_outage: bool = True,
+    org_id: str | None = None,
 ) -> Any:
-    """Bearer HTTP call with retries on transient failures for idempotent methods.
+    """Bearer HTTP call with retries on transient failures.
 
     Gateway 502/503/504 and network errors retry until
-    ``transient_retry_budget_ms`` elapses (default 120s). Other retryable
-    statuses use the short ``retries`` attempt budget. POST/PATCH fail fast
-    unless ``retry_gateway_outage`` is set, which retries only 502/503/504
-    and transport errors (a CloudFront drop), not application 500s.
-    Webhook trigger, vault secret store, and org create set that flag.
+    ``transient_retry_budget_ms`` elapses (default 120s) for every method —
+    a CloudFront drop means the edge never delivered the request. Pass
+    ``retry_gateway_outage=False`` to fail fast on POST/PATCH instead.
+    Other retryable statuses (429, 499, application 500, …) still use the
+    short ``retries`` attempt budget and only for idempotent methods.
 
     ``timeout_seconds`` is an optional per-call abort budget. When the deadline
     expires, raises :class:`~stackgen.errors.TimeoutError`. Omit to wait until
@@ -135,10 +136,12 @@ def request(
     method = method.upper()
     budget_ms = resolve_transient_retry_budget_ms(transient_retry_budget_ms)
     idempotent = is_idempotent_http_method(method)
-    retry_outage = idempotent or retry_gateway_outage
+    retry_outage = bool(retry_gateway_outage)
     headers = {"Authorization": f"Bearer {token}"}
     if content_type:
         headers["Content-Type"] = content_type
+    if org_id:
+        headers["X-Appcd-Org"] = org_id
 
     started = time.monotonic()
     attempt = 0

{stackgen_sdk-0.4.0rc35 → stackgen_sdk-0.4.0rc37}/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.0rc35'
-__version_tuple__ = version_tuple = (0, 4, 0, 'rc35')
+__version__ = version = '0.4.0rc37'
+__version_tuple__ = version_tuple = (0, 4, 0, 'rc37')
 
 __commit_id__ = commit_id = None

{stackgen_sdk-0.4.0rc35 → stackgen_sdk-0.4.0rc37}/src/stackgen/client.py

@@ -1,9 +1,10 @@
-"""StackgenClient — one entrypoint for Aiden, SRE, and Vault."""
+"""StackgenClient — one entrypoint for Aiden, SRE, DevOps, and Vault."""
 
 from __future__ import annotations
 
 from stackgen.aiden import AidenNamespace
 from stackgen.config import StackgenConfig
+from stackgen.devops import DevOpsNamespace
 from stackgen.orgs import OrgsNamespace
 from stackgen.sre import SRENamespace
 from stackgen.vault import VaultNamespace
@@ -15,6 +16,7 @@ class StackgenClient:
     Namespaces:
       - ``aiden`` — platform automations, sessions, session-report download
       - ``sre`` — alerts and investigations
+      - ``devops`` — Ops Inbox requests and workflow discovery
       - ``vault`` — secrets (allowlisted separately)
       - ``orgs`` — create and delete disposable projects
     """
@@ -25,6 +27,7 @@ class StackgenClient:
         self.config = config
         self.aiden = AidenNamespace(config)
         self.sre = SRENamespace(config)
+        self.devops = DevOpsNamespace(config)
         self.vault = VaultNamespace(config)
         self.orgs = OrgsNamespace(config)
 

{stackgen_sdk-0.4.0rc35 → stackgen_sdk-0.4.0rc37}/src/stackgen/config.py

@@ -97,6 +97,10 @@ class StackgenConfig:
         """HTTP prefix for the SRE app."""
         return self.mothership() + "/app/sre"
 
+    def devops_url(self) -> str:
+        """HTTP prefix for the DevOps Ops Inbox app."""
+        return self.mothership() + "/app/devops"
+
     def vault_url(self) -> str:
         """HTTP prefix for Vault on the mothership edge (``/api/vault/v1``)."""
         return self.mothership() + "/api/vault/v1"

stackgen_sdk-0.4.0rc37/src/stackgen/devops/__init__.py

@@ -0,0 +1,5 @@
+"""DevOps Ops Inbox namespace."""
+
+from stackgen.devops.namespace import DevOpsNamespace
+
+__all__ = ["DevOpsNamespace"]

stackgen_sdk-0.4.0rc37/src/stackgen/devops/namespace.py

@@ -0,0 +1,374 @@
+"""DevOps namespace — Ops Inbox requests and workflow discovery."""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.parse
+from typing import Any
+
+from stackgen import _http
+from stackgen.config import StackgenConfig
+from stackgen.errors import HttpError, StackgenError, TimeoutError
+
+_TRIAGE_WAIT = frozenset({"new", "triaging"})
+_EXEC_WAIT_STATUS = frozenset({"approved", "executing"})
+_EXEC_WAIT_EXEC = frozenset({"not_started", "running"})
+
+
+def query_string(params: dict[str, Any]) -> str:
+    cleaned = {k: v for k, v in params.items() if v is not None}
+    if not cleaned:
+        return ""
+    return "?" + urllib.parse.urlencode(cleaned, doseq=True)
+
+
+def _escape(segment: str) -> str:
+    return urllib.parse.quote(str(segment), safe="")
+
+
+def _as_dict(value: Any, label: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise StackgenError(f"unexpected {label} payload: {value!r}")
+    return value
+
+
+class DevOpsNamespace:
+    """Ops Inbox requests and workflow discovery."""
+
+    def __init__(self, config: StackgenConfig) -> None:
+        self._config = config
+
+    def _url(self, path: str, params: dict[str, Any] | None = None) -> str:
+        return f"{self._config.devops_url()}/api/v1{path}{query_string(params or {})}"
+
+    def _req(self, url: str, **kwargs: Any) -> Any:
+        org = (self._config.org_id or "").strip() or None
+        return _http.request(url, self._config.api_token, org_id=org, **kwargs)
+
+    def setup_status(self) -> Any:
+        """GET /app/devops/api/setup"""
+        url = f"{self._config.devops_url()}/api/setup"
+        return self._req(url)
+
+    def list_requests(self, **params: Any) -> Any:
+        """GET /app/devops/api/v1/requests"""
+        return self._req(self._url("/requests", params))
+
+    def get_request(self, request_id: str) -> Any:
+        """GET /app/devops/api/v1/requests/{id}"""
+        return self._req(self._url(f"/requests/{_escape(request_id)}"),
+        )
+
+    def update_request(self, request_id: str, body: dict[str, Any]) -> Any:
+        """PATCH /app/devops/api/v1/requests/{id}"""
+        payload = json.dumps(body).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}"),
+            method="PATCH",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def sync_requests(self) -> Any:
+        """POST /app/devops/api/v1/requests/sync — ticket pull finishes in this call."""
+        return self._req(self._url("/requests/sync"),
+            method="POST",
+            body=b"{}",
+            content_type="application/json",
+        )
+
+    def fetch_request(self, identifier: str) -> Any:
+        """POST /app/devops/api/v1/requests/fetch — import one ticket key."""
+        payload = json.dumps({"identifier": identifier}).encode("utf-8")
+        return self._req(self._url("/requests/fetch"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def wait_for_triage(self, request_id: str) -> dict[str, Any]:
+        """Poll while status is new or triaging. Returns on any other status."""
+        cfg = self._config
+        deadline = time.monotonic() + cfg.timeout_seconds
+        last_transient = ""
+        while time.monotonic() < deadline:
+            try:
+                data = _as_dict(
+                    self._req(self._url(f"/requests/{_escape(request_id)}"),
+                        retries=1,
+                    ),
+                    "getRequest",
+                )
+                last_transient = ""
+                status = _http.text(data.get("status")).casefold()
+                if status not in _TRIAGE_WAIT:
+                    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"triage ({last_transient})" if last_transient else "triage"
+        raise TimeoutError(label, cfg.timeout_seconds)
+
+    def fetch_and_wait(self, identifier: str) -> dict[str, Any]:
+        """Fetch one ticket and wait until triage settles."""
+        started = _as_dict(self.fetch_request(identifier), "fetchRequest")
+        request_id = _http.text(started.get("id"))
+        if not request_id:
+            raise StackgenError(f"fetch_request missing id: {started!r}")
+        return self.wait_for_triage(request_id)
+
+    def approve_request(
+        self,
+        request_id: str,
+        *,
+        workflow_name: str | None = None,
+        override_reason: str | None = None,
+    ) -> Any:
+        """POST /app/devops/api/v1/requests/{id}/approve"""
+        body: dict[str, Any] = {}
+        if workflow_name is not None:
+            body["workflow_name"] = workflow_name
+        if override_reason is not None:
+            body["override_reason"] = override_reason
+        payload = json.dumps(body).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}/approve"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def wait_for_execution(self, request_id: str) -> dict[str, Any]:
+        """Poll while approved/executing with execution not finished."""
+        cfg = self._config
+        deadline = time.monotonic() + cfg.timeout_seconds
+        last_transient = ""
+        while time.monotonic() < deadline:
+            try:
+                data = _as_dict(
+                    self._req(self._url(f"/requests/{_escape(request_id)}"),
+                        retries=1,
+                    ),
+                    "getRequest",
+                )
+                last_transient = ""
+                status = _http.text(data.get("status")).casefold()
+                exec_status = _http.text(data.get("execution_status")).casefold()
+                if exec_status == "failed":
+                    raise StackgenError(
+                        f"request {request_id} execution failed: "
+                        f"{data.get('execution_result') or 'no detail'}"
+                    )
+                if exec_status == "completed":
+                    return data
+                still_waiting = (
+                    status in _EXEC_WAIT_STATUS and exec_status in _EXEC_WAIT_EXEC
+                )
+                if not still_waiting:
+                    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)
+
+    def approve_and_wait(
+        self,
+        request_id: str,
+        *,
+        workflow_name: str | None = None,
+        override_reason: str | None = None,
+    ) -> dict[str, Any]:
+        """Approve a request and wait for the run."""
+        self.approve_request(
+            request_id,
+            workflow_name=workflow_name,
+            override_reason=override_reason,
+        )
+        return self.wait_for_execution(request_id)
+
+    def defer_request(self, request_id: str) -> Any:
+        return self._req(self._url(f"/requests/{_escape(request_id)}/defer"),
+            method="POST",
+            body=b"{}",
+            content_type="application/json",
+        )
+
+    def reopen_request(
+        self,
+        request_id: str,
+        category: str | None = None,
+    ) -> Any:
+        body: dict[str, Any] = {}
+        if category is not None:
+            body["category"] = category
+        payload = json.dumps(body).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}/reopen"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def retriage_request(self, request_id: str) -> Any:
+        return self._req(self._url(f"/requests/{_escape(request_id)}/retriage"),
+            method="POST",
+            body=b"{}",
+            content_type="application/json",
+        )
+
+    def stop_triage(self, request_id: str) -> Any:
+        return self._req(self._url(f"/requests/{_escape(request_id)}/stop-triage"),
+            method="POST",
+            body=b"{}",
+            content_type="application/json",
+        )
+
+    def post_source_comment(
+        self,
+        request_id: str,
+        body: str | None = None,
+    ) -> Any:
+        """Post a comment on the upstream ticket (default body when omitted)."""
+        payload_obj: dict[str, Any] = {}
+        if body is not None:
+            payload_obj["body"] = body
+        payload = json.dumps(payload_obj).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}/source-comment"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def list_workflows(self) -> Any:
+        return self._req(self._url("/workflows"))
+
+    def suggest_workflow(
+        self,
+        request_id: str,
+        body: dict[str, Any] | None = None,
+    ) -> Any:
+        payload = json.dumps(body or {}).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}/workflow-suggestions"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def create_request_workflow(self, request_id: str, draft: dict[str, Any]) -> Any:
+        payload = json.dumps({"draft": draft}).encode("utf-8")
+        return self._req(self._url(f"/requests/{_escape(request_id)}/workflows"),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def inbox_funnel(self, period: str = "30d", source: str | None = None) -> Any:
+        params: dict[str, Any] = {"period": period}
+        if source is not None:
+            params["source"] = source
+        return self._req(self._url("/metrics/funnel", params))
+
+    def start_workflow_discovery(
+        self,
+        *,
+        window_days: int | None = None,
+        ticket_cap: int | None = None,
+        apply_inbox_filters: bool | None = None,
+    ) -> Any:
+        """Start discovery. On 409, return the latest in-progress run."""
+        body: dict[str, Any] = {}
+        if window_days is not None:
+            body["window_days"] = window_days
+        if ticket_cap is not None:
+            body["ticket_cap"] = ticket_cap
+        if apply_inbox_filters is not None:
+            body["apply_inbox_filters"] = apply_inbox_filters
+        payload = json.dumps(body).encode("utf-8")
+        try:
+            return self._req(self._url("/discovery/runs"),
+                method="POST",
+                body=payload,
+                content_type="application/json",
+            )
+        except HttpError as err:
+            if err.status_code != 409:
+                raise
+            return self.latest_workflow_discovery()
+
+    def latest_workflow_discovery(self) -> Any:
+        return self._req(self._url("/discovery/runs/latest"),
+        )
+
+    def wait_for_workflow_discovery(self) -> dict[str, Any]:
+        """Poll the latest discovery run while status is running."""
+        cfg = self._config
+        deadline = time.monotonic() + cfg.timeout_seconds
+        last_transient = ""
+        while time.monotonic() < deadline:
+            try:
+                data = _as_dict(
+                    self._req(self._url("/discovery/runs/latest"),
+                        retries=1,
+                    ),
+                    "getLatestWorkflowDiscovery",
+                )
+                last_transient = ""
+                status = _http.text(data.get("status")).casefold()
+                if status == "ready":
+                    return data
+                if status == "failed":
+                    raise StackgenError(
+                        f"workflow discovery failed: {data.get('error') or 'no detail'}"
+                    )
+            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"workflow discovery ({last_transient})"
+            if last_transient
+            else "workflow discovery"
+        )
+        raise TimeoutError(label, cfg.timeout_seconds)
+
+    def create_discovered_workflow(
+        self,
+        run_id: str,
+        class_id: str,
+        draft: dict[str, Any],
+    ) -> Any:
+        payload = json.dumps({"draft": draft}).encode("utf-8")
+        return self._req(
+            self._url(
+                f"/discovery/runs/{_escape(run_id)}/classes/{_escape(class_id)}/workflow"
+            ),
+            method="POST",
+            body=payload,
+            content_type="application/json",
+        )
+
+    def dismiss_discovery_class(self, run_id: str, class_id: str) -> Any:
+        return self._req(
+            self._url(
+                f"/discovery/runs/{_escape(run_id)}/classes/{_escape(class_id)}/dismiss"
+            ),
+            method="POST",
+            body=b"{}",
+            content_type="application/json",
+        )