stackgen-sdk 0.1.1__py3-none-any.whl

stackgen/generated/models/alert_sync_run_status.py

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class AlertSyncRunStatus(str, Enum):
+    """
+    Status of an alert sync run (manual, scheduled, or webhook-triggered).
+    """
+
+    """
+    allowed enum values
+    """
+    RUNNING = 'running'
+    COMPLETED = 'completed'
+    FAILED = 'failed'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AlertSyncRunStatus from a JSON string"""
+        return cls(json.loads(json_str))
+
+

stackgen/generated/models/alert_v1.py

@@ -0,0 +1,213 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from stackgen.generated.models.alert_analysis_status import AlertAnalysisStatus
+from stackgen.generated.models.alert_attention import AlertAttention
+from stackgen.generated.models.alert_role import AlertRole
+from stackgen.generated.models.alert_status import AlertStatus
+from stackgen.generated.models.investigation_ref import InvestigationRef
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AlertV1(BaseModel):
+    """
+    A single alert with its current lifecycle, analysis, and triage state.
+    """ # noqa: E501
+    id: StrictStr = Field(description="Internal alert UUID.")
+    external_uid: StrictStr = Field(description="Stable identifier from the alert source (e.g. Grafana fingerprint).")
+    source_type: StrictStr = Field(description="Alert source system (e.g. \"grafana\").")
+    integration_name: Optional[StrictStr] = Field(default=None, description="Human-readable name of the integration that produced this alert.")
+    title: StrictStr = Field(description="Short human-readable alert title.")
+    description: StrictStr = Field(description="Longer description or message from the alert source.")
+    source_severity: StrictStr = Field(description="Raw severity string from the source (e.g. \"critical\", \"high\").")
+    display_priority: StrictInt = Field(description="Numeric sort key derived from severity (lower = more urgent).")
+    impact_score: Annotated[int, Field(le=100, strict=True, ge=0)] = Field(description="Estimated blast-radius impact (0–100, higher = greater impact). Derived at ingest from environment criticality, label scope breadth, and co-firing storm fanout — not from monitor severity. ")
+    impact_explanation: Optional[StrictStr] = Field(default=None, description="Plain-English rationale for impact_score (e.g. prod environment, three co-firing peers) so operators can trust impact sorting. ")
+    status: AlertStatus
+    analysis_status: AlertAnalysisStatus
+    attention: AlertAttention
+    attention_reason: Optional[StrictStr] = Field(default=None, description="Plain-English explanation for the attention classification.")
+    ignore_reason: Optional[StrictStr] = Field(default=None, description="Plain-English reason the operator provided when ignoring this alert.")
+    short_summary: Optional[StrictStr] = Field(default=None, description="One-liner produced by Aiden auto-analysis (sre_classify_alert_criticality) summarising what is happening with this alert. Rendered inline in the alerts list and queue ahead of the full investigation result.")
+    initial_investigation: Optional[StrictStr] = Field(default=None, description="First-pass write-up produced by Aiden auto-analysis. Multi-line text with hypotheses, related signals, and suggested next steps; rendered as the headline body in the alert detail drawer before the deep-dive investigation completes.")
+    triggered_at: datetime = Field(description="When the alert last fired (most recent trigger from the source).")
+    created_at: datetime = Field(description="When the alert was first triggered and ingested into SRE (unchanged on re-fires).")
+    resolved_at: Optional[datetime] = Field(default=None, description="When the alert was last resolved.")
+    refire_count: StrictInt = Field(description="Number of times this alert has re-fired after being resolved.")
+    last_resolved_at: Optional[datetime] = Field(default=None, description="Timestamp of the most recent resolution (before a re-fire).")
+    investigation: Optional[InvestigationRef] = None
+    labels: Optional[Dict[str, StrictStr]] = Field(default=None, description="User-facing alert labels from the monitoring source (e.g. Grafana Prometheus labels). Internal system keys are stripped before persistence.")
+    alert_role: Optional[AlertRole] = None
+    storm_id: Optional[StrictStr] = Field(default=None, description="UUID grouping co-firing alerts in the same incident storm. Null when the alert is isolated or not yet correlated.")
+    likely_upstream: Optional[StrictStr] = Field(default=None, description="For symptom alerts, a plain-English hint naming the most likely upstream cause alert or service in the same storm.")
+    ingested_via: Optional[StrictStr] = Field(default=None, description="Ingestion-mode tag for this alert's current episode: \"push\" (webhook) or \"pull\" (scheduled/manual sync). Set on first ingest and on re-fire from resolved; left unchanged on plain updates.")
+    raw_payload: Optional[StrictStr] = Field(default=None, description="Source-native payload the ingestion/auto-investigate filters run on, stored verbatim as JSON text — the raw webhook body for push, or the marshalled source object for pull. Null on legacy rows ingested before raw-payload capture.")
+    __properties: ClassVar[List[str]] = ["id", "external_uid", "source_type", "integration_name", "title", "description", "source_severity", "display_priority", "impact_score", "impact_explanation", "status", "analysis_status", "attention", "attention_reason", "ignore_reason", "short_summary", "initial_investigation", "triggered_at", "created_at", "resolved_at", "refire_count", "last_resolved_at", "investigation", "labels", "alert_role", "storm_id", "likely_upstream", "ingested_via", "raw_payload"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of AlertV1 from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of investigation
+        if self.investigation:
+            _dict['investigation'] = self.investigation.to_dict()
+        # set to None if integration_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.integration_name is None and "integration_name" in self.model_fields_set:
+            _dict['integration_name'] = None
+
+        # set to None if impact_explanation (nullable) is None
+        # and model_fields_set contains the field
+        if self.impact_explanation is None and "impact_explanation" in self.model_fields_set:
+            _dict['impact_explanation'] = None
+
+        # set to None if attention_reason (nullable) is None
+        # and model_fields_set contains the field
+        if self.attention_reason is None and "attention_reason" in self.model_fields_set:
+            _dict['attention_reason'] = None
+
+        # set to None if ignore_reason (nullable) is None
+        # and model_fields_set contains the field
+        if self.ignore_reason is None and "ignore_reason" in self.model_fields_set:
+            _dict['ignore_reason'] = None
+
+        # set to None if short_summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.short_summary is None and "short_summary" in self.model_fields_set:
+            _dict['short_summary'] = None
+
+        # set to None if initial_investigation (nullable) is None
+        # and model_fields_set contains the field
+        if self.initial_investigation is None and "initial_investigation" in self.model_fields_set:
+            _dict['initial_investigation'] = None
+
+        # set to None if resolved_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.resolved_at is None and "resolved_at" in self.model_fields_set:
+            _dict['resolved_at'] = None
+
+        # set to None if last_resolved_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_resolved_at is None and "last_resolved_at" in self.model_fields_set:
+            _dict['last_resolved_at'] = None
+
+        # set to None if storm_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.storm_id is None and "storm_id" in self.model_fields_set:
+            _dict['storm_id'] = None
+
+        # set to None if likely_upstream (nullable) is None
+        # and model_fields_set contains the field
+        if self.likely_upstream is None and "likely_upstream" in self.model_fields_set:
+            _dict['likely_upstream'] = None
+
+        # set to None if ingested_via (nullable) is None
+        # and model_fields_set contains the field
+        if self.ingested_via is None and "ingested_via" in self.model_fields_set:
+            _dict['ingested_via'] = None
+
+        # set to None if raw_payload (nullable) is None
+        # and model_fields_set contains the field
+        if self.raw_payload is None and "raw_payload" in self.model_fields_set:
+            _dict['raw_payload'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of AlertV1 from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "external_uid": obj.get("external_uid"),
+            "source_type": obj.get("source_type"),
+            "integration_name": obj.get("integration_name"),
+            "title": obj.get("title"),
+            "description": obj.get("description"),
+            "source_severity": obj.get("source_severity"),
+            "display_priority": obj.get("display_priority"),
+            "impact_score": obj.get("impact_score"),
+            "impact_explanation": obj.get("impact_explanation"),
+            "status": obj.get("status"),
+            "analysis_status": obj.get("analysis_status"),
+            "attention": obj.get("attention"),
+            "attention_reason": obj.get("attention_reason"),
+            "ignore_reason": obj.get("ignore_reason"),
+            "short_summary": obj.get("short_summary"),
+            "initial_investigation": obj.get("initial_investigation"),
+            "triggered_at": obj.get("triggered_at"),
+            "created_at": obj.get("created_at"),
+            "resolved_at": obj.get("resolved_at"),
+            "refire_count": obj.get("refire_count"),
+            "last_resolved_at": obj.get("last_resolved_at"),
+            "investigation": InvestigationRef.from_dict(obj["investigation"]) if obj.get("investigation") is not None else None,
+            "labels": obj.get("labels"),
+            "alert_role": obj.get("alert_role"),
+            "storm_id": obj.get("storm_id"),
+            "likely_upstream": obj.get("likely_upstream"),
+            "ingested_via": obj.get("ingested_via"),
+            "raw_payload": obj.get("raw_payload")
+        })
+        return _obj
+
+

stackgen/generated/models/artifact_info.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ArtifactInfo(BaseModel):
+    """
+    Information about a session artifact generated and uploaded.
+    """ # noqa: E501
+    id: StrictStr
+    session_id: StrictStr
+    name: StrictStr
+    mime_type: StrictStr
+    size_bytes: StrictInt
+    created_at: Optional[datetime] = None
+    __properties: ClassVar[List[str]] = ["id", "session_id", "name", "mime_type", "size_bytes", "created_at"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ArtifactInfo from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ArtifactInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "session_id": obj.get("session_id"),
+            "name": obj.get("name"),
+            "mime_type": obj.get("mime_type"),
+            "size_bytes": obj.get("size_bytes"),
+            "created_at": obj.get("created_at")
+        })
+        return _obj
+
+

stackgen/generated/models/error_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorResponse(BaseModel):
+    """
+    Standard error response body.
+    """ # noqa: E501
+    error: StrictStr = Field(description="Human-readable error message.")
+    code: Optional[StrictStr] = Field(default=None, description="Machine-readable error code.")
+    details: Optional[Dict[str, Any]] = Field(default=None, description="Additional structured details about the error.")
+    __properties: ClassVar[List[str]] = ["error", "code", "details"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ErrorResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ErrorResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "error": obj.get("error"),
+            "code": obj.get("code"),
+            "details": obj.get("details")
+        })
+        return _obj
+
+

stackgen/generated/models/investigate_alert_request.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigateAlertRequest(BaseModel):
+    """
+    Optional parameters for starting or retrieving an alert investigation.
+    """ # noqa: E501
+    force_new: Optional[StrictBool] = Field(default=False, description="Force a new investigation to be created.")
+    remediation_requested: Optional[StrictBool] = Field(default=False, description="When true, satisfy on_request remediation mode for this run (attempt a HITL-gated fix PR when evidence supports a durable code change). Ignored when remediation mode is off.")
+    operator_message: Optional[StrictStr] = Field(default=None, description="Optional operator text for this investigation. When it explicitly asks to open a fix PR or remediate, it satisfies on_request remediation mode the same as remediation_requested.")
+    __properties: ClassVar[List[str]] = ["force_new", "remediation_requested", "operator_message"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InvestigateAlertRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigateAlertRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "force_new": obj.get("force_new") if obj.get("force_new") is not None else False,
+            "remediation_requested": obj.get("remediation_requested") if obj.get("remediation_requested") is not None else False,
+            "operator_message": obj.get("operator_message")
+        })
+        return _obj
+
+

stackgen/generated/models/investigate_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from stackgen.generated.models.investigation_ref import InvestigationRef
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigateResponse(BaseModel):
+    """
+    Investigation started or existing investigation returned.
+    """ # noqa: E501
+    investigation: InvestigationRef
+    __properties: ClassVar[List[str]] = ["investigation"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InvestigateResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of investigation
+        if self.investigation:
+            _dict['investigation'] = self.investigation.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigateResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "investigation": InvestigationRef.from_dict(obj["investigation"]) if obj.get("investigation") is not None else None
+        })
+        return _obj
+
+