stackgen-sdk 0.1.1__py3-none-any.whl

stackgen/generated/models/investigation_prior_incident.py

@@ -0,0 +1,109 @@
+# 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, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationPriorIncident(BaseModel):
+    """
+    A prior incident similar to the current alert context.
+    """ # noqa: E501
+    alert_id: Optional[StrictStr] = Field(default=None, description="Internal alert UUID when the prior incident is known.")
+    title: StrictStr = Field(description="Short title of the prior incident.")
+    similarity: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=None, description="Similarity score to the current alert (0–1).")
+    confidence_boost: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=None, description="How much this match should boost downstream hypothesis confidence.")
+    __properties: ClassVar[List[str]] = ["alert_id", "title", "similarity", "confidence_boost"]
+
+    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 InvestigationPriorIncident 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,
+        )
+        # set to None if alert_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.alert_id is None and "alert_id" in self.model_fields_set:
+            _dict['alert_id'] = None
+
+        # set to None if similarity (nullable) is None
+        # and model_fields_set contains the field
+        if self.similarity is None and "similarity" in self.model_fields_set:
+            _dict['similarity'] = None
+
+        # set to None if confidence_boost (nullable) is None
+        # and model_fields_set contains the field
+        if self.confidence_boost is None and "confidence_boost" in self.model_fields_set:
+            _dict['confidence_boost'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationPriorIncident from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "alert_id": obj.get("alert_id"),
+            "title": obj.get("title"),
+            "similarity": obj.get("similarity"),
+            "confidence_boost": obj.get("confidence_boost")
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_recommended_next_step.py

@@ -0,0 +1,101 @@
+# 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 InvestigationRecommendedNextStep(BaseModel):
+    """
+    One tiered remediation action with risk, verification, and optional operator commands for kubectl or gh.
+    """ # noqa: E501
+    tier: StrictStr = Field(description="Mitigation tier such as immediate_containment, immediate_app, restore_observability, secondary_cluster, or preventive.")
+    action: StrictStr = Field(description="Plain-language remediation action for operators.")
+    risk: Optional[StrictStr] = Field(default=None, description="Risk level such as low, medium, or high.")
+    approval_required: Optional[StrictBool] = Field(default=None, description="Whether operator approval is required before execution.")
+    expected_impact: Optional[StrictStr] = Field(default=None, description="Expected outcome after the action succeeds.")
+    verify: Optional[StrictStr] = Field(default=None, description="Metric or log check that confirms success.")
+    rollback: Optional[StrictStr] = Field(default=None, description="How to undo the action if verification fails.")
+    operator_commands: Optional[List[StrictStr]] = Field(default=None, description="Copy-paste kubectl or gh commands for operators.")
+    __properties: ClassVar[List[str]] = ["tier", "action", "risk", "approval_required", "expected_impact", "verify", "rollback", "operator_commands"]
+
+    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 InvestigationRecommendedNextStep 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 InvestigationRecommendedNextStep from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "tier": obj.get("tier"),
+            "action": obj.get("action"),
+            "risk": obj.get("risk"),
+            "approval_required": obj.get("approval_required"),
+            "expected_impact": obj.get("expected_impact"),
+            "verify": obj.get("verify"),
+            "rollback": obj.get("rollback"),
+            "operator_commands": obj.get("operator_commands")
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_ref.py

@@ -0,0 +1,118 @@
+# 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_extensions import Annotated
+from stackgen.generated.models.investigation_status import InvestigationStatus
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationRef(BaseModel):
+    """
+    Minimal reference to a Aiden investigation linked to an alert.
+    """ # noqa: E501
+    id: StrictStr = Field(description="Investigation UUID.")
+    alert_id: StrictStr = Field(description="Alert UUID that triggered this investigation.")
+    guild_trace_id: StrictStr = Field(description="Aiden trace ID used to stream live investigation output.")
+    guild_session_id: Optional[StrictStr] = Field(default=None, description="Aiden session ID for the in-progress chat run. Populated by Aiden MCP callbacks once the session is created. Used by the UI to deep link into the conversation view.")
+    status: InvestigationStatus
+    result_summary: Optional[StrictStr] = Field(default=None, description="Short summary of the investigation result, once completed.")
+    parent_investigation_id: Optional[StrictStr] = Field(default=None, description="When this investigation was created by forking another, the parent investigation it was forked from. Null for normal investigations.")
+    evidence_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=0, description="Number of evidence URLs persisted on the investigation. Computed server-side via jsonb_array_length so it stays consistent with the full list returned by /api/v1/investigations/{id}.")
+    __properties: ClassVar[List[str]] = ["id", "alert_id", "guild_trace_id", "guild_session_id", "status", "result_summary", "parent_investigation_id", "evidence_count"]
+
+    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 InvestigationRef 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,
+        )
+        # set to None if guild_session_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.guild_session_id is None and "guild_session_id" in self.model_fields_set:
+            _dict['guild_session_id'] = None
+
+        # set to None if result_summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.result_summary is None and "result_summary" in self.model_fields_set:
+            _dict['result_summary'] = None
+
+        # set to None if parent_investigation_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.parent_investigation_id is None and "parent_investigation_id" in self.model_fields_set:
+            _dict['parent_investigation_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationRef 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"),
+            "alert_id": obj.get("alert_id"),
+            "guild_trace_id": obj.get("guild_trace_id"),
+            "guild_session_id": obj.get("guild_session_id"),
+            "status": obj.get("status"),
+            "result_summary": obj.get("result_summary"),
+            "parent_investigation_id": obj.get("parent_investigation_id"),
+            "evidence_count": obj.get("evidence_count") if obj.get("evidence_count") is not None else 0
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_status.py

@@ -0,0 +1,42 @@
+# 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 InvestigationStatus(str, Enum):
+    """
+    Lifecycle status of a Aiden investigation. `draft` means triage was persisted with gaps (more info requested) and is not operator-final.
+    """
+
+    """
+    allowed enum values
+    """
+    QUEUED = 'queued'
+    RUNNING = 'running'
+    DRAFT = 'draft'
+    COMPLETED = 'completed'
+    FAILED = 'failed'
+    CANCELLED = 'cancelled'
+    RESOLVED = 'resolved'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InvestigationStatus from a JSON string"""
+        return cls(json.loads(json_str))
+
+

stackgen/generated/models/investigation_structured_hypothesis_entry.py

@@ -0,0 +1,115 @@
+# 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 InvestigationStructuredHypothesisEntry(BaseModel):
+    """
+    A ruled-out or unverified hypothesis recorded in structured RCA.
+    """ # noqa: E501
+    statement: StrictStr = Field(description="Plain-language hypothesis statement.")
+    falsifier: Optional[StrictStr] = Field(default=None, description="Evidence that would falsify the hypothesis.")
+    reason: Optional[StrictStr] = Field(default=None, description="Why the hypothesis was ruled out or left unverified.")
+    missing_capability: Optional[StrictStr] = Field(default=None, description="Tool or integration gap that blocked verification.")
+    what_would_falsify: Optional[StrictStr] = Field(default=None, description="Concrete signal that would confirm or reject the hypothesis.")
+    __properties: ClassVar[List[str]] = ["statement", "falsifier", "reason", "missing_capability", "what_would_falsify"]
+
+    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 InvestigationStructuredHypothesisEntry 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,
+        )
+        # set to None if falsifier (nullable) is None
+        # and model_fields_set contains the field
+        if self.falsifier is None and "falsifier" in self.model_fields_set:
+            _dict['falsifier'] = None
+
+        # set to None if reason (nullable) is None
+        # and model_fields_set contains the field
+        if self.reason is None and "reason" in self.model_fields_set:
+            _dict['reason'] = None
+
+        # set to None if missing_capability (nullable) is None
+        # and model_fields_set contains the field
+        if self.missing_capability is None and "missing_capability" in self.model_fields_set:
+            _dict['missing_capability'] = None
+
+        # set to None if what_would_falsify (nullable) is None
+        # and model_fields_set contains the field
+        if self.what_would_falsify is None and "what_would_falsify" in self.model_fields_set:
+            _dict['what_would_falsify'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationStructuredHypothesisEntry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "statement": obj.get("statement"),
+            "falsifier": obj.get("falsifier"),
+            "reason": obj.get("reason"),
+            "missing_capability": obj.get("missing_capability"),
+            "what_would_falsify": obj.get("what_would_falsify")
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_structured_limitation_entry.py

@@ -0,0 +1,120 @@
+# 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 InvestigationStructuredLimitationEntry(BaseModel):
+    """
+    An observability or integration limitation recorded during triage.
+    """ # noqa: E501
+    plane: Optional[StrictStr] = Field(default=None, description="Observability plane (metrics, logs, traces, etc.).")
+    datasource_uid_or_tool: Optional[StrictStr] = Field(default=None, description="Datasource UID or tool name that was unavailable.")
+    error_verbatim: Optional[StrictStr] = Field(default=None, description="Raw error text from the failed probe.")
+    operator_action: Optional[StrictStr] = Field(default=None, description="Suggested operator follow-up.")
+    status: Optional[StrictStr] = Field(default=None, description="Structured limitation outcome (e.g. selector_recovery_exhausted when logs recovery ran but the plane is still empty).")
+    __properties: ClassVar[List[str]] = ["plane", "datasource_uid_or_tool", "error_verbatim", "operator_action", "status"]
+
+    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 InvestigationStructuredLimitationEntry 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,
+        )
+        # set to None if plane (nullable) is None
+        # and model_fields_set contains the field
+        if self.plane is None and "plane" in self.model_fields_set:
+            _dict['plane'] = None
+
+        # set to None if datasource_uid_or_tool (nullable) is None
+        # and model_fields_set contains the field
+        if self.datasource_uid_or_tool is None and "datasource_uid_or_tool" in self.model_fields_set:
+            _dict['datasource_uid_or_tool'] = None
+
+        # set to None if error_verbatim (nullable) is None
+        # and model_fields_set contains the field
+        if self.error_verbatim is None and "error_verbatim" in self.model_fields_set:
+            _dict['error_verbatim'] = None
+
+        # set to None if operator_action (nullable) is None
+        # and model_fields_set contains the field
+        if self.operator_action is None and "operator_action" in self.model_fields_set:
+            _dict['operator_action'] = None
+
+        # set to None if status (nullable) is None
+        # and model_fields_set contains the field
+        if self.status is None and "status" in self.model_fields_set:
+            _dict['status'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationStructuredLimitationEntry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "plane": obj.get("plane"),
+            "datasource_uid_or_tool": obj.get("datasource_uid_or_tool"),
+            "error_verbatim": obj.get("error_verbatim"),
+            "operator_action": obj.get("operator_action"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+