cyberdesk 0.2.7__py3-none-any.whl → 1.0.0__py3-none-any.whl

openapi_client/cyberdesk_cloud_client/models/__init__.py

@@ -0,0 +1,107 @@
+"""Contains all the data models used in inputs/outputs"""
+
+from .connection_create import ConnectionCreate
+from .connection_response import ConnectionResponse
+from .connection_status import ConnectionStatus
+from .connection_update import ConnectionUpdate
+from .database_health_check_v1_health_db_get_response_database_health_check_v1_health_db_get import (
+    DatabaseHealthCheckV1HealthDbGetResponseDatabaseHealthCheckV1HealthDbGet,
+)
+from .display_dimensions import DisplayDimensions
+from .dummy_test_endpoint_v1_test_post_response_dummy_test_endpoint_v1_test_post import (
+    DummyTestEndpointV1TestPostResponseDummyTestEndpointV1TestPost,
+)
+from .get_workflow_versions_v1_workflows_workflow_id_versions_get_response_200_item import (
+    GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponse200Item,
+)
+from .health_check_v1_health_get_response_health_check_v1_health_get import (
+    HealthCheckV1HealthGetResponseHealthCheckV1HealthGet,
+)
+from .http_validation_error import HTTPValidationError
+from .keyboard_key_request import KeyboardKeyRequest
+from .keyboard_type_request import KeyboardTypeRequest
+from .machine_create import MachineCreate
+from .machine_response import MachineResponse
+from .machine_status import MachineStatus
+from .machine_update import MachineUpdate
+from .mouse_click_request import MouseClickRequest
+from .mouse_move_request import MouseMoveRequest
+from .mouse_position import MousePosition
+from .paginated_response import PaginatedResponse
+from .paginated_response_connection_response import PaginatedResponseConnectionResponse
+from .paginated_response_machine_response import PaginatedResponseMachineResponse
+from .paginated_response_run_response import PaginatedResponseRunResponse
+from .paginated_response_trajectory_response import PaginatedResponseTrajectoryResponse
+from .paginated_response_workflow_response import PaginatedResponseWorkflowResponse
+from .request_log_create import RequestLogCreate
+from .request_log_response import RequestLogResponse
+from .request_log_update import RequestLogUpdate
+from .run_create import RunCreate
+from .run_response import RunResponse
+from .run_response_output_data_type_0 import RunResponseOutputDataType0
+from .run_response_run_message_history_type_0_item import RunResponseRunMessageHistoryType0Item
+from .run_status import RunStatus
+from .run_update import RunUpdate
+from .run_update_output_data_type_0 import RunUpdateOutputDataType0
+from .run_update_run_message_history_type_0_item import RunUpdateRunMessageHistoryType0Item
+from .trajectory_create import TrajectoryCreate
+from .trajectory_create_trajectory_data_item import TrajectoryCreateTrajectoryDataItem
+from .trajectory_response import TrajectoryResponse
+from .trajectory_response_trajectory_data_item import TrajectoryResponseTrajectoryDataItem
+from .trajectory_update import TrajectoryUpdate
+from .trajectory_update_trajectory_data_type_0_item import TrajectoryUpdateTrajectoryDataType0Item
+from .validation_error import ValidationError
+from .workflow_create import WorkflowCreate
+from .workflow_response import WorkflowResponse
+from .workflow_response_old_versions_type_0_item import WorkflowResponseOldVersionsType0Item
+from .workflow_update import WorkflowUpdate
+
+__all__ = (
+    "ConnectionCreate",
+    "ConnectionResponse",
+    "ConnectionStatus",
+    "ConnectionUpdate",
+    "DatabaseHealthCheckV1HealthDbGetResponseDatabaseHealthCheckV1HealthDbGet",
+    "DisplayDimensions",
+    "DummyTestEndpointV1TestPostResponseDummyTestEndpointV1TestPost",
+    "GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponse200Item",
+    "HealthCheckV1HealthGetResponseHealthCheckV1HealthGet",
+    "HTTPValidationError",
+    "KeyboardKeyRequest",
+    "KeyboardTypeRequest",
+    "MachineCreate",
+    "MachineResponse",
+    "MachineStatus",
+    "MachineUpdate",
+    "MouseClickRequest",
+    "MouseMoveRequest",
+    "MousePosition",
+    "PaginatedResponse",
+    "PaginatedResponseConnectionResponse",
+    "PaginatedResponseMachineResponse",
+    "PaginatedResponseRunResponse",
+    "PaginatedResponseTrajectoryResponse",
+    "PaginatedResponseWorkflowResponse",
+    "RequestLogCreate",
+    "RequestLogResponse",
+    "RequestLogUpdate",
+    "RunCreate",
+    "RunResponse",
+    "RunResponseOutputDataType0",
+    "RunResponseRunMessageHistoryType0Item",
+    "RunStatus",
+    "RunUpdate",
+    "RunUpdateOutputDataType0",
+    "RunUpdateRunMessageHistoryType0Item",
+    "TrajectoryCreate",
+    "TrajectoryCreateTrajectoryDataItem",
+    "TrajectoryResponse",
+    "TrajectoryResponseTrajectoryDataItem",
+    "TrajectoryUpdate",
+    "TrajectoryUpdateTrajectoryDataType0Item",
+    "ValidationError",
+    "WorkflowCreate",
+    "WorkflowResponse",
+    "WorkflowResponseOldVersionsType0Item",
+    "WorkflowUpdate",
+)

openapi_client/cyberdesk_cloud_client/models/connection_create.py

@@ -0,0 +1,111 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ConnectionCreate")
+
+
+@_attrs_define
+class ConnectionCreate:
+    """Schema for creating a connection
+
+    Attributes:
+        websocket_id (str):
+        machine_id (UUID):
+        ip_address (Union[None, Unset, str]):
+        user_agent (Union[None, Unset, str]):
+    """
+
+    websocket_id: str
+    machine_id: UUID
+    ip_address: Union[None, Unset, str] = UNSET
+    user_agent: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        websocket_id = self.websocket_id
+
+        machine_id = str(self.machine_id)
+
+        ip_address: Union[None, Unset, str]
+        if isinstance(self.ip_address, Unset):
+            ip_address = UNSET
+        else:
+            ip_address = self.ip_address
+
+        user_agent: Union[None, Unset, str]
+        if isinstance(self.user_agent, Unset):
+            user_agent = UNSET
+        else:
+            user_agent = self.user_agent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "websocket_id": websocket_id,
+                "machine_id": machine_id,
+            }
+        )
+        if ip_address is not UNSET:
+            field_dict["ip_address"] = ip_address
+        if user_agent is not UNSET:
+            field_dict["user_agent"] = user_agent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        websocket_id = d.pop("websocket_id")
+
+        machine_id = UUID(d.pop("machine_id"))
+
+        def _parse_ip_address(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)
+
+        ip_address = _parse_ip_address(d.pop("ip_address", UNSET))
+
+        def _parse_user_agent(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)
+
+        user_agent = _parse_user_agent(d.pop("user_agent", UNSET))
+
+        connection_create = cls(
+            websocket_id=websocket_id,
+            machine_id=machine_id,
+            ip_address=ip_address,
+            user_agent=user_agent,
+        )
+
+        connection_create.additional_properties = d
+        return connection_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/connection_response.py

@@ -0,0 +1,171 @@
+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 ..models.connection_status import ConnectionStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ConnectionResponse")
+
+
+@_attrs_define
+class ConnectionResponse:
+    """Connection response schema
+
+    Attributes:
+        websocket_id (str):
+        id (UUID):
+        machine_id (UUID):
+        connected_at (datetime.datetime):
+        disconnected_at (Union[None, datetime.datetime]):
+        last_ping (datetime.datetime):
+        status (ConnectionStatus):
+        ip_address (Union[None, Unset, str]):
+        user_agent (Union[None, Unset, str]):
+    """
+
+    websocket_id: str
+    id: UUID
+    machine_id: UUID
+    connected_at: datetime.datetime
+    disconnected_at: Union[None, datetime.datetime]
+    last_ping: datetime.datetime
+    status: ConnectionStatus
+    ip_address: Union[None, Unset, str] = UNSET
+    user_agent: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        websocket_id = self.websocket_id
+
+        id = str(self.id)
+
+        machine_id = str(self.machine_id)
+
+        connected_at = self.connected_at.isoformat()
+
+        disconnected_at: Union[None, str]
+        if isinstance(self.disconnected_at, datetime.datetime):
+            disconnected_at = self.disconnected_at.isoformat()
+        else:
+            disconnected_at = self.disconnected_at
+
+        last_ping = self.last_ping.isoformat()
+
+        status = self.status.value
+
+        ip_address: Union[None, Unset, str]
+        if isinstance(self.ip_address, Unset):
+            ip_address = UNSET
+        else:
+            ip_address = self.ip_address
+
+        user_agent: Union[None, Unset, str]
+        if isinstance(self.user_agent, Unset):
+            user_agent = UNSET
+        else:
+            user_agent = self.user_agent
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "websocket_id": websocket_id,
+                "id": id,
+                "machine_id": machine_id,
+                "connected_at": connected_at,
+                "disconnected_at": disconnected_at,
+                "last_ping": last_ping,
+                "status": status,
+            }
+        )
+        if ip_address is not UNSET:
+            field_dict["ip_address"] = ip_address
+        if user_agent is not UNSET:
+            field_dict["user_agent"] = user_agent
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        websocket_id = d.pop("websocket_id")
+
+        id = UUID(d.pop("id"))
+
+        machine_id = UUID(d.pop("machine_id"))
+
+        connected_at = isoparse(d.pop("connected_at"))
+
+        def _parse_disconnected_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                disconnected_at_type_0 = isoparse(data)
+
+                return disconnected_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        disconnected_at = _parse_disconnected_at(d.pop("disconnected_at"))
+
+        last_ping = isoparse(d.pop("last_ping"))
+
+        status = ConnectionStatus(d.pop("status"))
+
+        def _parse_ip_address(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)
+
+        ip_address = _parse_ip_address(d.pop("ip_address", UNSET))
+
+        def _parse_user_agent(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)
+
+        user_agent = _parse_user_agent(d.pop("user_agent", UNSET))
+
+        connection_response = cls(
+            websocket_id=websocket_id,
+            id=id,
+            machine_id=machine_id,
+            connected_at=connected_at,
+            disconnected_at=disconnected_at,
+            last_ping=last_ping,
+            status=status,
+            ip_address=ip_address,
+            user_agent=user_agent,
+        )
+
+        connection_response.additional_properties = d
+        return connection_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/{api_reference_client/models/get_v1_desktop_id_response_404_status.py → cyberdesk_cloud_client/models/connection_status.py}

@@ -1,8 +1,10 @@
-from enum import Enum
-
-
-class GetV1DesktopIdResponse404Status(str, Enum):
-    ERROR = "error"
-
-    def __str__(self) -> str:
-        return str(self.value)
+from enum import Enum
+
+
+class ConnectionStatus(str, Enum):
+    CONNECTED = "connected"
+    DISCONNECTED = "disconnected"
+    ERROR = "error"
+
+    def __str__(self) -> str:
+        return str(self.value)

openapi_client/cyberdesk_cloud_client/models/connection_update.py

@@ -0,0 +1,145 @@
+import datetime
+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 dateutil.parser import isoparse
+
+from ..models.connection_status import ConnectionStatus
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ConnectionUpdate")
+
+
+@_attrs_define
+class ConnectionUpdate:
+    """Schema for updating a connection
+
+    Attributes:
+        status (Union[ConnectionStatus, None, Unset]):
+        last_ping (Union[None, Unset, datetime.datetime]):
+        disconnected_at (Union[None, Unset, datetime.datetime]):
+    """
+
+    status: Union[ConnectionStatus, None, Unset] = UNSET
+    last_ping: Union[None, Unset, datetime.datetime] = UNSET
+    disconnected_at: Union[None, Unset, datetime.datetime] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status: Union[None, Unset, str]
+        if isinstance(self.status, Unset):
+            status = UNSET
+        elif isinstance(self.status, ConnectionStatus):
+            status = self.status.value
+        else:
+            status = self.status
+
+        last_ping: Union[None, Unset, str]
+        if isinstance(self.last_ping, Unset):
+            last_ping = UNSET
+        elif isinstance(self.last_ping, datetime.datetime):
+            last_ping = self.last_ping.isoformat()
+        else:
+            last_ping = self.last_ping
+
+        disconnected_at: Union[None, Unset, str]
+        if isinstance(self.disconnected_at, Unset):
+            disconnected_at = UNSET
+        elif isinstance(self.disconnected_at, datetime.datetime):
+            disconnected_at = self.disconnected_at.isoformat()
+        else:
+            disconnected_at = self.disconnected_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if status is not UNSET:
+            field_dict["status"] = status
+        if last_ping is not UNSET:
+            field_dict["last_ping"] = last_ping
+        if disconnected_at is not UNSET:
+            field_dict["disconnected_at"] = disconnected_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_status(data: object) -> Union[ConnectionStatus, None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                status_type_0 = ConnectionStatus(data)
+
+                return status_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[ConnectionStatus, None, Unset], data)
+
+        status = _parse_status(d.pop("status", UNSET))
+
+        def _parse_last_ping(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_ping_type_0 = isoparse(data)
+
+                return last_ping_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        last_ping = _parse_last_ping(d.pop("last_ping", UNSET))
+
+        def _parse_disconnected_at(data: object) -> Union[None, Unset, datetime.datetime]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                disconnected_at_type_0 = isoparse(data)
+
+                return disconnected_at_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, datetime.datetime], data)
+
+        disconnected_at = _parse_disconnected_at(d.pop("disconnected_at", UNSET))
+
+        connection_update = cls(
+            status=status,
+            last_ping=last_ping,
+            disconnected_at=disconnected_at,
+        )
+
+        connection_update.additional_properties = d
+        return connection_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/database_health_check_v1_health_db_get_response_database_health_check_v1_health_db_get.py

@@ -0,0 +1,44 @@
+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="DatabaseHealthCheckV1HealthDbGetResponseDatabaseHealthCheckV1HealthDbGet")
+
+
+@_attrs_define
+class DatabaseHealthCheckV1HealthDbGetResponseDatabaseHealthCheckV1HealthDbGet:
+    """ """
+
+    additional_properties: dict[str, str] = _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)
+        database_health_check_v1_health_db_get_response_database_health_check_v1_health_db_get = cls()
+
+        database_health_check_v1_health_db_get_response_database_health_check_v1_health_db_get.additional_properties = d
+        return database_health_check_v1_health_db_get_response_database_health_check_v1_health_db_get
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> 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