kalir-python 0.1.0__py3-none-any.whl

kalir/models/incident.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.incident_severity import IncidentSeverity
+from ..models.incident_status import IncidentStatus
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="Incident")
+
+
+
+@_attrs_define
+class Incident:
+    """ 
+        Attributes:
+            incident_id (UUID | Unset):
+            title (str | Unset):
+            status (IncidentStatus | Unset):
+            severity (IncidentSeverity | Unset):
+            signal_family (str | Unset):
+            created_at (datetime.datetime | Unset):
+     """
+
+    incident_id: UUID | Unset = UNSET
+    title: str | Unset = UNSET
+    status: IncidentStatus | Unset = UNSET
+    severity: IncidentSeverity | Unset = UNSET
+    signal_family: str | Unset = UNSET
+    created_at: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        incident_id: str | Unset = UNSET
+        if not isinstance(self.incident_id, Unset):
+            incident_id = str(self.incident_id)
+
+        title = self.title
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+
+        severity: str | Unset = UNSET
+        if not isinstance(self.severity, Unset):
+            severity = self.severity.value
+
+
+        signal_family = self.signal_family
+
+        created_at: str | Unset = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if incident_id is not UNSET:
+            field_dict["incident_id"] = incident_id
+        if title is not UNSET:
+            field_dict["title"] = title
+        if status is not UNSET:
+            field_dict["status"] = status
+        if severity is not UNSET:
+            field_dict["severity"] = severity
+        if signal_family is not UNSET:
+            field_dict["signal_family"] = signal_family
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _incident_id = d.pop("incident_id", UNSET)
+        incident_id: UUID | Unset
+        if isinstance(_incident_id,  Unset):
+            incident_id = UNSET
+        else:
+            incident_id = UUID(_incident_id)
+
+
+
+
+        title = d.pop("title", UNSET)
+
+        _status = d.pop("status", UNSET)
+        status: IncidentStatus | Unset
+        if isinstance(_status,  Unset):
+            status = UNSET
+        else:
+            status = IncidentStatus(_status)
+
+
+
+
+        _severity = d.pop("severity", UNSET)
+        severity: IncidentSeverity | Unset
+        if isinstance(_severity,  Unset):
+            severity = UNSET
+        else:
+            severity = IncidentSeverity(_severity)
+
+
+
+
+        signal_family = d.pop("signal_family", UNSET)
+
+        _created_at = d.pop("created_at", UNSET)
+        created_at: datetime.datetime | Unset
+        if isinstance(_created_at,  Unset):
+            created_at = UNSET
+        else:
+            created_at = datetime.datetime.fromisoformat(_created_at)
+
+
+
+
+        incident = cls(
+            incident_id=incident_id,
+            title=title,
+            status=status,
+            severity=severity,
+            signal_family=signal_family,
+            created_at=created_at,
+        )
+
+
+        incident.additional_properties = d
+        return incident
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

kalir/models/incident_severity.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+class IncidentSeverity(StrEnum):
+    CRITICAL = "critical"
+    HIGH = "high"
+    LOW = "low"
+    MEDIUM = "medium"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/incident_status.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+class IncidentStatus(StrEnum):
+    ACKNOWLEDGED = "acknowledged"
+    CLOSED = "closed"
+    MITIGATED = "mitigated"
+    OPEN = "open"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/incident_webhook_event.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.incident_webhook_event_type import IncidentWebhookEventType
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.incident_webhook_event_data import IncidentWebhookEventData
+
+
+
+
+
+T = TypeVar("T", bound="IncidentWebhookEvent")
+
+
+
+@_attrs_define
+class IncidentWebhookEvent:
+    """ 
+        Attributes:
+            id (str | Unset):
+            type_ (IncidentWebhookEventType | Unset):
+            api_version (str | Unset):
+            created_at (datetime.datetime | Unset):
+            data (IncidentWebhookEventData | Unset):
+     """
+
+    id: str | Unset = UNSET
+    type_: IncidentWebhookEventType | Unset = UNSET
+    api_version: str | Unset = UNSET
+    created_at: datetime.datetime | Unset = UNSET
+    data: IncidentWebhookEventData | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.incident_webhook_event_data import IncidentWebhookEventData # noqa: PLC0415
+        id = self.id
+
+        type_: str | Unset = UNSET
+        if not isinstance(self.type_, Unset):
+            type_ = self.type_.value
+
+
+        api_version = self.api_version
+
+        created_at: str | Unset = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+        data: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = self.data.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if id is not UNSET:
+            field_dict["id"] = id
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if api_version is not UNSET:
+            field_dict["api_version"] = api_version
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if data is not UNSET:
+            field_dict["data"] = data
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.incident_webhook_event_data import IncidentWebhookEventData # noqa: PLC0415
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        _type_ = d.pop("type", UNSET)
+        type_: IncidentWebhookEventType | Unset
+        if isinstance(_type_,  Unset):
+            type_ = UNSET
+        else:
+            type_ = IncidentWebhookEventType(_type_)
+
+
+
+
+        api_version = d.pop("api_version", UNSET)
+
+        _created_at = d.pop("created_at", UNSET)
+        created_at: datetime.datetime | Unset
+        if isinstance(_created_at,  Unset):
+            created_at = UNSET
+        else:
+            created_at = datetime.datetime.fromisoformat(_created_at)
+
+
+
+
+        _data = d.pop("data", UNSET)
+        data: IncidentWebhookEventData | Unset
+        if isinstance(_data,  Unset):
+            data = UNSET
+        else:
+            data = IncidentWebhookEventData.from_dict(_data)
+
+
+
+
+        incident_webhook_event = cls(
+            id=id,
+            type_=type_,
+            api_version=api_version,
+            created_at=created_at,
+            data=data,
+        )
+
+
+        incident_webhook_event.additional_properties = d
+        return incident_webhook_event
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

kalir/models/incident_webhook_event_data.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+  from ..models.incident_webhook_event_data_previous import IncidentWebhookEventDataPrevious
+  from ..models.webhook_incident import WebhookIncident
+
+
+
+
+
+T = TypeVar("T", bound="IncidentWebhookEventData")
+
+
+
+@_attrs_define
+class IncidentWebhookEventData:
+    """ 
+        Attributes:
+            incident (WebhookIncident | Unset):
+            previous (IncidentWebhookEventDataPrevious | Unset): Only on incident.updated.
+     """
+
+    incident: WebhookIncident | Unset = UNSET
+    previous: IncidentWebhookEventDataPrevious | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.incident_webhook_event_data_previous import IncidentWebhookEventDataPrevious # noqa: PLC0415
+        from ..models.webhook_incident import WebhookIncident # noqa: PLC0415
+        incident: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.incident, Unset):
+            incident = self.incident.to_dict()
+
+        previous: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.previous, Unset):
+            previous = self.previous.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if incident is not UNSET:
+            field_dict["incident"] = incident
+        if previous is not UNSET:
+            field_dict["previous"] = previous
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.incident_webhook_event_data_previous import IncidentWebhookEventDataPrevious # noqa: PLC0415
+        from ..models.webhook_incident import WebhookIncident # noqa: PLC0415
+        d = dict(src_dict)
+        _incident = d.pop("incident", UNSET)
+        incident: WebhookIncident | Unset
+        if isinstance(_incident,  Unset):
+            incident = UNSET
+        else:
+            incident = WebhookIncident.from_dict(_incident)
+
+
+
+
+        _previous = d.pop("previous", UNSET)
+        previous: IncidentWebhookEventDataPrevious | Unset
+        if isinstance(_previous,  Unset):
+            previous = UNSET
+        else:
+            previous = IncidentWebhookEventDataPrevious.from_dict(_previous)
+
+
+
+
+        incident_webhook_event_data = cls(
+            incident=incident,
+            previous=previous,
+        )
+
+
+        incident_webhook_event_data.additional_properties = d
+        return incident_webhook_event_data
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

kalir/models/incident_webhook_event_data_previous.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="IncidentWebhookEventDataPrevious")
+
+
+
+@_attrs_define
+class IncidentWebhookEventDataPrevious:
+    """ Only on incident.updated.
+
+        Attributes:
+            status (str | Unset):
+            severity (str | Unset):
+     """
+
+    status: str | Unset = UNSET
+    severity: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status
+
+        severity = self.severity
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if status is not UNSET:
+            field_dict["status"] = status
+        if severity is not UNSET:
+            field_dict["severity"] = severity
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = d.pop("status", UNSET)
+
+        severity = d.pop("severity", UNSET)
+
+        incident_webhook_event_data_previous = cls(
+            status=status,
+            severity=severity,
+        )
+
+
+        incident_webhook_event_data_previous.additional_properties = d
+        return incident_webhook_event_data_previous
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

kalir/models/incident_webhook_event_type.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+class IncidentWebhookEventType(StrEnum):
+    INCIDENT_CREATED = "incident.created"
+    INCIDENT_UPDATED = "incident.updated"
+    PHISHING_DETECTED = "phishing.detected"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/infostealer_domain_summary.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.infostealer_domain_summary_snapshot import InfostealerDomainSummarySnapshot
+
+
+
+
+
+T = TypeVar("T", bound="InfostealerDomainSummary")
+
+
+
+@_attrs_define
+class InfostealerDomainSummary:
+    """ 
+        Attributes:
+            domain (str | Unset):
+            refreshed_at (datetime.datetime | Unset):
+            snapshot (InfostealerDomainSummarySnapshot | Unset):
+     """
+
+    domain: str | Unset = UNSET
+    refreshed_at: datetime.datetime | Unset = UNSET
+    snapshot: InfostealerDomainSummarySnapshot | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.infostealer_domain_summary_snapshot import InfostealerDomainSummarySnapshot # noqa: PLC0415
+        domain = self.domain
+
+        refreshed_at: str | Unset = UNSET
+        if not isinstance(self.refreshed_at, Unset):
+            refreshed_at = self.refreshed_at.isoformat()
+
+        snapshot: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.snapshot, Unset):
+            snapshot = self.snapshot.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if domain is not UNSET:
+            field_dict["domain"] = domain
+        if refreshed_at is not UNSET:
+            field_dict["refreshed_at"] = refreshed_at
+        if snapshot is not UNSET:
+            field_dict["snapshot"] = snapshot
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.infostealer_domain_summary_snapshot import InfostealerDomainSummarySnapshot # noqa: PLC0415
+        d = dict(src_dict)
+        domain = d.pop("domain", UNSET)
+
+        _refreshed_at = d.pop("refreshed_at", UNSET)
+        refreshed_at: datetime.datetime | Unset
+        if isinstance(_refreshed_at,  Unset):
+            refreshed_at = UNSET
+        else:
+            refreshed_at = datetime.datetime.fromisoformat(_refreshed_at)
+
+
+
+
+        _snapshot = d.pop("snapshot", UNSET)
+        snapshot: InfostealerDomainSummarySnapshot | Unset
+        if isinstance(_snapshot,  Unset):
+            snapshot = UNSET
+        else:
+            snapshot = InfostealerDomainSummarySnapshot.from_dict(_snapshot)
+
+
+
+
+        infostealer_domain_summary = cls(
+            domain=domain,
+            refreshed_at=refreshed_at,
+            snapshot=snapshot,
+        )
+
+
+        infostealer_domain_summary.additional_properties = d
+        return infostealer_domain_summary
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties