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

aceapi_v2_client/models/list_response_named_description_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.named_description_read import NamedDescriptionRead
+
+
+T = TypeVar("T", bound="ListResponseNamedDescriptionRead")
+
+
+@_attrs_define
+class ListResponseNamedDescriptionRead:
+    """
+    Attributes:
+        data (list[NamedDescriptionRead]):
+    """
+
+    data: list[NamedDescriptionRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.named_description_read import NamedDescriptionRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = NamedDescriptionRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_named_description_read = cls(
+            data=data,
+        )
+
+        list_response_named_description_read.additional_properties = d
+        return list_response_named_description_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/list_response_node_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.node_read import NodeRead
+
+
+T = TypeVar("T", bound="ListResponseNodeRead")
+
+
+@_attrs_define
+class ListResponseNodeRead:
+    """
+    Attributes:
+        data (list[NodeRead]):
+    """
+
+    data: list[NodeRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.node_read import NodeRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = NodeRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_node_read = cls(
+            data=data,
+        )
+
+        list_response_node_read.additional_properties = d
+        return list_response_node_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/list_response_observable_comment_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.observable_comment_read import ObservableCommentRead
+
+
+T = TypeVar("T", bound="ListResponseObservableCommentRead")
+
+
+@_attrs_define
+class ListResponseObservableCommentRead:
+    """
+    Attributes:
+        data (list[ObservableCommentRead]):
+    """
+
+    data: list[ObservableCommentRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.observable_comment_read import ObservableCommentRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = ObservableCommentRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_observable_comment_read = cls(
+            data=data,
+        )
+
+        list_response_observable_comment_read.additional_properties = d
+        return list_response_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/list_response_observable_type_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.observable_type_read import ObservableTypeRead
+
+
+T = TypeVar("T", bound="ListResponseObservableTypeRead")
+
+
+@_attrs_define
+class ListResponseObservableTypeRead:
+    """
+    Attributes:
+        data (list[ObservableTypeRead]):
+    """
+
+    data: list[ObservableTypeRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.observable_type_read import ObservableTypeRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = ObservableTypeRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_observable_type_read = cls(
+            data=data,
+        )
+
+        list_response_observable_type_read.additional_properties = d
+        return list_response_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/list_response_threat_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.threat_read import ThreatRead
+
+
+T = TypeVar("T", bound="ListResponseThreatRead")
+
+
+@_attrs_define
+class ListResponseThreatRead:
+    """
+    Attributes:
+        data (list[ThreatRead]):
+    """
+
+    data: list[ThreatRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.threat_read import ThreatRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = ThreatRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_threat_read = cls(
+            data=data,
+        )
+
+        list_response_threat_read.additional_properties = d
+        return list_response_threat_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/list_response_threat_type_read.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.threat_type_read import ThreatTypeRead
+
+
+T = TypeVar("T", bound="ListResponseThreatTypeRead")
+
+
+@_attrs_define
+class ListResponseThreatTypeRead:
+    """
+    Attributes:
+        data (list[ThreatTypeRead]):
+    """
+
+    data: list[ThreatTypeRead]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.threat_type_read import ThreatTypeRead
+
+        d = dict(src_dict)
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = ThreatTypeRead.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        list_response_threat_type_read = cls(
+            data=data,
+        )
+
+        list_response_threat_type_read.additional_properties = d
+        return list_response_threat_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/named_description_read.py

@@ -0,0 +1,69 @@
+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="NamedDescriptionRead")
+
+
+@_attrs_define
+class NamedDescriptionRead:
+    """
+    Attributes:
+        name (str):
+        description (str):
+    """
+
+    name: str
+    description: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "description": description,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        description = d.pop("description")
+
+        named_description_read = cls(
+            name=name,
+            description=description,
+        )
+
+        named_description_read.additional_properties = d
+        return named_description_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/node_read.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.collector_status_read import CollectorStatusRead
+
+
+T = TypeVar("T", bound="NodeRead")
+
+
+@_attrs_define
+class NodeRead:
+    """
+    Attributes:
+        id (int):
+        name (str):
+        location (str):
+        company_id (int):
+        status (str):
+        last_update (datetime.datetime):
+        is_primary (bool):
+        any_mode (bool):
+        workload_count (int):
+        delayed_analysis_count (int):
+        collectors (list[CollectorStatusRead] | Unset):
+    """
+
+    id: int
+    name: str
+    location: str
+    company_id: int
+    status: str
+    last_update: datetime.datetime
+    is_primary: bool
+    any_mode: bool
+    workload_count: int
+    delayed_analysis_count: int
+    collectors: list[CollectorStatusRead] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        location = self.location
+
+        company_id = self.company_id
+
+        status = self.status
+
+        last_update = self.last_update.isoformat()
+
+        is_primary = self.is_primary
+
+        any_mode = self.any_mode
+
+        workload_count = self.workload_count
+
+        delayed_analysis_count = self.delayed_analysis_count
+
+        collectors: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.collectors, Unset):
+            collectors = []
+            for collectors_item_data in self.collectors:
+                collectors_item = collectors_item_data.to_dict()
+                collectors.append(collectors_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "name": name,
+                "location": location,
+                "company_id": company_id,
+                "status": status,
+                "last_update": last_update,
+                "is_primary": is_primary,
+                "any_mode": any_mode,
+                "workload_count": workload_count,
+                "delayed_analysis_count": delayed_analysis_count,
+            }
+        )
+        if collectors is not UNSET:
+            field_dict["collectors"] = collectors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.collector_status_read import CollectorStatusRead
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        location = d.pop("location")
+
+        company_id = d.pop("company_id")
+
+        status = d.pop("status")
+
+        last_update = datetime.datetime.fromisoformat(d.pop("last_update"))
+
+        is_primary = d.pop("is_primary")
+
+        any_mode = d.pop("any_mode")
+
+        workload_count = d.pop("workload_count")
+
+        delayed_analysis_count = d.pop("delayed_analysis_count")
+
+        _collectors = d.pop("collectors", UNSET)
+        collectors: list[CollectorStatusRead] | Unset = UNSET
+        if _collectors is not UNSET:
+            collectors = []
+            for collectors_item_data in _collectors:
+                collectors_item = CollectorStatusRead.from_dict(collectors_item_data)
+
+                collectors.append(collectors_item)
+
+        node_read = cls(
+            id=id,
+            name=name,
+            location=location,
+            company_id=company_id,
+            status=status,
+            last_update=last_update,
+            is_primary=is_primary,
+            any_mode=any_mode,
+            workload_count=workload_count,
+            delayed_analysis_count=delayed_analysis_count,
+            collectors=collectors,
+        )
+
+        node_read.additional_properties = d
+        return node_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