robodock-cli 0.1.0__py3-none-any.whl

fast_api_client/models/artifact_item.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, 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.artifact_item_extra_info_type_0 import ArtifactItemExtraInfoType0
+
+
+T = TypeVar("T", bound="ArtifactItem")
+
+
+@_attrs_define
+class ArtifactItem:
+    """
+    Attributes:
+        type_ (None | str | Unset):
+        name (None | str | Unset):
+        file_name (None | str | Unset):
+        object_key (None | str | Unset):
+        dataset_uuid (None | str | Unset):
+        singledata_uuid (None | str | Unset):
+        url (None | str | Unset):
+        epoch (int | None | Unset):
+        extra_info (ArtifactItemExtraInfoType0 | None | Unset):
+    """
+
+    type_: None | str | Unset = UNSET
+    name: None | str | Unset = UNSET
+    file_name: None | str | Unset = UNSET
+    object_key: None | str | Unset = UNSET
+    dataset_uuid: None | str | Unset = UNSET
+    singledata_uuid: None | str | Unset = UNSET
+    url: None | str | Unset = UNSET
+    epoch: int | None | Unset = UNSET
+    extra_info: ArtifactItemExtraInfoType0 | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.artifact_item_extra_info_type_0 import ArtifactItemExtraInfoType0  # noqa: PLC0415
+
+        type_: None | str | Unset
+        if isinstance(self.type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = self.type_
+
+        name: None | str | Unset
+        if isinstance(self.name, Unset):
+            name = UNSET
+        else:
+            name = self.name
+
+        file_name: None | str | Unset
+        if isinstance(self.file_name, Unset):
+            file_name = UNSET
+        else:
+            file_name = self.file_name
+
+        object_key: None | str | Unset
+        if isinstance(self.object_key, Unset):
+            object_key = UNSET
+        else:
+            object_key = self.object_key
+
+        dataset_uuid: None | str | Unset
+        if isinstance(self.dataset_uuid, Unset):
+            dataset_uuid = UNSET
+        else:
+            dataset_uuid = self.dataset_uuid
+
+        singledata_uuid: None | str | Unset
+        if isinstance(self.singledata_uuid, Unset):
+            singledata_uuid = UNSET
+        else:
+            singledata_uuid = self.singledata_uuid
+
+        url: None | str | Unset
+        if isinstance(self.url, Unset):
+            url = UNSET
+        else:
+            url = self.url
+
+        epoch: int | None | Unset
+        if isinstance(self.epoch, Unset):
+            epoch = UNSET
+        else:
+            epoch = self.epoch
+
+        extra_info: dict[str, Any] | None | Unset
+        if isinstance(self.extra_info, Unset):
+            extra_info = UNSET
+        elif isinstance(self.extra_info, ArtifactItemExtraInfoType0):
+            extra_info = self.extra_info.to_dict()
+        else:
+            extra_info = self.extra_info
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if name is not UNSET:
+            field_dict["name"] = name
+        if file_name is not UNSET:
+            field_dict["file_name"] = file_name
+        if object_key is not UNSET:
+            field_dict["object_key"] = object_key
+        if dataset_uuid is not UNSET:
+            field_dict["dataset_uuid"] = dataset_uuid
+        if singledata_uuid is not UNSET:
+            field_dict["singledata_uuid"] = singledata_uuid
+        if url is not UNSET:
+            field_dict["url"] = url
+        if epoch is not UNSET:
+            field_dict["epoch"] = epoch
+        if extra_info is not UNSET:
+            field_dict["extra_info"] = extra_info
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.artifact_item_extra_info_type_0 import ArtifactItemExtraInfoType0  # noqa: PLC0415
+
+        d = dict(src_dict)
+
+        def _parse_type_(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        type_ = _parse_type_(d.pop("type", UNSET))
+
+        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_file_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        file_name = _parse_file_name(d.pop("file_name", UNSET))
+
+        def _parse_object_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        object_key = _parse_object_key(d.pop("object_key", UNSET))
+
+        def _parse_dataset_uuid(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        dataset_uuid = _parse_dataset_uuid(d.pop("dataset_uuid", UNSET))
+
+        def _parse_singledata_uuid(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        singledata_uuid = _parse_singledata_uuid(d.pop("singledata_uuid", UNSET))
+
+        def _parse_url(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        url = _parse_url(d.pop("url", UNSET))
+
+        def _parse_epoch(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        epoch = _parse_epoch(d.pop("epoch", UNSET))
+
+        def _parse_extra_info(data: object) -> ArtifactItemExtraInfoType0 | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                extra_info_type_0 = ArtifactItemExtraInfoType0.from_dict(data)
+
+                return extra_info_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(ArtifactItemExtraInfoType0 | None | Unset, data)
+
+        extra_info = _parse_extra_info(d.pop("extra_info", UNSET))
+
+        artifact_item = cls(
+            type_=type_,
+            name=name,
+            file_name=file_name,
+            object_key=object_key,
+            dataset_uuid=dataset_uuid,
+            singledata_uuid=singledata_uuid,
+            url=url,
+            epoch=epoch,
+            extra_info=extra_info,
+        )
+
+        artifact_item.additional_properties = d
+        return artifact_item
+
+    @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/artifact_item_extra_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="ArtifactItemExtraInfoType0")
+
+
+@_attrs_define
+class ArtifactItemExtraInfoType0:
+    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)
+        artifact_item_extra_info_type_0 = cls()
+
+        artifact_item_extra_info_type_0.additional_properties = d
+        return artifact_item_extra_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/artifact_open_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="ArtifactOpenRequest")
+
+
+@_attrs_define
+class ArtifactOpenRequest:
+    """
+    Attributes:
+        object_key (None | str | Unset): Object storage key
+        data_path (None | str | Unset): Full storage path
+    """
+
+    object_key: None | str | Unset = UNSET
+    data_path: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        object_key: None | str | Unset
+        if isinstance(self.object_key, Unset):
+            object_key = UNSET
+        else:
+            object_key = self.object_key
+
+        data_path: None | str | Unset
+        if isinstance(self.data_path, Unset):
+            data_path = UNSET
+        else:
+            data_path = self.data_path
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if object_key is not UNSET:
+            field_dict["object_key"] = object_key
+        if data_path is not UNSET:
+            field_dict["data_path"] = data_path
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_object_key(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        object_key = _parse_object_key(d.pop("object_key", UNSET))
+
+        def _parse_data_path(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        data_path = _parse_data_path(d.pop("data_path", UNSET))
+
+        artifact_open_request = cls(
+            object_key=object_key,
+            data_path=data_path,
+        )
+
+        artifact_open_request.additional_properties = d
+        return artifact_open_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/body_download_singledata_list_api_pv1_singledata_download_get.py

@@ -0,0 +1,61 @@
+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="BodyDownloadSingledataListApiPV1SingledataDownloadGet")
+
+
+@_attrs_define
+class BodyDownloadSingledataListApiPV1SingledataDownloadGet:
+    """
+    Attributes:
+        uuids (list[str]):
+    """
+
+    uuids: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        uuids = self.uuids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "uuids": uuids,
+            }
+        )
+
+        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"))
+
+        body_download_singledata_list_api_pv1_singledata_download_get = cls(
+            uuids=uuids,
+        )
+
+        body_download_singledata_list_api_pv1_singledata_download_get.additional_properties = d
+        return body_download_singledata_list_api_pv1_singledata_download_get
+
+    @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/change_password_request.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="ChangePasswordRequest")
+
+
+@_attrs_define
+class ChangePasswordRequest:
+    """
+    Attributes:
+        old_password (str):
+        new_password (str):
+    """
+
+    old_password: str
+    new_password: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        old_password = self.old_password
+
+        new_password = self.new_password
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "old_password": old_password,
+                "new_password": new_password,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        old_password = d.pop("old_password")
+
+        new_password = d.pop("new_password")
+
+        change_password_request = cls(
+            old_password=old_password,
+            new_password=new_password,
+        )
+
+        change_password_request.additional_properties = d
+        return change_password_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/checkpoint_download_request.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="CheckpointDownloadRequest")
+
+
+@_attrs_define
+class CheckpointDownloadRequest:
+    """
+    Attributes:
+        run_uuid (str): UUID of the run
+        checkpoint_path (str): Path to the checkpoint
+    """
+
+    run_uuid: str
+    checkpoint_path: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        run_uuid = self.run_uuid
+
+        checkpoint_path = self.checkpoint_path
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "run_uuid": run_uuid,
+                "checkpoint_path": checkpoint_path,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        run_uuid = d.pop("run_uuid")
+
+        checkpoint_path = d.pop("checkpoint_path")
+
+        checkpoint_download_request = cls(
+            run_uuid=run_uuid,
+            checkpoint_path=checkpoint_path,
+        )
+
+        checkpoint_download_request.additional_properties = d
+        return checkpoint_download_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/create_group_request.py

@@ -0,0 +1,72 @@
+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
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CreateGroupRequest")
+
+
+@_attrs_define
+class CreateGroupRequest:
+    """
+    Attributes:
+        name (str):
+        description (str | Unset):  Default: ''.
+    """
+
+    name: str
+    description: str | Unset = ""
+    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,
+            }
+        )
+        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")
+
+        description = d.pop("description", UNSET)
+
+        create_group_request = cls(
+            name=name,
+            description=description,
+        )
+
+        create_group_request.additional_properties = d
+        return create_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