kalir-python 0.1.0__py3-none-any.whl

kalir/models/list_webhooks_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.webhook_endpoint import WebhookEndpoint
+
+
+
+
+
+T = TypeVar("T", bound="ListWebhooksResponse200")
+
+
+
+@_attrs_define
+class ListWebhooksResponse200:
+    """ 
+        Attributes:
+            data (list[WebhookEndpoint] | Unset):
+     """
+
+    data: list[WebhookEndpoint] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.webhook_endpoint import WebhookEndpoint # 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)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        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.webhook_endpoint import WebhookEndpoint # noqa: PLC0415
+        d = dict(src_dict)
+        _data = d.pop("data", UNSET)
+        data: list[WebhookEndpoint] | Unset = UNSET
+        if _data is not UNSET:
+            data = []
+            for data_item_data in _data:
+                data_item = WebhookEndpoint.from_dict(data_item_data)
+
+
+
+                data.append(data_item)
+
+
+        list_webhooks_response_200 = cls(
+            data=data,
+        )
+
+
+        list_webhooks_response_200.additional_properties = d
+        return list_webhooks_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/mention.py

@@ -0,0 +1,194 @@
+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.mention_source import MentionSource
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="Mention")
+
+
+
+@_attrs_define
+class Mention:
+    """ 
+        Attributes:
+            id (UUID | Unset):
+            source (MentionSource | Unset):
+            source_name (str | Unset):
+            title (str | Unset):
+            url (str | Unset):
+            matched_term (str | Unset):
+            context (str | Unset): Snippet around the match.
+            intel_value (str | Unset):
+            screenshot_url (str | Unset):
+            detected_at (datetime.datetime | Unset):
+     """
+
+    id: UUID | Unset = UNSET
+    source: MentionSource | Unset = UNSET
+    source_name: str | Unset = UNSET
+    title: str | Unset = UNSET
+    url: str | Unset = UNSET
+    matched_term: str | Unset = UNSET
+    context: str | Unset = UNSET
+    intel_value: str | Unset = UNSET
+    screenshot_url: str | Unset = UNSET
+    detected_at: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id: str | Unset = UNSET
+        if not isinstance(self.id, Unset):
+            id = str(self.id)
+
+        source: str | Unset = UNSET
+        if not isinstance(self.source, Unset):
+            source = self.source.value
+
+
+        source_name = self.source_name
+
+        title = self.title
+
+        url = self.url
+
+        matched_term = self.matched_term
+
+        context = self.context
+
+        intel_value = self.intel_value
+
+        screenshot_url = self.screenshot_url
+
+        detected_at: str | Unset = UNSET
+        if not isinstance(self.detected_at, Unset):
+            detected_at = self.detected_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if id is not UNSET:
+            field_dict["id"] = id
+        if source is not UNSET:
+            field_dict["source"] = source
+        if source_name is not UNSET:
+            field_dict["source_name"] = source_name
+        if title is not UNSET:
+            field_dict["title"] = title
+        if url is not UNSET:
+            field_dict["url"] = url
+        if matched_term is not UNSET:
+            field_dict["matched_term"] = matched_term
+        if context is not UNSET:
+            field_dict["context"] = context
+        if intel_value is not UNSET:
+            field_dict["intel_value"] = intel_value
+        if screenshot_url is not UNSET:
+            field_dict["screenshot_url"] = screenshot_url
+        if detected_at is not UNSET:
+            field_dict["detected_at"] = detected_at
+
+        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)
+        id: UUID | Unset
+        if isinstance(_id,  Unset):
+            id = UNSET
+        else:
+            id = UUID(_id)
+
+
+
+
+        _source = d.pop("source", UNSET)
+        source: MentionSource | Unset
+        if isinstance(_source,  Unset):
+            source = UNSET
+        else:
+            source = MentionSource(_source)
+
+
+
+
+        source_name = d.pop("source_name", UNSET)
+
+        title = d.pop("title", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        matched_term = d.pop("matched_term", UNSET)
+
+        context = d.pop("context", UNSET)
+
+        intel_value = d.pop("intel_value", UNSET)
+
+        screenshot_url = d.pop("screenshot_url", UNSET)
+
+        _detected_at = d.pop("detected_at", UNSET)
+        detected_at: datetime.datetime | Unset
+        if isinstance(_detected_at,  Unset):
+            detected_at = UNSET
+        else:
+            detected_at = datetime.datetime.fromisoformat(_detected_at)
+
+
+
+
+        mention = cls(
+            id=id,
+            source=source,
+            source_name=source_name,
+            title=title,
+            url=url,
+            matched_term=matched_term,
+            context=context,
+            intel_value=intel_value,
+            screenshot_url=screenshot_url,
+            detected_at=detected_at,
+        )
+
+
+        mention.additional_properties = d
+        return mention
+
+    @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/mention_source.py

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

kalir/models/overview.py

@@ -0,0 +1,231 @@
+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.overview_risk_level import OverviewRiskLevel
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.overview_assets import OverviewAssets
+  from ..models.overview_exposures import OverviewExposures
+  from ..models.overview_incidents import OverviewIncidents
+  from ..models.overview_phishing import OverviewPhishing
+  from ..models.overview_takedowns import OverviewTakedowns
+
+
+
+
+
+T = TypeVar("T", bound="Overview")
+
+
+
+@_attrs_define
+class Overview:
+    """ 
+        Attributes:
+            risk_score (int | Unset):
+            risk_level (OverviewRiskLevel | Unset):
+            incidents (OverviewIncidents | Unset):
+            exposures (OverviewExposures | Unset):
+            phishing (OverviewPhishing | Unset):
+            takedowns (OverviewTakedowns | Unset):
+            assets (OverviewAssets | Unset):
+            generated_at (datetime.datetime | Unset):
+     """
+
+    risk_score: int | Unset = UNSET
+    risk_level: OverviewRiskLevel | Unset = UNSET
+    incidents: OverviewIncidents | Unset = UNSET
+    exposures: OverviewExposures | Unset = UNSET
+    phishing: OverviewPhishing | Unset = UNSET
+    takedowns: OverviewTakedowns | Unset = UNSET
+    assets: OverviewAssets | Unset = UNSET
+    generated_at: datetime.datetime | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.overview_assets import OverviewAssets # noqa: PLC0415
+        from ..models.overview_exposures import OverviewExposures # noqa: PLC0415
+        from ..models.overview_incidents import OverviewIncidents # noqa: PLC0415
+        from ..models.overview_phishing import OverviewPhishing # noqa: PLC0415
+        from ..models.overview_takedowns import OverviewTakedowns # noqa: PLC0415
+        risk_score = self.risk_score
+
+        risk_level: str | Unset = UNSET
+        if not isinstance(self.risk_level, Unset):
+            risk_level = self.risk_level.value
+
+
+        incidents: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.incidents, Unset):
+            incidents = self.incidents.to_dict()
+
+        exposures: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.exposures, Unset):
+            exposures = self.exposures.to_dict()
+
+        phishing: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.phishing, Unset):
+            phishing = self.phishing.to_dict()
+
+        takedowns: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.takedowns, Unset):
+            takedowns = self.takedowns.to_dict()
+
+        assets: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.assets, Unset):
+            assets = self.assets.to_dict()
+
+        generated_at: str | Unset = UNSET
+        if not isinstance(self.generated_at, Unset):
+            generated_at = self.generated_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if risk_score is not UNSET:
+            field_dict["risk_score"] = risk_score
+        if risk_level is not UNSET:
+            field_dict["risk_level"] = risk_level
+        if incidents is not UNSET:
+            field_dict["incidents"] = incidents
+        if exposures is not UNSET:
+            field_dict["exposures"] = exposures
+        if phishing is not UNSET:
+            field_dict["phishing"] = phishing
+        if takedowns is not UNSET:
+            field_dict["takedowns"] = takedowns
+        if assets is not UNSET:
+            field_dict["assets"] = assets
+        if generated_at is not UNSET:
+            field_dict["generated_at"] = generated_at
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.overview_assets import OverviewAssets # noqa: PLC0415
+        from ..models.overview_exposures import OverviewExposures # noqa: PLC0415
+        from ..models.overview_incidents import OverviewIncidents # noqa: PLC0415
+        from ..models.overview_phishing import OverviewPhishing # noqa: PLC0415
+        from ..models.overview_takedowns import OverviewTakedowns # noqa: PLC0415
+        d = dict(src_dict)
+        risk_score = d.pop("risk_score", UNSET)
+
+        _risk_level = d.pop("risk_level", UNSET)
+        risk_level: OverviewRiskLevel | Unset
+        if isinstance(_risk_level,  Unset):
+            risk_level = UNSET
+        else:
+            risk_level = OverviewRiskLevel(_risk_level)
+
+
+
+
+        _incidents = d.pop("incidents", UNSET)
+        incidents: OverviewIncidents | Unset
+        if isinstance(_incidents,  Unset):
+            incidents = UNSET
+        else:
+            incidents = OverviewIncidents.from_dict(_incidents)
+
+
+
+
+        _exposures = d.pop("exposures", UNSET)
+        exposures: OverviewExposures | Unset
+        if isinstance(_exposures,  Unset):
+            exposures = UNSET
+        else:
+            exposures = OverviewExposures.from_dict(_exposures)
+
+
+
+
+        _phishing = d.pop("phishing", UNSET)
+        phishing: OverviewPhishing | Unset
+        if isinstance(_phishing,  Unset):
+            phishing = UNSET
+        else:
+            phishing = OverviewPhishing.from_dict(_phishing)
+
+
+
+
+        _takedowns = d.pop("takedowns", UNSET)
+        takedowns: OverviewTakedowns | Unset
+        if isinstance(_takedowns,  Unset):
+            takedowns = UNSET
+        else:
+            takedowns = OverviewTakedowns.from_dict(_takedowns)
+
+
+
+
+        _assets = d.pop("assets", UNSET)
+        assets: OverviewAssets | Unset
+        if isinstance(_assets,  Unset):
+            assets = UNSET
+        else:
+            assets = OverviewAssets.from_dict(_assets)
+
+
+
+
+        _generated_at = d.pop("generated_at", UNSET)
+        generated_at: datetime.datetime | Unset
+        if isinstance(_generated_at,  Unset):
+            generated_at = UNSET
+        else:
+            generated_at = datetime.datetime.fromisoformat(_generated_at)
+
+
+
+
+        overview = cls(
+            risk_score=risk_score,
+            risk_level=risk_level,
+            incidents=incidents,
+            exposures=exposures,
+            phishing=phishing,
+            takedowns=takedowns,
+            assets=assets,
+            generated_at=generated_at,
+        )
+
+
+        overview.additional_properties = d
+        return overview
+
+    @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/overview_assets.py

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