aceapi-v2-client 2.0.0__py3-none-any.whl

aceapi_v2_client/models/observable_comment_create.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ObservableCommentCreate")
+
+
+@_attrs_define
+class ObservableCommentCreate:
+    """
+    Attributes:
+        observable_type (str):
+        observable_value (str):
+        comment (str):
+    """
+
+    observable_type: str
+    observable_value: str
+    comment: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        observable_type = self.observable_type
+
+        observable_value = self.observable_value
+
+        comment = self.comment
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "observable_type": observable_type,
+                "observable_value": observable_value,
+                "comment": comment,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        observable_type = d.pop("observable_type")
+
+        observable_value = d.pop("observable_value")
+
+        comment = d.pop("comment")
+
+        observable_comment_create = cls(
+            observable_type=observable_type,
+            observable_value=observable_value,
+            comment=comment,
+        )
+
+        observable_comment_create.additional_properties = d
+        return observable_comment_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

aceapi_v2_client/models/observable_comment_read.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ObservableCommentRead")
+
+
+@_attrs_define
+class ObservableCommentRead:
+    """
+    Attributes:
+        id (int):
+        insert_date (datetime.datetime):
+        user_id (int):
+        user_display_name (str):
+        observable_id (int):
+        comment (str):
+    """
+
+    id: int
+    insert_date: datetime.datetime
+    user_id: int
+    user_display_name: str
+    observable_id: int
+    comment: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        insert_date = self.insert_date.isoformat()
+
+        user_id = self.user_id
+
+        user_display_name = self.user_display_name
+
+        observable_id = self.observable_id
+
+        comment = self.comment
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "insert_date": insert_date,
+                "user_id": user_id,
+                "user_display_name": user_display_name,
+                "observable_id": observable_id,
+                "comment": comment,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        insert_date = datetime.datetime.fromisoformat(d.pop("insert_date"))
+
+        user_id = d.pop("user_id")
+
+        user_display_name = d.pop("user_display_name")
+
+        observable_id = d.pop("observable_id")
+
+        comment = d.pop("comment")
+
+        observable_comment_read = cls(
+            id=id,
+            insert_date=insert_date,
+            user_id=user_id,
+            user_display_name=user_display_name,
+            observable_id=observable_id,
+            comment=comment,
+        )
+
+        observable_comment_read.additional_properties = d
+        return observable_comment_read
+
+    @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

aceapi_v2_client/models/observable_comment_update.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ObservableCommentUpdate")
+
+
+@_attrs_define
+class ObservableCommentUpdate:
+    """
+    Attributes:
+        comment (str):
+    """
+
+    comment: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        comment = self.comment
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "comment": comment,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        comment = d.pop("comment")
+
+        observable_comment_update = cls(
+            comment=comment,
+        )
+
+        observable_comment_update.additional_properties = d
+        return observable_comment_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

aceapi_v2_client/models/observable_type_read.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ObservableTypeRead")
+
+
+@_attrs_define
+class ObservableTypeRead:
+    """Response model for reading an observable type.
+
+    Attributes:
+        name (str):
+    """
+
+    name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        observable_type_read = cls(
+            name=name,
+        )
+
+        observable_type_read.additional_properties = d
+        return observable_type_read
+
+    @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

aceapi_v2_client/models/ping_response.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PingResponse")
+
+
+@_attrs_define
+class PingResponse:
+    """
+    Attributes:
+        result (str):
+    """
+
+    result: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        result = self.result
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "result": result,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        result = d.pop("result")
+
+        ping_response = cls(
+            result=result,
+        )
+
+        ping_response.additional_properties = d
+        return ping_response
+
+    @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

aceapi_v2_client/models/refresh_request.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="RefreshRequest")
+
+
+@_attrs_define
+class RefreshRequest:
+    """Request model for token refresh endpoint.
+
+    Attributes:
+        refresh_token (str):
+    """
+
+    refresh_token: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        refresh_token = self.refresh_token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "refresh_token": refresh_token,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        refresh_token = d.pop("refresh_token")
+
+        refresh_request = cls(
+            refresh_token=refresh_token,
+        )
+
+        refresh_request.additional_properties = d
+        return refresh_request
+
+    @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

aceapi_v2_client/models/set_interesting_observables_interesting_patch_response_set_interesting_observables_interesting_patch.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar(
+    "T",
+    bound="SetInterestingObservablesInterestingPatchResponseSetInterestingObservablesInterestingPatch",
+)
+
+
+@_attrs_define
+class SetInterestingObservablesInterestingPatchResponseSetInterestingObservablesInterestingPatch:
+    """ """
+
+    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)
+        set_interesting_observables_interesting_patch_response_set_interesting_observables_interesting_patch = cls()
+
+        set_interesting_observables_interesting_patch_response_set_interesting_observables_interesting_patch.additional_properties = d
+        return set_interesting_observables_interesting_patch_response_set_interesting_observables_interesting_patch
+
+    @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

aceapi_v2_client/models/set_interesting_request.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SetInterestingRequest")
+
+
+@_attrs_define
+class SetInterestingRequest:
+    """
+    Attributes:
+        observable_type (str):
+        observable_value (str):
+        is_interesting (bool):
+    """
+
+    observable_type: str
+    observable_value: str
+    is_interesting: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        observable_type = self.observable_type
+
+        observable_value = self.observable_value
+
+        is_interesting = self.is_interesting
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "observable_type": observable_type,
+                "observable_value": observable_value,
+                "is_interesting": is_interesting,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        observable_type = d.pop("observable_type")
+
+        observable_value = d.pop("observable_value")
+
+        is_interesting = d.pop("is_interesting")
+
+        set_interesting_request = cls(
+            observable_type=observable_type,
+            observable_value=observable_value,
+            is_interesting=is_interesting,
+        )
+
+        set_interesting_request.additional_properties = d
+        return set_interesting_request
+
+    @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

aceapi_v2_client/models/status_update.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="StatusUpdate")
+
+
+@_attrs_define
+class StatusUpdate:
+    """Body for updating an event's status.
+
+    Attributes:
+        status (str):
+    """
+
+    status: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = d.pop("status")
+
+        status_update = cls(
+            status=status,
+        )
+
+        status_update.additional_properties = d
+        return status_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

aceapi_v2_client/models/supported_api_version_response.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SupportedApiVersionResponse")
+
+
+@_attrs_define
+class SupportedApiVersionResponse:
+    """
+    Attributes:
+        result (int):
+    """
+
+    result: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        result = self.result
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "result": result,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        result = d.pop("result")
+
+        supported_api_version_response = cls(
+            result=result,
+        )
+
+        supported_api_version_response.additional_properties = d
+        return supported_api_version_response
+
+    @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