cyberdesk 1.10.0__tar.gz → 1.11.0__tar.gz

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyberdesk
-Version: 1.10.0
+Version: 1.11.0
 Summary: The official Python SDK for Cyberdesk
 Author-email: Cyberdesk Team <dev@cyberdesk.io>
 License-Expression: MIT

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/cyberdesk/__init__.py

@@ -27,7 +27,7 @@ from .client import (
     AttachmentType,
 )
 
-__version__ = "1.10.0"
+__version__ = "1.11.0"
 
 __all__ = [
     "CyberdeskClient",

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/cyberdesk/client.py

@@ -28,6 +28,7 @@ from openapi_client.cyberdesk_cloud_client.api.runs import (
     get_run_v1_runs_run_id_get,
     update_run_v1_runs_run_id_patch,
     delete_run_v1_runs_run_id_delete,
+    bulk_create_runs_v1_runs_bulk_post,
 )
 from openapi_client.cyberdesk_cloud_client.api.connections import (
     list_connections_v1_connections_get,
@@ -64,6 +65,8 @@ from openapi_client.cyberdesk_cloud_client.models import (
     RunUpdate,
     RunResponse,
     RunStatus,
+    RunBulkCreate,
+    RunBulkCreateResponse,
     FileInput,
     ConnectionCreate,
     ConnectionResponse,
@@ -98,6 +101,8 @@ __all__ = [
     "RunUpdate",
     "RunResponse",
     "RunStatus",
+    "RunBulkCreate",
+    "RunBulkCreateResponse",
     "FileInput",
     "ConnectionCreate",
     "ConnectionResponse",
@@ -527,6 +532,60 @@ class RunsAPI:
             return ApiResponse(data={"success": True})
         except Exception as e:
             return ApiResponse(error=e)
+    
+    async def bulk_create(self, data: RunBulkCreate) -> ApiResponse:
+        """Create multiple runs with the same configuration.
+        
+        This method efficiently creates multiple runs:
+        - All runs are created in a single database transaction
+        - Temporal workflows are started asynchronously 
+        - Returns immediately with created run details
+        
+        Args:
+            data: RunBulkCreate object containing workflow_id, machine_id, 
+                  input_values, file_inputs, and count (max 1000)
+        
+        Returns:
+            ApiResponse with RunBulkCreateResponse containing:
+                - created_runs: List of created RunResponse objects
+                - failed_count: Number of runs that failed to create
+                - errors: List of error messages for failed runs
+        """
+        try:
+            response = await bulk_create_runs_v1_runs_bulk_post.asyncio(
+                client=self.client,
+                body=data
+            )
+            return ApiResponse(data=response)
+        except Exception as e:
+            return ApiResponse(error=e)
+    
+    def bulk_create_sync(self, data: RunBulkCreate) -> ApiResponse:
+        """Create multiple runs with the same configuration (synchronous).
+        
+        This method efficiently creates multiple runs:
+        - All runs are created in a single database transaction
+        - Temporal workflows are started asynchronously 
+        - Returns immediately with created run details
+        
+        Args:
+            data: RunBulkCreate object containing workflow_id, machine_id, 
+                  input_values, file_inputs, and count (max 1000)
+        
+        Returns:
+            ApiResponse with RunBulkCreateResponse containing:
+                - created_runs: List of created RunResponse objects
+                - failed_count: Number of runs that failed to create
+                - errors: List of error messages for failed runs
+        """
+        try:
+            response = bulk_create_runs_v1_runs_bulk_post.sync(
+                client=self.client,
+                body=data
+            )
+            return ApiResponse(data=response)
+        except Exception as e:
+            return ApiResponse(error=e)
 
 
 class ConnectionsAPI:

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/cyberdesk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cyberdesk
-Version: 1.10.0
+Version: 1.11.0
 Summary: The official Python SDK for Cyberdesk
 Author-email: Cyberdesk Team <dev@cyberdesk.io>
 License-Expression: MIT

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/cyberdesk.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ openapi_client/cyberdesk_cloud_client/api/run_attachments/get_run_attachment_v1_
 openapi_client/cyberdesk_cloud_client/api/run_attachments/list_run_attachments_v1_run_attachments_get.py
 openapi_client/cyberdesk_cloud_client/api/run_attachments/update_run_attachment_v1_run_attachments_attachment_id_put.py
 openapi_client/cyberdesk_cloud_client/api/runs/__init__.py
+openapi_client/cyberdesk_cloud_client/api/runs/bulk_create_runs_v1_runs_bulk_post.py
 openapi_client/cyberdesk_cloud_client/api/runs/create_run_v1_runs_post.py
 openapi_client/cyberdesk_cloud_client/api/runs/delete_run_v1_runs_run_id_delete.py
 openapi_client/cyberdesk_cloud_client/api/runs/get_run_v1_runs_run_id_get.py
@@ -123,6 +124,9 @@ openapi_client/cyberdesk_cloud_client/models/run_attachment_create.py
 openapi_client/cyberdesk_cloud_client/models/run_attachment_download_url_response.py
 openapi_client/cyberdesk_cloud_client/models/run_attachment_response.py
 openapi_client/cyberdesk_cloud_client/models/run_attachment_update.py
+openapi_client/cyberdesk_cloud_client/models/run_bulk_create.py
+openapi_client/cyberdesk_cloud_client/models/run_bulk_create_input_values_type_0.py
+openapi_client/cyberdesk_cloud_client/models/run_bulk_create_response.py
 openapi_client/cyberdesk_cloud_client/models/run_create.py
 openapi_client/cyberdesk_cloud_client/models/run_create_input_values_type_0.py
 openapi_client/cyberdesk_cloud_client/models/run_response.py

cyberdesk-1.11.0/openapi_client/cyberdesk_cloud_client/api/runs/bulk_create_runs_v1_runs_bulk_post.py

@@ -0,0 +1,200 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.http_validation_error import HTTPValidationError
+from ...models.run_bulk_create import RunBulkCreate
+from ...models.run_bulk_create_response import RunBulkCreateResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    body: RunBulkCreate,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": "/v1/runs/bulk",
+    }
+
+    _kwargs["json"] = body.to_dict()
+
+    headers["Content-Type"] = "application/json"
+
+    _kwargs["headers"] = headers
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    if response.status_code == 201:
+        response_201 = RunBulkCreateResponse.from_dict(response.json())
+
+        return response_201
+    if response.status_code == 422:
+        response_422 = HTTPValidationError.from_dict(response.json())
+
+        return response_422
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: RunBulkCreate,
+) -> Response[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    """Bulk Create Runs
+
+     Create multiple runs with the same configuration.
+
+    This endpoint creates multiple runs efficiently:
+    - All runs are created in a single database transaction
+    - Temporal workflows are started asynchronously
+    - Returns immediately with created run details
+
+    Maximum 1000 runs can be created in a single request.
+
+    Args:
+        body (RunBulkCreate): Schema for bulk creating runs
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, RunBulkCreateResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: AuthenticatedClient,
+    body: RunBulkCreate,
+) -> Optional[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    """Bulk Create Runs
+
+     Create multiple runs with the same configuration.
+
+    This endpoint creates multiple runs efficiently:
+    - All runs are created in a single database transaction
+    - Temporal workflows are started asynchronously
+    - Returns immediately with created run details
+
+    Maximum 1000 runs can be created in a single request.
+
+    Args:
+        body (RunBulkCreate): Schema for bulk creating runs
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, RunBulkCreateResponse]
+    """
+
+    return sync_detailed(
+        client=client,
+        body=body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: AuthenticatedClient,
+    body: RunBulkCreate,
+) -> Response[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    """Bulk Create Runs
+
+     Create multiple runs with the same configuration.
+
+    This endpoint creates multiple runs efficiently:
+    - All runs are created in a single database transaction
+    - Temporal workflows are started asynchronously
+    - Returns immediately with created run details
+
+    Maximum 1000 runs can be created in a single request.
+
+    Args:
+        body (RunBulkCreate): Schema for bulk creating runs
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Union[HTTPValidationError, RunBulkCreateResponse]]
+    """
+
+    kwargs = _get_kwargs(
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: AuthenticatedClient,
+    body: RunBulkCreate,
+) -> Optional[Union[HTTPValidationError, RunBulkCreateResponse]]:
+    """Bulk Create Runs
+
+     Create multiple runs with the same configuration.
+
+    This endpoint creates multiple runs efficiently:
+    - All runs are created in a single database transaction
+    - Temporal workflows are started asynchronously
+    - Returns immediately with created run details
+
+    Maximum 1000 runs can be created in a single request.
+
+    Args:
+        body (RunBulkCreate): Schema for bulk creating runs
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Union[HTTPValidationError, RunBulkCreateResponse]
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            body=body,
+        )
+    ).parsed

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/openapi_client/cyberdesk_cloud_client/models/__init__.py

@@ -60,6 +60,9 @@ from .run_attachment_create import RunAttachmentCreate
 from .run_attachment_download_url_response import RunAttachmentDownloadUrlResponse
 from .run_attachment_response import RunAttachmentResponse
 from .run_attachment_update import RunAttachmentUpdate
+from .run_bulk_create import RunBulkCreate
+from .run_bulk_create_input_values_type_0 import RunBulkCreateInputValuesType0
+from .run_bulk_create_response import RunBulkCreateResponse
 from .run_create import RunCreate
 from .run_create_input_values_type_0 import RunCreateInputValuesType0
 from .run_response import RunResponse
@@ -130,6 +133,9 @@ __all__ = (
     "RunAttachmentDownloadUrlResponse",
     "RunAttachmentResponse",
     "RunAttachmentUpdate",
+    "RunBulkCreate",
+    "RunBulkCreateInputValuesType0",
+    "RunBulkCreateResponse",
     "RunCreate",
     "RunCreateInputValuesType0",
     "RunResponse",

cyberdesk-1.11.0/openapi_client/cyberdesk_cloud_client/models/run_bulk_create.py

@@ -0,0 +1,181 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.file_input import FileInput
+    from ..models.run_bulk_create_input_values_type_0 import RunBulkCreateInputValuesType0
+
+
+T = TypeVar("T", bound="RunBulkCreate")
+
+
+@_attrs_define
+class RunBulkCreate:
+    """Schema for bulk creating runs
+
+    Attributes:
+        workflow_id (UUID):
+        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.
+        input_values (Union['RunBulkCreateInputValuesType0', None, Unset]): Input values for workflow variables
+        file_inputs (Union[None, Unset, list['FileInput']]): Files to upload to the machine
+    """
+
+    workflow_id: UUID
+    count: int
+    machine_id: Union[None, UUID, Unset] = 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)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.run_bulk_create_input_values_type_0 import RunBulkCreateInputValuesType0
+
+        workflow_id = str(self.workflow_id)
+
+        count = self.count
+
+        machine_id: Union[None, Unset, str]
+        if isinstance(self.machine_id, Unset):
+            machine_id = UNSET
+        elif isinstance(self.machine_id, UUID):
+            machine_id = str(self.machine_id)
+        else:
+            machine_id = self.machine_id
+
+        input_values: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.input_values, Unset):
+            input_values = UNSET
+        elif isinstance(self.input_values, RunBulkCreateInputValuesType0):
+            input_values = self.input_values.to_dict()
+        else:
+            input_values = self.input_values
+
+        file_inputs: Union[None, Unset, list[dict[str, Any]]]
+        if isinstance(self.file_inputs, Unset):
+            file_inputs = UNSET
+        elif isinstance(self.file_inputs, list):
+            file_inputs = []
+            for file_inputs_type_0_item_data in self.file_inputs:
+                file_inputs_type_0_item = file_inputs_type_0_item_data.to_dict()
+                file_inputs.append(file_inputs_type_0_item)
+
+        else:
+            file_inputs = self.file_inputs
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "workflow_id": workflow_id,
+                "count": count,
+            }
+        )
+        if machine_id is not UNSET:
+            field_dict["machine_id"] = machine_id
+        if input_values is not UNSET:
+            field_dict["input_values"] = input_values
+        if file_inputs is not UNSET:
+            field_dict["file_inputs"] = file_inputs
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.file_input import FileInput
+        from ..models.run_bulk_create_input_values_type_0 import RunBulkCreateInputValuesType0
+
+        d = dict(src_dict)
+        workflow_id = UUID(d.pop("workflow_id"))
+
+        count = d.pop("count")
+
+        def _parse_machine_id(data: object) -> Union[None, UUID, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                machine_id_type_0 = UUID(data)
+
+                return machine_id_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, UUID, Unset], data)
+
+        machine_id = _parse_machine_id(d.pop("machine_id", UNSET))
+
+        def _parse_input_values(data: object) -> Union["RunBulkCreateInputValuesType0", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                input_values_type_0 = RunBulkCreateInputValuesType0.from_dict(data)
+
+                return input_values_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["RunBulkCreateInputValuesType0", None, Unset], data)
+
+        input_values = _parse_input_values(d.pop("input_values", UNSET))
+
+        def _parse_file_inputs(data: object) -> Union[None, Unset, list["FileInput"]]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                file_inputs_type_0 = []
+                _file_inputs_type_0 = data
+                for file_inputs_type_0_item_data in _file_inputs_type_0:
+                    file_inputs_type_0_item = FileInput.from_dict(file_inputs_type_0_item_data)
+
+                    file_inputs_type_0.append(file_inputs_type_0_item)
+
+                return file_inputs_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, Unset, list["FileInput"]], data)
+
+        file_inputs = _parse_file_inputs(d.pop("file_inputs", UNSET))
+
+        run_bulk_create = cls(
+            workflow_id=workflow_id,
+            count=count,
+            machine_id=machine_id,
+            input_values=input_values,
+            file_inputs=file_inputs,
+        )
+
+        run_bulk_create.additional_properties = d
+        return run_bulk_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

cyberdesk-1.11.0/openapi_client/cyberdesk_cloud_client/models/run_bulk_create_input_values_type_0.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="RunBulkCreateInputValuesType0")
+
+
+@_attrs_define
+class RunBulkCreateInputValuesType0:
+    """ """
+
+    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)
+        run_bulk_create_input_values_type_0 = cls()
+
+        run_bulk_create_input_values_type_0.additional_properties = d
+        return run_bulk_create_input_values_type_0
+
+    @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

cyberdesk-1.11.0/openapi_client/cyberdesk_cloud_client/models/run_bulk_create_response.py

@@ -0,0 +1,96 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.run_response import RunResponse
+
+
+T = TypeVar("T", bound="RunBulkCreateResponse")
+
+
+@_attrs_define
+class RunBulkCreateResponse:
+    """Response for bulk run creation
+
+    Attributes:
+        created_runs (list['RunResponse']):
+        failed_count (Union[Unset, int]):  Default: 0.
+        errors (Union[Unset, list[str]]):
+    """
+
+    created_runs: list["RunResponse"]
+    failed_count: Union[Unset, int] = 0
+    errors: Union[Unset, list[str]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        created_runs = []
+        for created_runs_item_data in self.created_runs:
+            created_runs_item = created_runs_item_data.to_dict()
+            created_runs.append(created_runs_item)
+
+        failed_count = self.failed_count
+
+        errors: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.errors, Unset):
+            errors = self.errors
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "created_runs": created_runs,
+            }
+        )
+        if failed_count is not UNSET:
+            field_dict["failed_count"] = failed_count
+        if errors is not UNSET:
+            field_dict["errors"] = errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.run_response import RunResponse
+
+        d = dict(src_dict)
+        created_runs = []
+        _created_runs = d.pop("created_runs")
+        for created_runs_item_data in _created_runs:
+            created_runs_item = RunResponse.from_dict(created_runs_item_data)
+
+            created_runs.append(created_runs_item)
+
+        failed_count = d.pop("failed_count", UNSET)
+
+        errors = cast(list[str], d.pop("errors", UNSET))
+
+        run_bulk_create_response = cls(
+            created_runs=created_runs,
+            failed_count=failed_count,
+            errors=errors,
+        )
+
+        run_bulk_create_response.additional_properties = d
+        return run_bulk_create_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

{cyberdesk-1.10.0 → cyberdesk-1.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cyberdesk"
-version = "1.10.0"
+version = "1.11.0"
 description = "The official Python SDK for Cyberdesk"
 authors = [{name = "Cyberdesk Team", email = "dev@cyberdesk.io"}]
 readme = "README.md"