kalir-python 0.1.0__py3-none-any.whl

kalir/models/infostealer_domain_summary_snapshot.py

@@ -0,0 +1,201 @@
+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.infostealer_domain_summary_snapshot_top_employee_urls_item import InfostealerDomainSummarySnapshotTopEmployeeUrlsItem
+  from ..models.infostealer_domain_summary_snapshot_top_families_item import InfostealerDomainSummarySnapshotTopFamiliesItem
+
+
+
+
+
+T = TypeVar("T", bound="InfostealerDomainSummarySnapshot")
+
+
+
+@_attrs_define
+class InfostealerDomainSummarySnapshot:
+    """ 
+        Attributes:
+            total_stealers (int | Unset):
+            employees (int | Unset):
+            users (int | Unset):
+            third_parties (int | Unset):
+            employee_weak_pct (float | Unset):
+            last_employee_compromised (str | Unset):
+            last_user_compromised (str | Unset):
+            degraded (bool | Unset):
+            top_families (list[InfostealerDomainSummarySnapshotTopFamiliesItem] | Unset):
+            top_employee_urls (list[InfostealerDomainSummarySnapshotTopEmployeeUrlsItem] | Unset):
+     """
+
+    total_stealers: int | Unset = UNSET
+    employees: int | Unset = UNSET
+    users: int | Unset = UNSET
+    third_parties: int | Unset = UNSET
+    employee_weak_pct: float | Unset = UNSET
+    last_employee_compromised: str | Unset = UNSET
+    last_user_compromised: str | Unset = UNSET
+    degraded: bool | Unset = UNSET
+    top_families: list[InfostealerDomainSummarySnapshotTopFamiliesItem] | Unset = UNSET
+    top_employee_urls: list[InfostealerDomainSummarySnapshotTopEmployeeUrlsItem] | 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_top_employee_urls_item import InfostealerDomainSummarySnapshotTopEmployeeUrlsItem # noqa: PLC0415
+        from ..models.infostealer_domain_summary_snapshot_top_families_item import InfostealerDomainSummarySnapshotTopFamiliesItem # noqa: PLC0415
+        total_stealers = self.total_stealers
+
+        employees = self.employees
+
+        users = self.users
+
+        third_parties = self.third_parties
+
+        employee_weak_pct = self.employee_weak_pct
+
+        last_employee_compromised = self.last_employee_compromised
+
+        last_user_compromised = self.last_user_compromised
+
+        degraded = self.degraded
+
+        top_families: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.top_families, Unset):
+            top_families = []
+            for top_families_item_data in self.top_families:
+                top_families_item = top_families_item_data.to_dict()
+                top_families.append(top_families_item)
+
+
+
+        top_employee_urls: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.top_employee_urls, Unset):
+            top_employee_urls = []
+            for top_employee_urls_item_data in self.top_employee_urls:
+                top_employee_urls_item = top_employee_urls_item_data.to_dict()
+                top_employee_urls.append(top_employee_urls_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if total_stealers is not UNSET:
+            field_dict["total_stealers"] = total_stealers
+        if employees is not UNSET:
+            field_dict["employees"] = employees
+        if users is not UNSET:
+            field_dict["users"] = users
+        if third_parties is not UNSET:
+            field_dict["third_parties"] = third_parties
+        if employee_weak_pct is not UNSET:
+            field_dict["employee_weak_pct"] = employee_weak_pct
+        if last_employee_compromised is not UNSET:
+            field_dict["last_employee_compromised"] = last_employee_compromised
+        if last_user_compromised is not UNSET:
+            field_dict["last_user_compromised"] = last_user_compromised
+        if degraded is not UNSET:
+            field_dict["degraded"] = degraded
+        if top_families is not UNSET:
+            field_dict["top_families"] = top_families
+        if top_employee_urls is not UNSET:
+            field_dict["top_employee_urls"] = top_employee_urls
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.infostealer_domain_summary_snapshot_top_employee_urls_item import InfostealerDomainSummarySnapshotTopEmployeeUrlsItem # noqa: PLC0415
+        from ..models.infostealer_domain_summary_snapshot_top_families_item import InfostealerDomainSummarySnapshotTopFamiliesItem # noqa: PLC0415
+        d = dict(src_dict)
+        total_stealers = d.pop("total_stealers", UNSET)
+
+        employees = d.pop("employees", UNSET)
+
+        users = d.pop("users", UNSET)
+
+        third_parties = d.pop("third_parties", UNSET)
+
+        employee_weak_pct = d.pop("employee_weak_pct", UNSET)
+
+        last_employee_compromised = d.pop("last_employee_compromised", UNSET)
+
+        last_user_compromised = d.pop("last_user_compromised", UNSET)
+
+        degraded = d.pop("degraded", UNSET)
+
+        _top_families = d.pop("top_families", UNSET)
+        top_families: list[InfostealerDomainSummarySnapshotTopFamiliesItem] | Unset = UNSET
+        if _top_families is not UNSET:
+            top_families = []
+            for top_families_item_data in _top_families:
+                top_families_item = InfostealerDomainSummarySnapshotTopFamiliesItem.from_dict(top_families_item_data)
+
+
+
+                top_families.append(top_families_item)
+
+
+        _top_employee_urls = d.pop("top_employee_urls", UNSET)
+        top_employee_urls: list[InfostealerDomainSummarySnapshotTopEmployeeUrlsItem] | Unset = UNSET
+        if _top_employee_urls is not UNSET:
+            top_employee_urls = []
+            for top_employee_urls_item_data in _top_employee_urls:
+                top_employee_urls_item = InfostealerDomainSummarySnapshotTopEmployeeUrlsItem.from_dict(top_employee_urls_item_data)
+
+
+
+                top_employee_urls.append(top_employee_urls_item)
+
+
+        infostealer_domain_summary_snapshot = cls(
+            total_stealers=total_stealers,
+            employees=employees,
+            users=users,
+            third_parties=third_parties,
+            employee_weak_pct=employee_weak_pct,
+            last_employee_compromised=last_employee_compromised,
+            last_user_compromised=last_user_compromised,
+            degraded=degraded,
+            top_families=top_families,
+            top_employee_urls=top_employee_urls,
+        )
+
+
+        infostealer_domain_summary_snapshot.additional_properties = d
+        return infostealer_domain_summary_snapshot
+
+    @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/infostealer_domain_summary_snapshot_top_employee_urls_item.py

@@ -0,0 +1,87 @@
+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="InfostealerDomainSummarySnapshotTopEmployeeUrlsItem")
+
+
+
+@_attrs_define
+class InfostealerDomainSummarySnapshotTopEmployeeUrlsItem:
+    """ 
+        Attributes:
+            url (str | Unset):
+            occurrence (int | Unset):
+     """
+
+    url: str | Unset = UNSET
+    occurrence: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        occurrence = self.occurrence
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if url is not UNSET:
+            field_dict["url"] = url
+        if occurrence is not UNSET:
+            field_dict["occurrence"] = occurrence
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        url = d.pop("url", UNSET)
+
+        occurrence = d.pop("occurrence", UNSET)
+
+        infostealer_domain_summary_snapshot_top_employee_urls_item = cls(
+            url=url,
+            occurrence=occurrence,
+        )
+
+
+        infostealer_domain_summary_snapshot_top_employee_urls_item.additional_properties = d
+        return infostealer_domain_summary_snapshot_top_employee_urls_item
+
+    @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/infostealer_domain_summary_snapshot_top_families_item.py

@@ -0,0 +1,87 @@
+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="InfostealerDomainSummarySnapshotTopFamiliesItem")
+
+
+
+@_attrs_define
+class InfostealerDomainSummarySnapshotTopFamiliesItem:
+    """ 
+        Attributes:
+            family (str | Unset):
+            count (int | Unset):
+     """
+
+    family: str | Unset = UNSET
+    count: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        family = self.family
+
+        count = self.count
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if family is not UNSET:
+            field_dict["family"] = family
+        if count is not UNSET:
+            field_dict["count"] = count
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        family = d.pop("family", UNSET)
+
+        count = d.pop("count", UNSET)
+
+        infostealer_domain_summary_snapshot_top_families_item = cls(
+            family=family,
+            count=count,
+        )
+
+
+        infostealer_domain_summary_snapshot_top_families_item.additional_properties = d
+        return infostealer_domain_summary_snapshot_top_families_item
+
+    @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_assets_response_200.py

@@ -0,0 +1,100 @@
+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.asset import Asset
+
+
+
+
+
+T = TypeVar("T", bound="ListAssetsResponse200")
+
+
+
+@_attrs_define
+class ListAssetsResponse200:
+    """ 
+        Attributes:
+            assets (list[Asset] | Unset):
+     """
+
+    assets: list[Asset] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.asset import Asset # noqa: PLC0415
+        assets: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.assets, Unset):
+            assets = []
+            for assets_item_data in self.assets:
+                assets_item = assets_item_data.to_dict()
+                assets.append(assets_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if assets is not UNSET:
+            field_dict["assets"] = assets
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.asset import Asset # noqa: PLC0415
+        d = dict(src_dict)
+        _assets = d.pop("assets", UNSET)
+        assets: list[Asset] | Unset = UNSET
+        if _assets is not UNSET:
+            assets = []
+            for assets_item_data in _assets:
+                assets_item = Asset.from_dict(assets_item_data)
+
+
+
+                assets.append(assets_item)
+
+
+        list_assets_response_200 = cls(
+            assets=assets,
+        )
+
+
+        list_assets_response_200.additional_properties = d
+        return list_assets_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_events_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.event import Event
+
+
+
+
+
+T = TypeVar("T", bound="ListEventsResponse200")
+
+
+
+@_attrs_define
+class ListEventsResponse200:
+    """ 
+        Attributes:
+            events (list[Event] | Unset):
+            total (int | Unset):
+     """
+
+    events: list[Event] | 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.event import Event # noqa: PLC0415
+        events: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.events, Unset):
+            events = []
+            for events_item_data in self.events:
+                events_item = events_item_data.to_dict()
+                events.append(events_item)
+
+
+
+        total = self.total
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if events is not UNSET:
+            field_dict["events"] = events
+        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.event import Event # noqa: PLC0415
+        d = dict(src_dict)
+        _events = d.pop("events", UNSET)
+        events: list[Event] | Unset = UNSET
+        if _events is not UNSET:
+            events = []
+            for events_item_data in _events:
+                events_item = Event.from_dict(events_item_data)
+
+
+
+                events.append(events_item)
+
+
+        total = d.pop("total", UNSET)
+
+        list_events_response_200 = cls(
+            events=events,
+            total=total,
+        )
+
+
+        list_events_response_200.additional_properties = d
+        return list_events_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_exposures_response_200.py

@@ -0,0 +1,127 @@
+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.exposure import Exposure
+
+
+
+
+
+T = TypeVar("T", bound="ListExposuresResponse200")
+
+
+
+@_attrs_define
+class ListExposuresResponse200:
+    """ 
+        Attributes:
+            exposures (list[Exposure] | Unset):
+            total (int | Unset):
+            limit (int | Unset):
+            offset (int | Unset):
+     """
+
+    exposures: list[Exposure] | Unset = UNSET
+    total: int | Unset = UNSET
+    limit: int | Unset = UNSET
+    offset: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.exposure import Exposure # noqa: PLC0415
+        exposures: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.exposures, Unset):
+            exposures = []
+            for exposures_item_data in self.exposures:
+                exposures_item = exposures_item_data.to_dict()
+                exposures.append(exposures_item)
+
+
+
+        total = self.total
+
+        limit = self.limit
+
+        offset = self.offset
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if exposures is not UNSET:
+            field_dict["exposures"] = exposures
+        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
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.exposure import Exposure # noqa: PLC0415
+        d = dict(src_dict)
+        _exposures = d.pop("exposures", UNSET)
+        exposures: list[Exposure] | Unset = UNSET
+        if _exposures is not UNSET:
+            exposures = []
+            for exposures_item_data in _exposures:
+                exposures_item = Exposure.from_dict(exposures_item_data)
+
+
+
+                exposures.append(exposures_item)
+
+
+        total = d.pop("total", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        offset = d.pop("offset", UNSET)
+
+        list_exposures_response_200 = cls(
+            exposures=exposures,
+            total=total,
+            limit=limit,
+            offset=offset,
+        )
+
+
+        list_exposures_response_200.additional_properties = d
+        return list_exposures_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