kalir-python 0.1.0__py3-none-any.whl

kalir/models/list_incidents_bucket.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+class ListIncidentsBucket(StrEnum):
+    AUTO_DISMISSED = "auto_dismissed"
+    IN_PROGRESS = "in_progress"
+    OPEN = "open"
+    RESOLVED = "resolved"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/list_incidents_response_200.py

@@ -0,0 +1,149 @@
+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 import Incident
+  from ..models.list_incidents_response_200_counts import ListIncidentsResponse200Counts
+
+
+
+
+
+T = TypeVar("T", bound="ListIncidentsResponse200")
+
+
+
+@_attrs_define
+class ListIncidentsResponse200:
+    """ 
+        Attributes:
+            incidents (list[Incident] | Unset):
+            total (int | Unset):
+            limit (int | Unset):
+            offset (int | Unset):
+            counts (ListIncidentsResponse200Counts | Unset): Incident counts per lifecycle bucket.
+     """
+
+    incidents: list[Incident] | Unset = UNSET
+    total: int | Unset = UNSET
+    limit: int | Unset = UNSET
+    offset: int | Unset = UNSET
+    counts: ListIncidentsResponse200Counts | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.incident import Incident # noqa: PLC0415
+        from ..models.list_incidents_response_200_counts import ListIncidentsResponse200Counts # noqa: PLC0415
+        incidents: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.incidents, Unset):
+            incidents = []
+            for incidents_item_data in self.incidents:
+                incidents_item = incidents_item_data.to_dict()
+                incidents.append(incidents_item)
+
+
+
+        total = self.total
+
+        limit = self.limit
+
+        offset = self.offset
+
+        counts: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.counts, Unset):
+            counts = self.counts.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if incidents is not UNSET:
+            field_dict["incidents"] = incidents
+        if total is not UNSET:
+            field_dict["total"] = total
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if offset is not UNSET:
+            field_dict["offset"] = offset
+        if counts is not UNSET:
+            field_dict["counts"] = counts
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.incident import Incident # noqa: PLC0415
+        from ..models.list_incidents_response_200_counts import ListIncidentsResponse200Counts # noqa: PLC0415
+        d = dict(src_dict)
+        _incidents = d.pop("incidents", UNSET)
+        incidents: list[Incident] | Unset = UNSET
+        if _incidents is not UNSET:
+            incidents = []
+            for incidents_item_data in _incidents:
+                incidents_item = Incident.from_dict(incidents_item_data)
+
+
+
+                incidents.append(incidents_item)
+
+
+        total = d.pop("total", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        offset = d.pop("offset", UNSET)
+
+        _counts = d.pop("counts", UNSET)
+        counts: ListIncidentsResponse200Counts | Unset
+        if isinstance(_counts,  Unset):
+            counts = UNSET
+        else:
+            counts = ListIncidentsResponse200Counts.from_dict(_counts)
+
+
+
+
+        list_incidents_response_200 = cls(
+            incidents=incidents,
+            total=total,
+            limit=limit,
+            offset=offset,
+            counts=counts,
+        )
+
+
+        list_incidents_response_200.additional_properties = d
+        return list_incidents_response_200
+
+    @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/list_incidents_response_200_counts.py

@@ -0,0 +1,106 @@
+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="ListIncidentsResponse200Counts")
+
+
+
+@_attrs_define
+class ListIncidentsResponse200Counts:
+    """ Incident counts per lifecycle bucket.
+
+        Attributes:
+            open_ (int | Unset):
+            in_progress (int | Unset):
+            resolved (int | Unset):
+            auto_dismissed (int | Unset):
+     """
+
+    open_: int | Unset = UNSET
+    in_progress: int | Unset = UNSET
+    resolved: int | Unset = UNSET
+    auto_dismissed: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        open_ = self.open_
+
+        in_progress = self.in_progress
+
+        resolved = self.resolved
+
+        auto_dismissed = self.auto_dismissed
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if open_ is not UNSET:
+            field_dict["open"] = open_
+        if in_progress is not UNSET:
+            field_dict["in_progress"] = in_progress
+        if resolved is not UNSET:
+            field_dict["resolved"] = resolved
+        if auto_dismissed is not UNSET:
+            field_dict["auto_dismissed"] = auto_dismissed
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        open_ = d.pop("open", UNSET)
+
+        in_progress = d.pop("in_progress", UNSET)
+
+        resolved = d.pop("resolved", UNSET)
+
+        auto_dismissed = d.pop("auto_dismissed", UNSET)
+
+        list_incidents_response_200_counts = cls(
+            open_=open_,
+            in_progress=in_progress,
+            resolved=resolved,
+            auto_dismissed=auto_dismissed,
+        )
+
+
+        list_incidents_response_200_counts.additional_properties = d
+        return list_incidents_response_200_counts
+
+    @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/list_incidents_status.py

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

kalir/models/list_mentions_response_200.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
+
+if TYPE_CHECKING:
+  from ..models.mention import Mention
+  from ..models.pagination import Pagination
+
+
+
+
+
+T = TypeVar("T", bound="ListMentionsResponse200")
+
+
+
+@_attrs_define
+class ListMentionsResponse200:
+    """ 
+        Attributes:
+            data (list[Mention] | Unset):
+            pagination (Pagination | Unset):
+     """
+
+    data: list[Mention] | Unset = UNSET
+    pagination: Pagination | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.mention import Mention # noqa: PLC0415
+        from ..models.pagination import Pagination # noqa: PLC0415
+        data: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = []
+            for data_item_data in self.data:
+                data_item = data_item_data.to_dict()
+                data.append(data_item)
+
+
+
+        pagination: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.pagination, Unset):
+            pagination = self.pagination.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if pagination is not UNSET:
+            field_dict["pagination"] = pagination
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.mention import Mention # noqa: PLC0415
+        from ..models.pagination import Pagination # noqa: PLC0415
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[Mention] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = Mention.from_dict(data_item_data)
+
+
+
+                data.append(data_item)
+
+
+        _pagination = d.pop("pagination", UNSET)
+        pagination: Pagination | Unset
+        if isinstance(_pagination,  Unset):
+            pagination = UNSET
+        else:
+            pagination = Pagination.from_dict(_pagination)
+
+
+
+
+        list_mentions_response_200 = cls(
+            data=data,
+            pagination=pagination,
+        )
+
+
+        list_mentions_response_200.additional_properties = d
+        return list_mentions_response_200
+
+    @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/list_mentions_source.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+class ListMentionsSource(StrEnum):
+    DARKWEB = "darkweb"
+    TELEGRAM = "telegram"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/list_phishing_response_200.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
+
+if TYPE_CHECKING:
+  from ..models.pagination import Pagination
+  from ..models.phishing_domain import PhishingDomain
+
+
+
+
+
+T = TypeVar("T", bound="ListPhishingResponse200")
+
+
+
+@_attrs_define
+class ListPhishingResponse200:
+    """ 
+        Attributes:
+            data (list[PhishingDomain] | Unset):
+            pagination (Pagination | Unset):
+     """
+
+    data: list[PhishingDomain] | Unset = UNSET
+    pagination: Pagination | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.pagination import Pagination # noqa: PLC0415
+        from ..models.phishing_domain import PhishingDomain # noqa: PLC0415
+        data: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.data, Unset):
+            data = []
+            for data_item_data in self.data:
+                data_item = data_item_data.to_dict()
+                data.append(data_item)
+
+
+
+        pagination: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.pagination, Unset):
+            pagination = self.pagination.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if data is not UNSET:
+            field_dict["data"] = data
+        if pagination is not UNSET:
+            field_dict["pagination"] = pagination
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.pagination import Pagination # noqa: PLC0415
+        from ..models.phishing_domain import PhishingDomain # noqa: PLC0415
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[PhishingDomain] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = PhishingDomain.from_dict(data_item_data)
+
+
+
+                data.append(data_item)
+
+
+        _pagination = d.pop("pagination", UNSET)
+        pagination: Pagination | Unset
+        if isinstance(_pagination,  Unset):
+            pagination = UNSET
+        else:
+            pagination = Pagination.from_dict(_pagination)
+
+
+
+
+        list_phishing_response_200 = cls(
+            data=data,
+            pagination=pagination,
+        )
+
+
+        list_phishing_response_200.additional_properties = d
+        return list_phishing_response_200
+
+    @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/list_phishing_verdict.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+class ListPhishingVerdict(StrEnum):
+    CONFIRMED = "confirmed"
+    INACTIVE = "inactive"
+    POSSIBLE = "possible"
+    POSSIBLE_FP = "possible_fp"
+    UNVERIFIED = "unverified"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/list_ransomware_victims_response_200.py

@@ -0,0 +1,109 @@
+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.list_ransomware_victims_response_200_victims_item import ListRansomwareVictimsResponse200VictimsItem
+
+
+
+
+
+T = TypeVar("T", bound="ListRansomwareVictimsResponse200")
+
+
+
+@_attrs_define
+class ListRansomwareVictimsResponse200:
+    """ 
+        Attributes:
+            victims (list[ListRansomwareVictimsResponse200VictimsItem] | Unset):
+            total (int | Unset):
+     """
+
+    victims: list[ListRansomwareVictimsResponse200VictimsItem] | Unset = UNSET
+    total: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.list_ransomware_victims_response_200_victims_item import ListRansomwareVictimsResponse200VictimsItem # noqa: PLC0415
+        victims: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.victims, Unset):
+            victims = []
+            for victims_item_data in self.victims:
+                victims_item = victims_item_data.to_dict()
+                victims.append(victims_item)
+
+
+
+        total = self.total
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if victims is not UNSET:
+            field_dict["victims"] = victims
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.list_ransomware_victims_response_200_victims_item import ListRansomwareVictimsResponse200VictimsItem # noqa: PLC0415
+        d = dict(src_dict)
+        _victims = d.pop("victims", UNSET)
+        victims: list[ListRansomwareVictimsResponse200VictimsItem] | Unset = UNSET
+        if _victims is not UNSET:
+            victims = []
+            for victims_item_data in _victims:
+                victims_item = ListRansomwareVictimsResponse200VictimsItem.from_dict(victims_item_data)
+
+
+
+                victims.append(victims_item)
+
+
+        total = d.pop("total", UNSET)
+
+        list_ransomware_victims_response_200 = cls(
+            victims=victims,
+            total=total,
+        )
+
+
+        list_ransomware_victims_response_200.additional_properties = d
+        return list_ransomware_victims_response_200
+
+    @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