kalir-python 0.1.0__py3-none-any.whl

kalir/models/overview_exposures.py

@@ -0,0 +1,105 @@
+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="OverviewExposures")
+
+
+
+@_attrs_define
+class OverviewExposures:
+    """ 
+        Attributes:
+            credentials (int | Unset):
+            with_password (int | Unset):
+            infostealer (int | Unset): Monitored mailboxes seen on infostealer-infected devices.
+            infostealer_employees (int | Unset): Employees compromised by infostealers across your domains.
+     """
+
+    credentials: int | Unset = UNSET
+    with_password: int | Unset = UNSET
+    infostealer: int | Unset = UNSET
+    infostealer_employees: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        credentials = self.credentials
+
+        with_password = self.with_password
+
+        infostealer = self.infostealer
+
+        infostealer_employees = self.infostealer_employees
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if credentials is not UNSET:
+            field_dict["credentials"] = credentials
+        if with_password is not UNSET:
+            field_dict["with_password"] = with_password
+        if infostealer is not UNSET:
+            field_dict["infostealer"] = infostealer
+        if infostealer_employees is not UNSET:
+            field_dict["infostealer_employees"] = infostealer_employees
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        credentials = d.pop("credentials", UNSET)
+
+        with_password = d.pop("with_password", UNSET)
+
+        infostealer = d.pop("infostealer", UNSET)
+
+        infostealer_employees = d.pop("infostealer_employees", UNSET)
+
+        overview_exposures = cls(
+            credentials=credentials,
+            with_password=with_password,
+            infostealer=infostealer,
+            infostealer_employees=infostealer_employees,
+        )
+
+
+        overview_exposures.additional_properties = d
+        return overview_exposures
+
+    @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_incidents.py

@@ -0,0 +1,114 @@
+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="OverviewIncidents")
+
+
+
+@_attrs_define
+class OverviewIncidents:
+    """ 
+        Attributes:
+            open_total (int | Unset):
+            open_critical (int | Unset):
+            open_high (int | Unset):
+            open_medium (int | Unset):
+            open_low (int | Unset):
+     """
+
+    open_total: int | Unset = UNSET
+    open_critical: int | Unset = UNSET
+    open_high: int | Unset = UNSET
+    open_medium: int | Unset = UNSET
+    open_low: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        open_total = self.open_total
+
+        open_critical = self.open_critical
+
+        open_high = self.open_high
+
+        open_medium = self.open_medium
+
+        open_low = self.open_low
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if open_total is not UNSET:
+            field_dict["open_total"] = open_total
+        if open_critical is not UNSET:
+            field_dict["open_critical"] = open_critical
+        if open_high is not UNSET:
+            field_dict["open_high"] = open_high
+        if open_medium is not UNSET:
+            field_dict["open_medium"] = open_medium
+        if open_low is not UNSET:
+            field_dict["open_low"] = open_low
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        open_total = d.pop("open_total", UNSET)
+
+        open_critical = d.pop("open_critical", UNSET)
+
+        open_high = d.pop("open_high", UNSET)
+
+        open_medium = d.pop("open_medium", UNSET)
+
+        open_low = d.pop("open_low", UNSET)
+
+        overview_incidents = cls(
+            open_total=open_total,
+            open_critical=open_critical,
+            open_high=open_high,
+            open_medium=open_medium,
+            open_low=open_low,
+        )
+
+
+        overview_incidents.additional_properties = d
+        return overview_incidents
+
+    @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_phishing.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="OverviewPhishing")
+
+
+
+@_attrs_define
+class OverviewPhishing:
+    """ 
+        Attributes:
+            active (int | Unset):
+            confirmed (int | Unset):
+     """
+
+    active: int | Unset = UNSET
+    confirmed: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        active = self.active
+
+        confirmed = self.confirmed
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if active is not UNSET:
+            field_dict["active"] = active
+        if confirmed is not UNSET:
+            field_dict["confirmed"] = confirmed
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        active = d.pop("active", UNSET)
+
+        confirmed = d.pop("confirmed", UNSET)
+
+        overview_phishing = cls(
+            active=active,
+            confirmed=confirmed,
+        )
+
+
+        overview_phishing.additional_properties = d
+        return overview_phishing
+
+    @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_risk_level.py

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

kalir/models/overview_takedowns.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="OverviewTakedowns")
+
+
+
+@_attrs_define
+class OverviewTakedowns:
+    """ 
+        Attributes:
+            open_ (int | Unset):
+            resolved (int | Unset):
+     """
+
+    open_: int | Unset = UNSET
+    resolved: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        open_ = self.open_
+
+        resolved = self.resolved
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if open_ is not UNSET:
+            field_dict["open"] = open_
+        if resolved is not UNSET:
+            field_dict["resolved"] = resolved
+
+        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)
+
+        resolved = d.pop("resolved", UNSET)
+
+        overview_takedowns = cls(
+            open_=open_,
+            resolved=resolved,
+        )
+
+
+        overview_takedowns.additional_properties = d
+        return overview_takedowns
+
+    @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/pagination.py

@@ -0,0 +1,105 @@
+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="Pagination")
+
+
+
+@_attrs_define
+class Pagination:
+    """ 
+        Attributes:
+            limit (int | Unset):
+            offset (int | Unset):
+            total (int | Unset):
+            has_more (bool | Unset):
+     """
+
+    limit: int | Unset = UNSET
+    offset: int | Unset = UNSET
+    total: int | Unset = UNSET
+    has_more: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        limit = self.limit
+
+        offset = self.offset
+
+        total = self.total
+
+        has_more = self.has_more
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if offset is not UNSET:
+            field_dict["offset"] = offset
+        if total is not UNSET:
+            field_dict["total"] = total
+        if has_more is not UNSET:
+            field_dict["has_more"] = has_more
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        limit = d.pop("limit", UNSET)
+
+        offset = d.pop("offset", UNSET)
+
+        total = d.pop("total", UNSET)
+
+        has_more = d.pop("has_more", UNSET)
+
+        pagination = cls(
+            limit=limit,
+            offset=offset,
+            total=total,
+            has_more=has_more,
+        )
+
+
+        pagination.additional_properties = d
+        return pagination
+
+    @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/phishing_domain.py

@@ -0,0 +1,186 @@
+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.phishing_domain_verdict import PhishingDomainVerdict
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="PhishingDomain")
+
+
+
+@_attrs_define
+class PhishingDomain:
+    """ 
+        Attributes:
+            id (UUID | Unset):
+            domain (str | Unset):  Example: kalir-login.com.
+            impersonates (str | Unset):  Example: kalir.io.
+            verdict (PhishingDomainVerdict | Unset): Automated verification outcome: `confirmed` phishing, `possible`,
+                `possible_fp` (likely benign), `inactive` (not serving content) or `unverified` (not checked yet).
+            confidence (float | Unset): Verifier confidence 0–1.
+            similarity (float | Unset): Lexical similarity to your domain 0–1.
+            reason (str | Unset):
+            screenshot_url (str | Unset):
+            detected_at (datetime.datetime | Unset):
+     """
+
+    id: UUID | Unset = UNSET
+    domain: str | Unset = UNSET
+    impersonates: str | Unset = UNSET
+    verdict: PhishingDomainVerdict | Unset = UNSET
+    confidence: float | Unset = UNSET
+    similarity: float | Unset = UNSET
+    reason: 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)
+
+        domain = self.domain
+
+        impersonates = self.impersonates
+
+        verdict: str | Unset = UNSET
+        if not isinstance(self.verdict, Unset):
+            verdict = self.verdict.value
+
+
+        confidence = self.confidence
+
+        similarity = self.similarity
+
+        reason = self.reason
+
+        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 domain is not UNSET:
+            field_dict["domain"] = domain
+        if impersonates is not UNSET:
+            field_dict["impersonates"] = impersonates
+        if verdict is not UNSET:
+            field_dict["verdict"] = verdict
+        if confidence is not UNSET:
+            field_dict["confidence"] = confidence
+        if similarity is not UNSET:
+            field_dict["similarity"] = similarity
+        if reason is not UNSET:
+            field_dict["reason"] = reason
+        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)
+
+
+
+
+        domain = d.pop("domain", UNSET)
+
+        impersonates = d.pop("impersonates", UNSET)
+
+        _verdict = d.pop("verdict", UNSET)
+        verdict: PhishingDomainVerdict | Unset
+        if isinstance(_verdict,  Unset):
+            verdict = UNSET
+        else:
+            verdict = PhishingDomainVerdict(_verdict)
+
+
+
+
+        confidence = d.pop("confidence", UNSET)
+
+        similarity = d.pop("similarity", UNSET)
+
+        reason = d.pop("reason", 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)
+
+
+
+
+        phishing_domain = cls(
+            id=id,
+            domain=domain,
+            impersonates=impersonates,
+            verdict=verdict,
+            confidence=confidence,
+            similarity=similarity,
+            reason=reason,
+            screenshot_url=screenshot_url,
+            detected_at=detected_at,
+        )
+
+
+        phishing_domain.additional_properties = d
+        return phishing_domain
+
+    @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/phishing_domain_verdict.py

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