robodock-cli 0.1.0__py3-none-any.whl

fast_api_client/models/single_data_update_request_lable_info_type_0.py

@@ -0,0 +1,45 @@
+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="SingleDataUpdateRequestLableInfoType0")
+
+
+@_attrs_define
+class SingleDataUpdateRequestLableInfoType0:
+    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)
+        single_data_update_request_lable_info_type_0 = cls()
+
+        single_data_update_request_lable_info_type_0.additional_properties = d
+        return single_data_update_request_lable_info_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

fast_api_client/models/stage_artifact_append.py

@@ -0,0 +1,85 @@
+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
+
+from ..models.stage_artifact_append_category import StageArtifactAppendCategory
+
+if TYPE_CHECKING:
+    from ..models.artifact_item import ArtifactItem
+
+
+T = TypeVar("T", bound="StageArtifactAppend")
+
+
+@_attrs_define
+class StageArtifactAppend:
+    """
+    Attributes:
+        stage_name (str):
+        category (StageArtifactAppendCategory):
+        artifact (ArtifactItem):
+    """
+
+    stage_name: str
+    category: StageArtifactAppendCategory
+    artifact: ArtifactItem
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        stage_name = self.stage_name
+
+        category = self.category.value
+
+        artifact = self.artifact.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "stage_name": stage_name,
+                "category": category,
+                "artifact": artifact,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.artifact_item import ArtifactItem  # noqa: PLC0415
+
+        d = dict(src_dict)
+        stage_name = d.pop("stage_name")
+
+        category = StageArtifactAppendCategory(d.pop("category"))
+
+        artifact = ArtifactItem.from_dict(d.pop("artifact"))
+
+        stage_artifact_append = cls(
+            stage_name=stage_name,
+            category=category,
+            artifact=artifact,
+        )
+
+        stage_artifact_append.additional_properties = d
+        return stage_artifact_append
+
+    @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

fast_api_client/models/stage_artifact_append_category.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class StageArtifactAppendCategory(StrEnum):
+    CHECKPOINTS = "checkpoints"
+    DATASETS = "datasets"
+    EPOCH_IMAGES = "epoch_images"
+
+    def __str__(self) -> str:
+        return str(self.value)

fast_api_client/models/switch_group_request.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="SwitchGroupRequest")
+
+
+@_attrs_define
+class SwitchGroupRequest:
+    """
+    Attributes:
+        group_id (str):
+    """
+
+    group_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        group_id = self.group_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "group_id": group_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        group_id = d.pop("group_id")
+
+        switch_group_request = cls(
+            group_id=group_id,
+        )
+
+        switch_group_request.additional_properties = d
+        return switch_group_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

fast_api_client/models/task_mapping_create_request.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TaskMappingCreateRequest")
+
+
+@_attrs_define
+class TaskMappingCreateRequest:
+    """
+    Attributes:
+        task_id (int): 任务 ID
+        task_name (str): 任务名称
+        init_scene_text (None | str | Unset): 初始场景描述
+        creator (None | str | Unset): 创建人
+    """
+
+    task_id: int
+    task_name: str
+    init_scene_text: None | str | Unset = UNSET
+    creator: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        task_id = self.task_id
+
+        task_name = self.task_name
+
+        init_scene_text: None | str | Unset
+        if isinstance(self.init_scene_text, Unset):
+            init_scene_text = UNSET
+        else:
+            init_scene_text = self.init_scene_text
+
+        creator: None | str | Unset
+        if isinstance(self.creator, Unset):
+            creator = UNSET
+        else:
+            creator = self.creator
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "task_id": task_id,
+                "task_name": task_name,
+            }
+        )
+        if init_scene_text is not UNSET:
+            field_dict["init_scene_text"] = init_scene_text
+        if creator is not UNSET:
+            field_dict["creator"] = creator
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        task_id = d.pop("task_id")
+
+        task_name = d.pop("task_name")
+
+        def _parse_init_scene_text(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        init_scene_text = _parse_init_scene_text(d.pop("init_scene_text", UNSET))
+
+        def _parse_creator(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        creator = _parse_creator(d.pop("creator", UNSET))
+
+        task_mapping_create_request = cls(
+            task_id=task_id,
+            task_name=task_name,
+            init_scene_text=init_scene_text,
+            creator=creator,
+        )
+
+        task_mapping_create_request.additional_properties = d
+        return task_mapping_create_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

fast_api_client/models/task_mapping_update_request.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TaskMappingUpdateRequest")
+
+
+@_attrs_define
+class TaskMappingUpdateRequest:
+    """
+    Attributes:
+        task_name (None | str | Unset): 任务名称
+        init_scene_text (None | str | Unset): 初始场景描述
+    """
+
+    task_name: None | str | Unset = UNSET
+    init_scene_text: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        task_name: None | str | Unset
+        if isinstance(self.task_name, Unset):
+            task_name = UNSET
+        else:
+            task_name = self.task_name
+
+        init_scene_text: None | str | Unset
+        if isinstance(self.init_scene_text, Unset):
+            init_scene_text = UNSET
+        else:
+            init_scene_text = self.init_scene_text
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if task_name is not UNSET:
+            field_dict["task_name"] = task_name
+        if init_scene_text is not UNSET:
+            field_dict["init_scene_text"] = init_scene_text
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_task_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        task_name = _parse_task_name(d.pop("task_name", UNSET))
+
+        def _parse_init_scene_text(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        init_scene_text = _parse_init_scene_text(d.pop("init_scene_text", UNSET))
+
+        task_mapping_update_request = cls(
+            task_name=task_name,
+            init_scene_text=init_scene_text,
+        )
+
+        task_mapping_update_request.additional_properties = d
+        return task_mapping_update_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

fast_api_client/models/update_group_request.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="UpdateGroupRequest")
+
+
+@_attrs_define
+class UpdateGroupRequest:
+    """
+    Attributes:
+        name (None | str | Unset):
+        description (None | str | Unset):
+    """
+
+    name: None | str | Unset = UNSET
+    description: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name: None | str | Unset
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        description: None | str | Unset
+        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) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        name = _parse_name(d.pop("name", UNSET))
+
+        def _parse_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        description = _parse_description(d.pop("description", UNSET))
+
+        update_group_request = cls(
+            name=name,
+            description=description,
+        )
+
+        update_group_request.additional_properties = d
+        return update_group_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

fast_api_client/models/update_member_request.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="UpdateMemberRequest")
+
+
+@_attrs_define
+class UpdateMemberRequest:
+    """
+    Attributes:
+        role (str):
+    """
+
+    role: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        role = self.role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "role": role,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        role = d.pop("role")
+
+        update_member_request = cls(
+            role=role,
+        )
+
+        update_member_request.additional_properties = d
+        return update_member_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

fast_api_client/models/upload_status_request.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="UploadStatusRequest")
+
+
+@_attrs_define
+class UploadStatusRequest:
+    """
+    Attributes:
+        uuids (list[str]): 触发的数据uuid列表
+        upload_status (list[bool]): 每个uuid数据上传是否成果，array长度与uuids一致，且里面为bool
+    """
+
+    uuids: list[str]
+    upload_status: list[bool]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuids = self.uuids
+
+        upload_status = self.upload_status
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuids": uuids,
+                "upload_status": upload_status,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        uuids = cast(list[str], d.pop("uuids"))
+
+        upload_status = cast(list[bool], d.pop("upload_status"))
+
+        upload_status_request = cls(
+            uuids=uuids,
+            upload_status=upload_status,
+        )
+
+        upload_status_request.additional_properties = d
+        return upload_status_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