kalir-python 0.1.0__py3-none-any.whl

kalir/models/exposure_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.exposure_webhook_event_type import ExposureWebhookEventType
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.exposure_webhook_event_data import ExposureWebhookEventData
+
+
+
+
+
+T = TypeVar("T", bound="ExposureWebhookEvent")
+
+
+
+@_attrs_define
+class ExposureWebhookEvent:
+    """ 
+        Attributes:
+            id (str | Unset):
+            type_ (ExposureWebhookEventType | Unset):
+            api_version (str | Unset):
+            created_at (datetime.datetime | Unset):
+            data (ExposureWebhookEventData | Unset):
+     """
+
+    id: str | Unset = UNSET
+    type_: ExposureWebhookEventType | Unset = UNSET
+    api_version: str | Unset = UNSET
+    created_at: datetime.datetime | Unset = UNSET
+    data: ExposureWebhookEventData | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.exposure_webhook_event_data import ExposureWebhookEventData # 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.exposure_webhook_event_data import ExposureWebhookEventData # noqa: PLC0415
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        _type_ = d.pop("type", UNSET)
+        type_: ExposureWebhookEventType | Unset
+        if isinstance(_type_,  Unset):
+            type_ = UNSET
+        else:
+            type_ = ExposureWebhookEventType(_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: ExposureWebhookEventData | Unset
+        if isinstance(_data,  Unset):
+            data = UNSET
+        else:
+            data = ExposureWebhookEventData.from_dict(_data)
+
+
+
+
+        exposure_webhook_event = cls(
+            id=id,
+            type_=type_,
+            api_version=api_version,
+            created_at=created_at,
+            data=data,
+        )
+
+
+        exposure_webhook_event.additional_properties = d
+        return exposure_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/exposure_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.exposure_webhook_event_data_exposure import ExposureWebhookEventDataExposure
+  from ..models.exposure_webhook_event_data_infection import ExposureWebhookEventDataInfection
+
+
+
+
+
+T = TypeVar("T", bound="ExposureWebhookEventData")
+
+
+
+@_attrs_define
+class ExposureWebhookEventData:
+    """ 
+        Attributes:
+            exposure (ExposureWebhookEventDataExposure | Unset):
+            infection (ExposureWebhookEventDataInfection | Unset): Only on infostealer.detected.
+     """
+
+    exposure: ExposureWebhookEventDataExposure | Unset = UNSET
+    infection: ExposureWebhookEventDataInfection | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.exposure_webhook_event_data_exposure import ExposureWebhookEventDataExposure # noqa: PLC0415
+        from ..models.exposure_webhook_event_data_infection import ExposureWebhookEventDataInfection # noqa: PLC0415
+        exposure: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.exposure, Unset):
+            exposure = self.exposure.to_dict()
+
+        infection: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.infection, Unset):
+            infection = self.infection.to_dict()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if exposure is not UNSET:
+            field_dict["exposure"] = exposure
+        if infection is not UNSET:
+            field_dict["infection"] = infection
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.exposure_webhook_event_data_exposure import ExposureWebhookEventDataExposure # noqa: PLC0415
+        from ..models.exposure_webhook_event_data_infection import ExposureWebhookEventDataInfection # noqa: PLC0415
+        d = dict(src_dict)
+        _exposure = d.pop("exposure", UNSET)
+        exposure: ExposureWebhookEventDataExposure | Unset
+        if isinstance(_exposure,  Unset):
+            exposure = UNSET
+        else:
+            exposure = ExposureWebhookEventDataExposure.from_dict(_exposure)
+
+
+
+
+        _infection = d.pop("infection", UNSET)
+        infection: ExposureWebhookEventDataInfection | Unset
+        if isinstance(_infection,  Unset):
+            infection = UNSET
+        else:
+            infection = ExposureWebhookEventDataInfection.from_dict(_infection)
+
+
+
+
+        exposure_webhook_event_data = cls(
+            exposure=exposure,
+            infection=infection,
+        )
+
+
+        exposure_webhook_event_data.additional_properties = d
+        return exposure_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/exposure_webhook_event_data_exposure.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
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="ExposureWebhookEventDataExposure")
+
+
+
+@_attrs_define
+class ExposureWebhookEventDataExposure:
+    """ 
+        Attributes:
+            id (str | Unset):
+            email (str | Unset):
+            source_name (str | Unset):
+            breach_date (datetime.datetime | Unset):
+            has_password (bool | Unset):
+            data_classes (list[str] | Unset):
+            url (str | Unset):
+     """
+
+    id: str | Unset = UNSET
+    email: str | Unset = UNSET
+    source_name: str | Unset = UNSET
+    breach_date: datetime.datetime | Unset = UNSET
+    has_password: bool | Unset = UNSET
+    data_classes: list[str] | Unset = UNSET
+    url: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        email = self.email
+
+        source_name = self.source_name
+
+        breach_date: str | Unset = UNSET
+        if not isinstance(self.breach_date, Unset):
+            breach_date = self.breach_date.isoformat()
+
+        has_password = self.has_password
+
+        data_classes: list[str] | Unset = UNSET
+        if not isinstance(self.data_classes, Unset):
+            data_classes = self.data_classes
+
+
+
+        url = self.url
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if id is not UNSET:
+            field_dict["id"] = id
+        if email is not UNSET:
+            field_dict["email"] = email
+        if source_name is not UNSET:
+            field_dict["source_name"] = source_name
+        if breach_date is not UNSET:
+            field_dict["breach_date"] = breach_date
+        if has_password is not UNSET:
+            field_dict["has_password"] = has_password
+        if data_classes is not UNSET:
+            field_dict["data_classes"] = data_classes
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id", UNSET)
+
+        email = d.pop("email", UNSET)
+
+        source_name = d.pop("source_name", UNSET)
+
+        _breach_date = d.pop("breach_date", UNSET)
+        breach_date: datetime.datetime | Unset
+        if isinstance(_breach_date,  Unset):
+            breach_date = UNSET
+        else:
+            breach_date = datetime.datetime.fromisoformat(_breach_date)
+
+
+
+
+        has_password = d.pop("has_password", UNSET)
+
+        data_classes = cast(list[str], d.pop("data_classes", UNSET))
+
+
+        url = d.pop("url", UNSET)
+
+        exposure_webhook_event_data_exposure = cls(
+            id=id,
+            email=email,
+            source_name=source_name,
+            breach_date=breach_date,
+            has_password=has_password,
+            data_classes=data_classes,
+            url=url,
+        )
+
+
+        exposure_webhook_event_data_exposure.additional_properties = d
+        return exposure_webhook_event_data_exposure
+
+    @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/exposure_webhook_event_data_infection.py

@@ -0,0 +1,136 @@
+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
+
+
+
+
+
+
+T = TypeVar("T", bound="ExposureWebhookEventDataInfection")
+
+
+
+@_attrs_define
+class ExposureWebhookEventDataInfection:
+    """ Only on infostealer.detected.
+
+        Attributes:
+            date_compromised (datetime.datetime | Unset):
+            computer_name (str | Unset):
+            operating_system (str | Unset):
+            ip (str | Unset): Masked by the source.
+            total_corporate_services (int | Unset):
+            total_user_services (int | Unset):
+     """
+
+    date_compromised: datetime.datetime | Unset = UNSET
+    computer_name: str | Unset = UNSET
+    operating_system: str | Unset = UNSET
+    ip: str | Unset = UNSET
+    total_corporate_services: int | Unset = UNSET
+    total_user_services: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        date_compromised: str | Unset = UNSET
+        if not isinstance(self.date_compromised, Unset):
+            date_compromised = self.date_compromised.isoformat()
+
+        computer_name = self.computer_name
+
+        operating_system = self.operating_system
+
+        ip = self.ip
+
+        total_corporate_services = self.total_corporate_services
+
+        total_user_services = self.total_user_services
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if date_compromised is not UNSET:
+            field_dict["date_compromised"] = date_compromised
+        if computer_name is not UNSET:
+            field_dict["computer_name"] = computer_name
+        if operating_system is not UNSET:
+            field_dict["operating_system"] = operating_system
+        if ip is not UNSET:
+            field_dict["ip"] = ip
+        if total_corporate_services is not UNSET:
+            field_dict["total_corporate_services"] = total_corporate_services
+        if total_user_services is not UNSET:
+            field_dict["total_user_services"] = total_user_services
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _date_compromised = d.pop("date_compromised", UNSET)
+        date_compromised: datetime.datetime | Unset
+        if isinstance(_date_compromised,  Unset):
+            date_compromised = UNSET
+        else:
+            date_compromised = datetime.datetime.fromisoformat(_date_compromised)
+
+
+
+
+        computer_name = d.pop("computer_name", UNSET)
+
+        operating_system = d.pop("operating_system", UNSET)
+
+        ip = d.pop("ip", UNSET)
+
+        total_corporate_services = d.pop("total_corporate_services", UNSET)
+
+        total_user_services = d.pop("total_user_services", UNSET)
+
+        exposure_webhook_event_data_infection = cls(
+            date_compromised=date_compromised,
+            computer_name=computer_name,
+            operating_system=operating_system,
+            ip=ip,
+            total_corporate_services=total_corporate_services,
+            total_user_services=total_user_services,
+        )
+
+
+        exposure_webhook_event_data_infection.additional_properties = d
+        return exposure_webhook_event_data_infection
+
+    @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/exposure_webhook_event_type.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+class ExposureWebhookEventType(StrEnum):
+    EXPOSURE_DETECTED = "exposure.detected"
+    INFOSTEALER_DETECTED = "infostealer.detected"
+
+    def __str__(self) -> str:
+        return str(self.value)