cyberdesk 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

openapi_client/cyberdesk_cloud_client/models/paginated_response_pool_response.py

@@ -0,0 +1,97 @@
+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.pool_response import PoolResponse
+
+
+T = TypeVar("T", bound="PaginatedResponsePoolResponse")
+
+
+@_attrs_define
+class PaginatedResponsePoolResponse:
+    """
+    Attributes:
+        items (list['PoolResponse']):
+        total (int):
+        skip (int):
+        limit (int):
+    """
+
+    items: list["PoolResponse"]
+    total: int
+    skip: int
+    limit: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        items = []
+        for items_item_data in self.items:
+            items_item = items_item_data.to_dict()
+            items.append(items_item)
+
+        total = self.total
+
+        skip = self.skip
+
+        limit = self.limit
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "items": items,
+                "total": total,
+                "skip": skip,
+                "limit": limit,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.pool_response import PoolResponse
+
+        d = dict(src_dict)
+        items = []
+        _items = d.pop("items")
+        for items_item_data in _items:
+            items_item = PoolResponse.from_dict(items_item_data)
+
+            items.append(items_item)
+
+        total = d.pop("total")
+
+        skip = d.pop("skip")
+
+        limit = d.pop("limit")
+
+        paginated_response_pool_response = cls(
+            items=items,
+            total=total,
+            skip=skip,
+            limit=limit,
+        )
+
+        paginated_response_pool_response.additional_properties = d
+        return paginated_response_pool_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

openapi_client/cyberdesk_cloud_client/models/pool_create.py

@@ -0,0 +1,82 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PoolCreate")
+
+
+@_attrs_define
+class PoolCreate:
+    """Schema for creating a pool
+
+    Attributes:
+        name (str):
+        description (Union[None, Unset, str]):
+    """
+
+    name: str
+    description: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        description: Union[None, Unset, str]
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if description is not UNSET:
+            field_dict["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")
+
+        def _parse_description(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        pool_create = cls(
+            name=name,
+            description=description,
+        )
+
+        pool_create.additional_properties = d
+        return pool_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

openapi_client/cyberdesk_cloud_client/models/pool_response.py

@@ -0,0 +1,137 @@
+import datetime
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PoolResponse")
+
+
+@_attrs_define
+class PoolResponse:
+    """Pool response schema
+
+    Attributes:
+        name (str):
+        id (UUID):
+        organization_id (str):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        description (Union[None, Unset, str]):
+        machine_count (Union[None, Unset, int]): Number of machines in this pool Default: 0.
+    """
+
+    name: str
+    id: UUID
+    organization_id: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    description: Union[None, Unset, str] = UNSET
+    machine_count: Union[None, Unset, int] = 0
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        id = str(self.id)
+
+        organization_id = self.organization_id
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        description: Union[None, Unset, str]
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        machine_count: Union[None, Unset, int]
+        if isinstance(self.machine_count, Unset):
+            machine_count = UNSET
+        else:
+            machine_count = self.machine_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "id": id,
+                "organization_id": organization_id,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if machine_count is not UNSET:
+            field_dict["machine_count"] = machine_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        id = UUID(d.pop("id"))
+
+        organization_id = d.pop("organization_id")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        def _parse_description(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        def _parse_machine_count(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        machine_count = _parse_machine_count(d.pop("machine_count", UNSET))
+
+        pool_response = cls(
+            name=name,
+            id=id,
+            organization_id=organization_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            description=description,
+            machine_count=machine_count,
+        )
+
+        pool_response.additional_properties = d
+        return pool_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

openapi_client/cyberdesk_cloud_client/models/pool_update.py

@@ -0,0 +1,92 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PoolUpdate")
+
+
+@_attrs_define
+class PoolUpdate:
+    """Schema for updating a pool
+
+    Attributes:
+        name (Union[None, Unset, str]):
+        description (Union[None, Unset, str]):
+    """
+
+    name: Union[None, Unset, str] = UNSET
+    description: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name: Union[None, Unset, str]
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        description: Union[None, Unset, str]
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if name is not UNSET:
+            field_dict["name"] = name
+        if description is not UNSET:
+            field_dict["description"] = description
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_name(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        name = _parse_name(d.pop("name", UNSET))
+
+        def _parse_description(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        pool_update = cls(
+            name=name,
+            description=description,
+        )
+
+        pool_update.additional_properties = d
+        return pool_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

openapi_client/cyberdesk_cloud_client/models/pool_with_machines.py

@@ -0,0 +1,162 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from uuid import UUID
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.machine_response import MachineResponse
+
+
+T = TypeVar("T", bound="PoolWithMachines")
+
+
+@_attrs_define
+class PoolWithMachines:
+    """Pool response with machines included
+
+    Attributes:
+        name (str):
+        id (UUID):
+        organization_id (str):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        description (Union[None, Unset, str]):
+        machine_count (Union[None, Unset, int]): Number of machines in this pool Default: 0.
+        machines (Union[Unset, list['MachineResponse']]):
+    """
+
+    name: str
+    id: UUID
+    organization_id: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    description: Union[None, Unset, str] = UNSET
+    machine_count: Union[None, Unset, int] = 0
+    machines: Union[Unset, list["MachineResponse"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        id = str(self.id)
+
+        organization_id = self.organization_id
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        description: Union[None, Unset, str]
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        machine_count: Union[None, Unset, int]
+        if isinstance(self.machine_count, Unset):
+            machine_count = UNSET
+        else:
+            machine_count = self.machine_count
+
+        machines: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.machines, Unset):
+            machines = []
+            for machines_item_data in self.machines:
+                machines_item = machines_item_data.to_dict()
+                machines.append(machines_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "id": id,
+                "organization_id": organization_id,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+        if description is not UNSET:
+            field_dict["description"] = description
+        if machine_count is not UNSET:
+            field_dict["machine_count"] = machine_count
+        if machines is not UNSET:
+            field_dict["machines"] = machines
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.machine_response import MachineResponse
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        id = UUID(d.pop("id"))
+
+        organization_id = d.pop("organization_id")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        def _parse_description(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        def _parse_machine_count(data: object) -> Union[None, Unset, int]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, int], data)
+
+        machine_count = _parse_machine_count(d.pop("machine_count", UNSET))
+
+        machines = []
+        _machines = d.pop("machines", UNSET)
+        for machines_item_data in _machines or []:
+            machines_item = MachineResponse.from_dict(machines_item_data)
+
+            machines.append(machines_item)
+
+        pool_with_machines = cls(
+            name=name,
+            id=id,
+            organization_id=organization_id,
+            created_at=created_at,
+            updated_at=updated_at,
+            description=description,
+            machine_count=machine_count,
+            machines=machines,
+        )
+
+        pool_with_machines.additional_properties = d
+        return pool_with_machines
+
+    @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

openapi_client/cyberdesk_cloud_client/models/run_bulk_create.py

@@ -24,6 +24,8 @@ class RunBulkCreate:
         count (int): Number of runs to create (max 1000)
         machine_id (Union[None, UUID, Unset]): Machine ID. If not provided, an available machine will be automatically
             selected.
+        pool_ids (Union[None, Unset, list[UUID]]): Pool IDs to filter available machines. Machine must belong to all of
+            these pools (intersection). Ignored when machine_id is provided.
         input_values (Union['RunBulkCreateInputValuesType0', None, Unset]): Input values for workflow variables
         file_inputs (Union[None, Unset, list['FileInput']]): Files to upload to the machine
     """
@@ -31,6 +33,7 @@ class RunBulkCreate:
     workflow_id: UUID
     count: int
     machine_id: Union[None, UUID, Unset] = UNSET
+    pool_ids: Union[None, Unset, list[UUID]] = UNSET
     input_values: Union["RunBulkCreateInputValuesType0", None, Unset] = UNSET
     file_inputs: Union[None, Unset, list["FileInput"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -50,6 +53,18 @@ class RunBulkCreate:
         else:
             machine_id = self.machine_id
 
+        pool_ids: Union[None, Unset, list[str]]
+        if isinstance(self.pool_ids, Unset):
+            pool_ids = UNSET
+        elif isinstance(self.pool_ids, list):
+            pool_ids = []
+            for pool_ids_type_0_item_data in self.pool_ids:
+                pool_ids_type_0_item = str(pool_ids_type_0_item_data)
+                pool_ids.append(pool_ids_type_0_item)
+
+        else:
+            pool_ids = self.pool_ids
+
         input_values: Union[None, Unset, dict[str, Any]]
         if isinstance(self.input_values, Unset):
             input_values = UNSET
@@ -80,6 +95,8 @@ class RunBulkCreate:
         )
         if machine_id is not UNSET:
             field_dict["machine_id"] = machine_id
+        if pool_ids is not UNSET:
+            field_dict["pool_ids"] = pool_ids
         if input_values is not UNSET:
             field_dict["input_values"] = input_values
         if file_inputs is not UNSET:
@@ -114,6 +131,28 @@ class RunBulkCreate:
 
         machine_id = _parse_machine_id(d.pop("machine_id", UNSET))
 
+        def _parse_pool_ids(data: object) -> Union[None, Unset, list[UUID]]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                pool_ids_type_0 = []
+                _pool_ids_type_0 = data
+                for pool_ids_type_0_item_data in _pool_ids_type_0:
+                    pool_ids_type_0_item = UUID(pool_ids_type_0_item_data)
+
+                    pool_ids_type_0.append(pool_ids_type_0_item)
+
+                return pool_ids_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, list[UUID]], data)
+
+        pool_ids = _parse_pool_ids(d.pop("pool_ids", UNSET))
+
         def _parse_input_values(data: object) -> Union["RunBulkCreateInputValuesType0", None, Unset]:
             if data is None:
                 return data
@@ -157,6 +196,7 @@ class RunBulkCreate:
             workflow_id=workflow_id,
             count=count,
             machine_id=machine_id,
+            pool_ids=pool_ids,
             input_values=input_values,
             file_inputs=file_inputs,
         )