kalir-python 0.1.0__py3-none-any.whl

kalir/models/rule_input.py

@@ -0,0 +1,134 @@
+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.rule_input_actions_item import RuleInputActionsItem
+
+
+
+
+
+T = TypeVar("T", bound="RuleInput")
+
+
+
+@_attrs_define
+class RuleInput:
+    """ 
+        Attributes:
+            name (str):
+            condition (str): CEL expression.
+            description (str | Unset):
+            actions (list[RuleInputActionsItem] | Unset):
+            enabled (bool | Unset):  Default: True.
+     """
+
+    name: str
+    condition: str
+    description: str | Unset = UNSET
+    actions: list[RuleInputActionsItem] | Unset = UNSET
+    enabled: bool | Unset = True
+    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
+
+
+        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
+
+        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_input = cls(
+            name=name,
+            condition=condition,
+            description=description,
+            actions=actions,
+            enabled=enabled,
+        )
+
+
+        rule_input.additional_properties = d
+        return rule_input
+
+    @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_input_actions_item.py

@@ -0,0 +1,64 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="RuleInputActionsItem")
+
+
+
+@_attrs_define
+class RuleInputActionsItem:
+    
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        rule_input_actions_item = cls(
+        )
+
+
+        rule_input_actions_item.additional_properties = d
+        return rule_input_actions_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/takedown.py

@@ -0,0 +1,163 @@
+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
+
+
+
+
+
+
+T = TypeVar("T", bound="Takedown")
+
+
+
+@_attrs_define
+class Takedown:
+    """ 
+        Attributes:
+            takedown_type (str):
+            target_domain (str | Unset):
+            target_url (str | Unset):
+            priority (str | Unset):
+            notes (str | Unset):
+            takedown_id (UUID | Unset):
+            status (str | Unset):
+            created_at (datetime.datetime | Unset):
+     """
+
+    takedown_type: str
+    target_domain: str | Unset = UNSET
+    target_url: str | Unset = UNSET
+    priority: str | Unset = UNSET
+    notes: str | Unset = UNSET
+    takedown_id: UUID | Unset = UNSET
+    status: str | 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]:
+        takedown_type = self.takedown_type
+
+        target_domain = self.target_domain
+
+        target_url = self.target_url
+
+        priority = self.priority
+
+        notes = self.notes
+
+        takedown_id: str | Unset = UNSET
+        if not isinstance(self.takedown_id, Unset):
+            takedown_id = str(self.takedown_id)
+
+        status = self.status
+
+        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({
+            "takedown_type": takedown_type,
+        })
+        if target_domain is not UNSET:
+            field_dict["target_domain"] = target_domain
+        if target_url is not UNSET:
+            field_dict["target_url"] = target_url
+        if priority is not UNSET:
+            field_dict["priority"] = priority
+        if notes is not UNSET:
+            field_dict["notes"] = notes
+        if takedown_id is not UNSET:
+            field_dict["takedown_id"] = takedown_id
+        if status is not UNSET:
+            field_dict["status"] = status
+        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:
+        d = dict(src_dict)
+        takedown_type = d.pop("takedown_type")
+
+        target_domain = d.pop("target_domain", UNSET)
+
+        target_url = d.pop("target_url", UNSET)
+
+        priority = d.pop("priority", UNSET)
+
+        notes = d.pop("notes", UNSET)
+
+        _takedown_id = d.pop("takedown_id", UNSET)
+        takedown_id: UUID | Unset
+        if isinstance(_takedown_id,  Unset):
+            takedown_id = UNSET
+        else:
+            takedown_id = UUID(_takedown_id)
+
+
+
+
+        status = d.pop("status", 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)
+
+
+
+
+        takedown = cls(
+            takedown_type=takedown_type,
+            target_domain=target_domain,
+            target_url=target_url,
+            priority=priority,
+            notes=notes,
+            takedown_id=takedown_id,
+            status=status,
+            created_at=created_at,
+        )
+
+
+        takedown.additional_properties = d
+        return takedown
+
+    @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/takedown_create.py

@@ -0,0 +1,113 @@
+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="TakedownCreate")
+
+
+
+@_attrs_define
+class TakedownCreate:
+    """ 
+        Attributes:
+            takedown_type (str):
+            target_domain (str | Unset):
+            target_url (str | Unset):
+            priority (str | Unset):
+            notes (str | Unset):
+     """
+
+    takedown_type: str
+    target_domain: str | Unset = UNSET
+    target_url: str | Unset = UNSET
+    priority: str | Unset = UNSET
+    notes: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        takedown_type = self.takedown_type
+
+        target_domain = self.target_domain
+
+        target_url = self.target_url
+
+        priority = self.priority
+
+        notes = self.notes
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "takedown_type": takedown_type,
+        })
+        if target_domain is not UNSET:
+            field_dict["target_domain"] = target_domain
+        if target_url is not UNSET:
+            field_dict["target_url"] = target_url
+        if priority is not UNSET:
+            field_dict["priority"] = priority
+        if notes is not UNSET:
+            field_dict["notes"] = notes
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        takedown_type = d.pop("takedown_type")
+
+        target_domain = d.pop("target_domain", UNSET)
+
+        target_url = d.pop("target_url", UNSET)
+
+        priority = d.pop("priority", UNSET)
+
+        notes = d.pop("notes", UNSET)
+
+        takedown_create = cls(
+            takedown_type=takedown_type,
+            target_domain=target_domain,
+            target_url=target_url,
+            priority=priority,
+            notes=notes,
+        )
+
+
+        takedown_create.additional_properties = d
+        return takedown_create
+
+    @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/takedown_update.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="TakedownUpdate")
+
+
+
+@_attrs_define
+class TakedownUpdate:
+    """ 
+        Attributes:
+            status (str | Unset):
+            priority (str | Unset):
+            notes (str | Unset):
+     """
+
+    status: str | Unset = UNSET
+    priority: str | Unset = UNSET
+    notes: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status
+
+        priority = self.priority
+
+        notes = self.notes
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if status is not UNSET:
+            field_dict["status"] = status
+        if priority is not UNSET:
+            field_dict["priority"] = priority
+        if notes is not UNSET:
+            field_dict["notes"] = notes
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = d.pop("status", UNSET)
+
+        priority = d.pop("priority", UNSET)
+
+        notes = d.pop("notes", UNSET)
+
+        takedown_update = cls(
+            status=status,
+            priority=priority,
+            notes=notes,
+        )
+
+
+        takedown_update.additional_properties = d
+        return takedown_update
+
+    @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/update_incident_status_body.py

@@ -0,0 +1,90 @@
+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.update_incident_status_body_status import UpdateIncidentStatusBodyStatus
+from ..types import UNSET, Unset
+
+
+
+
+
+
+T = TypeVar("T", bound="UpdateIncidentStatusBody")
+
+
+
+@_attrs_define
+class UpdateIncidentStatusBody:
+    """ 
+        Attributes:
+            status (UpdateIncidentStatusBodyStatus):
+            note (str | Unset): Optional human-readable note attached to the status change.
+     """
+
+    status: UpdateIncidentStatusBodyStatus
+    note: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        note = self.note
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "status": status,
+        })
+        if note is not UNSET:
+            field_dict["note"] = note
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = UpdateIncidentStatusBodyStatus(d.pop("status"))
+
+
+
+
+        note = d.pop("note", UNSET)
+
+        update_incident_status_body = cls(
+            status=status,
+            note=note,
+        )
+
+
+        update_incident_status_body.additional_properties = d
+        return update_incident_status_body
+
+    @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/update_incident_status_body_status.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+class UpdateIncidentStatusBodyStatus(StrEnum):
+    ACKNOWLEDGED = "acknowledged"
+    CLOSED = "closed"
+    MITIGATED = "mitigated"
+    OPEN = "open"
+
+    def __str__(self) -> str:
+        return str(self.value)