kalir-python 0.1.0__py3-none-any.whl

kalir/models/report.py

@@ -0,0 +1,182 @@
+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.report_status import ReportStatus
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.report_parameters import ReportParameters
+
+
+
+
+
+T = TypeVar("T", bound="Report")
+
+
+
+@_attrs_define
+class Report:
+    """ 
+        Attributes:
+            id (UUID | Unset):
+            type_ (str | Unset):
+            status (ReportStatus | Unset):
+            created_at (datetime.datetime | Unset):
+            completed_at (datetime.datetime | Unset):
+            parameters (ReportParameters | Unset):
+     """
+
+    id: UUID | Unset = UNSET
+    type_: str | Unset = UNSET
+    status: ReportStatus | Unset = UNSET
+    created_at: datetime.datetime | Unset = UNSET
+    completed_at: datetime.datetime | Unset = UNSET
+    parameters: ReportParameters | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.report_parameters import ReportParameters # noqa: PLC0415
+        id: str | Unset = UNSET
+        if not isinstance(self.id, Unset):
+            id = str(self.id)
+
+        type_ = self.type_
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+
+        created_at: str | Unset = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+        completed_at: str | Unset = UNSET
+        if not isinstance(self.completed_at, Unset):
+            completed_at = self.completed_at.isoformat()
+
+        parameters: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.parameters, Unset):
+            parameters = self.parameters.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 status is not UNSET:
+            field_dict["status"] = status
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if completed_at is not UNSET:
+            field_dict["completed_at"] = completed_at
+        if parameters is not UNSET:
+            field_dict["parameters"] = parameters
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.report_parameters import ReportParameters # noqa: PLC0415
+        d = dict(src_dict)
+        _id = d.pop("id", UNSET)
+        id: UUID | Unset
+        if isinstance(_id,  Unset):
+            id = UNSET
+        else:
+            id = UUID(_id)
+
+
+
+
+        type_ = d.pop("type", UNSET)
+
+        _status = d.pop("status", UNSET)
+        status: ReportStatus | Unset
+        if isinstance(_status,  Unset):
+            status = UNSET
+        else:
+            status = ReportStatus(_status)
+
+
+
+
+        _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)
+
+
+
+
+        _completed_at = d.pop("completed_at", UNSET)
+        completed_at: datetime.datetime | Unset
+        if isinstance(_completed_at,  Unset):
+            completed_at = UNSET
+        else:
+            completed_at = datetime.datetime.fromisoformat(_completed_at)
+
+
+
+
+        _parameters = d.pop("parameters", UNSET)
+        parameters: ReportParameters | Unset
+        if isinstance(_parameters,  Unset):
+            parameters = UNSET
+        else:
+            parameters = ReportParameters.from_dict(_parameters)
+
+
+
+
+        report = cls(
+            id=id,
+            type_=type_,
+            status=status,
+            created_at=created_at,
+            completed_at=completed_at,
+            parameters=parameters,
+        )
+
+
+        report.additional_properties = d
+        return report
+
+    @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/report_parameters.py

@@ -0,0 +1,181 @@
+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.report_parameters_date_range import ReportParametersDateRange
+from ..models.report_parameters_language import ReportParametersLanguage
+from ..models.report_parameters_sections_item import ReportParametersSectionsItem
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="ReportParameters")
+
+
+
+@_attrs_define
+class ReportParameters:
+    """ 
+        Attributes:
+            report_name (str):
+            sections (list[ReportParametersSectionsItem]):
+            date_range (ReportParametersDateRange | Unset):
+            date_from (datetime.datetime | Unset):
+            date_to (datetime.datetime | Unset):
+            language (ReportParametersLanguage | Unset):
+     """
+
+    report_name: str
+    sections: list[ReportParametersSectionsItem]
+    date_range: ReportParametersDateRange | Unset = UNSET
+    date_from: datetime.datetime | Unset = UNSET
+    date_to: datetime.datetime | Unset = UNSET
+    language: ReportParametersLanguage | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        report_name = self.report_name
+
+        sections = []
+        for sections_item_data in self.sections:
+            sections_item = sections_item_data.value
+            sections.append(sections_item)
+
+
+
+        date_range: str | Unset = UNSET
+        if not isinstance(self.date_range, Unset):
+            date_range = self.date_range.value
+
+
+        date_from: str | Unset = UNSET
+        if not isinstance(self.date_from, Unset):
+            date_from = self.date_from.isoformat()
+
+        date_to: str | Unset = UNSET
+        if not isinstance(self.date_to, Unset):
+            date_to = self.date_to.isoformat()
+
+        language: str | Unset = UNSET
+        if not isinstance(self.language, Unset):
+            language = self.language.value
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "report_name": report_name,
+            "sections": sections,
+        })
+        if date_range is not UNSET:
+            field_dict["date_range"] = date_range
+        if date_from is not UNSET:
+            field_dict["date_from"] = date_from
+        if date_to is not UNSET:
+            field_dict["date_to"] = date_to
+        if language is not UNSET:
+            field_dict["language"] = language
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        report_name = d.pop("report_name")
+
+        sections = []
+        _sections = d.pop("sections")
+        for sections_item_data in (_sections):
+            sections_item = ReportParametersSectionsItem(sections_item_data)
+
+
+
+            sections.append(sections_item)
+
+
+        _date_range = d.pop("date_range", UNSET)
+        date_range: ReportParametersDateRange | Unset
+        if isinstance(_date_range,  Unset):
+            date_range = UNSET
+        else:
+            date_range = ReportParametersDateRange(_date_range)
+
+
+
+
+        _date_from = d.pop("date_from", UNSET)
+        date_from: datetime.datetime | Unset
+        if isinstance(_date_from,  Unset):
+            date_from = UNSET
+        else:
+            date_from = datetime.datetime.fromisoformat(_date_from)
+
+
+
+
+        _date_to = d.pop("date_to", UNSET)
+        date_to: datetime.datetime | Unset
+        if isinstance(_date_to,  Unset):
+            date_to = UNSET
+        else:
+            date_to = datetime.datetime.fromisoformat(_date_to)
+
+
+
+
+        _language = d.pop("language", UNSET)
+        language: ReportParametersLanguage | Unset
+        if isinstance(_language,  Unset):
+            language = UNSET
+        else:
+            language = ReportParametersLanguage(_language)
+
+
+
+
+        report_parameters = cls(
+            report_name=report_name,
+            sections=sections,
+            date_range=date_range,
+            date_from=date_from,
+            date_to=date_to,
+            language=language,
+        )
+
+
+        report_parameters.additional_properties = d
+        return report_parameters
+
+    @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/report_parameters_date_range.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+class ReportParametersDateRange(StrEnum):
+    CUSTOM = "custom"
+    VALUE_0 = "24h"
+    VALUE_1 = "7d"
+    VALUE_2 = "30d"
+    VALUE_3 = "90d"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/report_parameters_language.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+class ReportParametersLanguage(StrEnum):
+    EN = "en"
+    ES = "es"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/report_parameters_sections_item.py

@@ -0,0 +1,15 @@
+from enum import StrEnum
+
+class ReportParametersSectionsItem(StrEnum):
+    ASSETS = "assets"
+    ATTACK_SURFACE = "attack_surface"
+    CREDENTIALS = "credentials"
+    DARKWEB = "darkweb"
+    EXECUTIVE_SUMMARY = "executive_summary"
+    INCIDENTS = "incidents"
+    PERSONNEL = "personnel"
+    TAKEDOWNS = "takedowns"
+    TELEGRAM = "telegram"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/report_status.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+class ReportStatus(StrEnum):
+    COMPLETED = "completed"
+    FAILED = "failed"
+    PENDING = "pending"
+    PROCESSING = "processing"
+
+    def __str__(self) -> str:
+        return str(self.value)

kalir/models/rotate_webhook_secret_response_200.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="RotateWebhookSecretResponse200")
+
+
+
+@_attrs_define
+class RotateWebhookSecretResponse200:
+    """ 
+        Attributes:
+            secret (str | Unset):
+            message (str | Unset):
+     """
+
+    secret: str | Unset = UNSET
+    message: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        secret = self.secret
+
+        message = self.message
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if secret is not UNSET:
+            field_dict["secret"] = secret
+        if message is not UNSET:
+            field_dict["message"] = message
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        secret = d.pop("secret", UNSET)
+
+        message = d.pop("message", UNSET)
+
+        rotate_webhook_secret_response_200 = cls(
+            secret=secret,
+            message=message,
+        )
+
+
+        rotate_webhook_secret_response_200.additional_properties = d
+        return rotate_webhook_secret_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/rule.py

@@ -0,0 +1,174 @@
+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
+from uuid import UUID
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.rule_input_actions_item import RuleInputActionsItem
+
+
+
+
+
+T = TypeVar("T", bound="Rule")
+
+
+
+@_attrs_define
+class Rule:
+    """ 
+        Attributes:
+            name (str):
+            condition (str): CEL expression.
+            description (str | Unset):
+            actions (list[RuleInputActionsItem] | Unset):
+            enabled (bool | Unset):  Default: True.
+            rule_id (UUID | Unset):
+            created_at (datetime.datetime | Unset):
+     """
+
+    name: str
+    condition: str
+    description: str | Unset = UNSET
+    actions: list[RuleInputActionsItem] | Unset = UNSET
+    enabled: bool | Unset = True
+    rule_id: UUID | Unset = UNSET
+    created_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.rule_input_actions_item import RuleInputActionsItem # noqa: PLC0415
+        name = self.name
+
+        condition = self.condition
+
+        description = self.description
+
+        actions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.actions, Unset):
+            actions = []
+            for actions_item_data in self.actions:
+                actions_item = actions_item_data.to_dict()
+                actions.append(actions_item)
+
+
+
+        enabled = self.enabled
+
+        rule_id: str | Unset = UNSET
+        if not isinstance(self.rule_id, Unset):
+            rule_id = str(self.rule_id)
+
+        created_at: str | Unset = UNSET
+        if not isinstance(self.created_at, Unset):
+            created_at = self.created_at.isoformat()
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+            "condition": condition,
+        })
+        if description is not UNSET:
+            field_dict["description"] = description
+        if actions is not UNSET:
+            field_dict["actions"] = actions
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
+        if rule_id is not UNSET:
+            field_dict["rule_id"] = rule_id
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.rule_input_actions_item import RuleInputActionsItem # noqa: PLC0415
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        condition = d.pop("condition")
+
+        description = d.pop("description", UNSET)
+
+        _actions = d.pop("actions", UNSET)
+        actions: list[RuleInputActionsItem] | Unset = UNSET
+        if _actions is not UNSET:
+            actions = []
+            for actions_item_data in _actions:
+                actions_item = RuleInputActionsItem.from_dict(actions_item_data)
+
+
+
+                actions.append(actions_item)
+
+
+        enabled = d.pop("enabled", UNSET)
+
+        _rule_id = d.pop("rule_id", UNSET)
+        rule_id: UUID | Unset
+        if isinstance(_rule_id,  Unset):
+            rule_id = UNSET
+        else:
+            rule_id = UUID(_rule_id)
+
+
+
+
+        _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)
+
+
+
+
+        rule = cls(
+            name=name,
+            condition=condition,
+            description=description,
+            actions=actions,
+            enabled=enabled,
+            rule_id=rule_id,
+            created_at=created_at,
+        )
+
+
+        rule.additional_properties = d
+        return rule
+
+    @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