robodock-cli 0.1.0__py3-none-any.whl

fast_api_client/models/single_data_update_request.py

@@ -0,0 +1,775 @@
+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.single_data_update_request_lable_info_type_0 import SingleDataUpdateRequestLableInfoType0
+
+
+T = TypeVar("T", bound="SingleDataUpdateRequest")
+
+
+@_attrs_define
+class SingleDataUpdateRequest:
+    """
+    Attributes:
+        alias (None | str | Unset): 别名
+        description (None | str | Unset): 描述
+        label (None | str | Unset): 标签
+        extra_info (None | str | Unset): 额外信息
+        uploaded (bool | None | Unset): 上传是否完成
+        patch_id (None | str | Unset): patch ID
+        patch_name (None | str | Unset): patch 名称
+        episode_id (None | str | Unset): episode ID
+        source_file_name (None | str | Unset): 源文件名
+        operator (None | str | Unset): 操作员
+        reviewer (None | str | Unset): 审核员
+        review_status (None | str | Unset): 审核状态
+        review_time (int | None | Unset): 审核时间
+        review_info (None | str | Unset): 审核备注
+        collection_method (None | str | Unset): 采集方式
+        collector_type (None | str | Unset): 采集设备类型
+        collector_id (None | str | Unset): 采集设备 ID
+        task_id (None | str | Unset): 任务 ID
+        task_actions (None | str | Unset): 任务步骤
+        task_description (None | str | Unset): 任务描述
+        task_success (int | None | Unset): 任务结果
+        finetune (int | None | Unset): 是否用于微调
+        isreal (int | None | Unset): 是否真实数据
+        lable_info (None | SingleDataUpdateRequestLableInfoType0 | Unset): 标签信息
+        scene_type (None | str | Unset): 场景类型
+        scene_id (None | str | Unset): 场景 ID
+        total_frames (int | None | Unset): 总帧数
+        duration_seconds (float | None | Unset): 时长
+        collection_time (int | None | Unset): 采集时间
+        checker_result (None | str | Unset): 检查结果
+        checker_info (None | str | Unset): 检查信息
+        ego_robot (None | str | Unset): 机器人类型
+        model (None | str | Unset): 模型
+        raw_type (None | str | Unset): 原始数据类型
+        raw_data_uuid (None | str | Unset): 原始数据UUID
+    """
+
+    alias: None | str | Unset = UNSET
+    description: None | str | Unset = UNSET
+    label: None | str | Unset = UNSET
+    extra_info: None | str | Unset = UNSET
+    uploaded: bool | None | Unset = UNSET
+    patch_id: None | str | Unset = UNSET
+    patch_name: None | str | Unset = UNSET
+    episode_id: None | str | Unset = UNSET
+    source_file_name: None | str | Unset = UNSET
+    operator: None | str | Unset = UNSET
+    reviewer: None | str | Unset = UNSET
+    review_status: None | str | Unset = UNSET
+    review_time: int | None | Unset = UNSET
+    review_info: None | str | Unset = UNSET
+    collection_method: None | str | Unset = UNSET
+    collector_type: None | str | Unset = UNSET
+    collector_id: None | str | Unset = UNSET
+    task_id: None | str | Unset = UNSET
+    task_actions: None | str | Unset = UNSET
+    task_description: None | str | Unset = UNSET
+    task_success: int | None | Unset = UNSET
+    finetune: int | None | Unset = UNSET
+    isreal: int | None | Unset = UNSET
+    lable_info: None | SingleDataUpdateRequestLableInfoType0 | Unset = UNSET
+    scene_type: None | str | Unset = UNSET
+    scene_id: None | str | Unset = UNSET
+    total_frames: int | None | Unset = UNSET
+    duration_seconds: float | None | Unset = UNSET
+    collection_time: int | None | Unset = UNSET
+    checker_result: None | str | Unset = UNSET
+    checker_info: None | str | Unset = UNSET
+    ego_robot: None | str | Unset = UNSET
+    model: None | str | Unset = UNSET
+    raw_type: None | str | Unset = UNSET
+    raw_data_uuid: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.single_data_update_request_lable_info_type_0 import (
+            SingleDataUpdateRequestLableInfoType0,  # noqa: PLC0415
+        )
+
+        alias: None | str | Unset
+        if isinstance(self.alias, Unset):
+            alias = UNSET
+        else:
+            alias = self.alias
+
+        description: None | str | Unset
+        if isinstance(self.description, Unset):
+            description = UNSET
+        else:
+            description = self.description
+
+        label: None | str | Unset
+        if isinstance(self.label, Unset):
+            label = UNSET
+        else:
+            label = self.label
+
+        extra_info: None | str | Unset
+        if isinstance(self.extra_info, Unset):
+            extra_info = UNSET
+        else:
+            extra_info = self.extra_info
+
+        uploaded: bool | None | Unset
+        if isinstance(self.uploaded, Unset):
+            uploaded = UNSET
+        else:
+            uploaded = self.uploaded
+
+        patch_id: None | str | Unset
+        if isinstance(self.patch_id, Unset):
+            patch_id = UNSET
+        else:
+            patch_id = self.patch_id
+
+        patch_name: None | str | Unset
+        if isinstance(self.patch_name, Unset):
+            patch_name = UNSET
+        else:
+            patch_name = self.patch_name
+
+        episode_id: None | str | Unset
+        if isinstance(self.episode_id, Unset):
+            episode_id = UNSET
+        else:
+            episode_id = self.episode_id
+
+        source_file_name: None | str | Unset
+        if isinstance(self.source_file_name, Unset):
+            source_file_name = UNSET
+        else:
+            source_file_name = self.source_file_name
+
+        operator: None | str | Unset
+        if isinstance(self.operator, Unset):
+            operator = UNSET
+        else:
+            operator = self.operator
+
+        reviewer: None | str | Unset
+        if isinstance(self.reviewer, Unset):
+            reviewer = UNSET
+        else:
+            reviewer = self.reviewer
+
+        review_status: None | str | Unset
+        if isinstance(self.review_status, Unset):
+            review_status = UNSET
+        else:
+            review_status = self.review_status
+
+        review_time: int | None | Unset
+        if isinstance(self.review_time, Unset):
+            review_time = UNSET
+        else:
+            review_time = self.review_time
+
+        review_info: None | str | Unset
+        if isinstance(self.review_info, Unset):
+            review_info = UNSET
+        else:
+            review_info = self.review_info
+
+        collection_method: None | str | Unset
+        if isinstance(self.collection_method, Unset):
+            collection_method = UNSET
+        else:
+            collection_method = self.collection_method
+
+        collector_type: None | str | Unset
+        if isinstance(self.collector_type, Unset):
+            collector_type = UNSET
+        else:
+            collector_type = self.collector_type
+
+        collector_id: None | str | Unset
+        if isinstance(self.collector_id, Unset):
+            collector_id = UNSET
+        else:
+            collector_id = self.collector_id
+
+        task_id: None | str | Unset
+        if isinstance(self.task_id, Unset):
+            task_id = UNSET
+        else:
+            task_id = self.task_id
+
+        task_actions: None | str | Unset
+        if isinstance(self.task_actions, Unset):
+            task_actions = UNSET
+        else:
+            task_actions = self.task_actions
+
+        task_description: None | str | Unset
+        if isinstance(self.task_description, Unset):
+            task_description = UNSET
+        else:
+            task_description = self.task_description
+
+        task_success: int | None | Unset
+        if isinstance(self.task_success, Unset):
+            task_success = UNSET
+        else:
+            task_success = self.task_success
+
+        finetune: int | None | Unset
+        if isinstance(self.finetune, Unset):
+            finetune = UNSET
+        else:
+            finetune = self.finetune
+
+        isreal: int | None | Unset
+        if isinstance(self.isreal, Unset):
+            isreal = UNSET
+        else:
+            isreal = self.isreal
+
+        lable_info: dict[str, Any] | None | Unset
+        if isinstance(self.lable_info, Unset):
+            lable_info = UNSET
+        elif isinstance(self.lable_info, SingleDataUpdateRequestLableInfoType0):
+            lable_info = self.lable_info.to_dict()
+        else:
+            lable_info = self.lable_info
+
+        scene_type: None | str | Unset
+        if isinstance(self.scene_type, Unset):
+            scene_type = UNSET
+        else:
+            scene_type = self.scene_type
+
+        scene_id: None | str | Unset
+        if isinstance(self.scene_id, Unset):
+            scene_id = UNSET
+        else:
+            scene_id = self.scene_id
+
+        total_frames: int | None | Unset
+        if isinstance(self.total_frames, Unset):
+            total_frames = UNSET
+        else:
+            total_frames = self.total_frames
+
+        duration_seconds: float | None | Unset
+        if isinstance(self.duration_seconds, Unset):
+            duration_seconds = UNSET
+        else:
+            duration_seconds = self.duration_seconds
+
+        collection_time: int | None | Unset
+        if isinstance(self.collection_time, Unset):
+            collection_time = UNSET
+        else:
+            collection_time = self.collection_time
+
+        checker_result: None | str | Unset
+        if isinstance(self.checker_result, Unset):
+            checker_result = UNSET
+        else:
+            checker_result = self.checker_result
+
+        checker_info: None | str | Unset
+        if isinstance(self.checker_info, Unset):
+            checker_info = UNSET
+        else:
+            checker_info = self.checker_info
+
+        ego_robot: None | str | Unset
+        if isinstance(self.ego_robot, Unset):
+            ego_robot = UNSET
+        else:
+            ego_robot = self.ego_robot
+
+        model: None | str | Unset
+        if isinstance(self.model, Unset):
+            model = UNSET
+        else:
+            model = self.model
+
+        raw_type: None | str | Unset
+        if isinstance(self.raw_type, Unset):
+            raw_type = UNSET
+        else:
+            raw_type = self.raw_type
+
+        raw_data_uuid: None | str | Unset
+        if isinstance(self.raw_data_uuid, Unset):
+            raw_data_uuid = UNSET
+        else:
+            raw_data_uuid = self.raw_data_uuid
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if alias is not UNSET:
+            field_dict["alias"] = alias
+        if description is not UNSET:
+            field_dict["description"] = description
+        if label is not UNSET:
+            field_dict["label"] = label
+        if extra_info is not UNSET:
+            field_dict["extra_info"] = extra_info
+        if uploaded is not UNSET:
+            field_dict["uploaded"] = uploaded
+        if patch_id is not UNSET:
+            field_dict["patch_id"] = patch_id
+        if patch_name is not UNSET:
+            field_dict["patch_name"] = patch_name
+        if episode_id is not UNSET:
+            field_dict["episode_id"] = episode_id
+        if source_file_name is not UNSET:
+            field_dict["source_file_name"] = source_file_name
+        if operator is not UNSET:
+            field_dict["operator"] = operator
+        if reviewer is not UNSET:
+            field_dict["reviewer"] = reviewer
+        if review_status is not UNSET:
+            field_dict["review_status"] = review_status
+        if review_time is not UNSET:
+            field_dict["review_time"] = review_time
+        if review_info is not UNSET:
+            field_dict["review_info"] = review_info
+        if collection_method is not UNSET:
+            field_dict["collection_method"] = collection_method
+        if collector_type is not UNSET:
+            field_dict["collector_type"] = collector_type
+        if collector_id is not UNSET:
+            field_dict["collector_id"] = collector_id
+        if task_id is not UNSET:
+            field_dict["task_id"] = task_id
+        if task_actions is not UNSET:
+            field_dict["task_actions"] = task_actions
+        if task_description is not UNSET:
+            field_dict["task_description"] = task_description
+        if task_success is not UNSET:
+            field_dict["task_success"] = task_success
+        if finetune is not UNSET:
+            field_dict["finetune"] = finetune
+        if isreal is not UNSET:
+            field_dict["isreal"] = isreal
+        if lable_info is not UNSET:
+            field_dict["lable_info"] = lable_info
+        if scene_type is not UNSET:
+            field_dict["scene_type"] = scene_type
+        if scene_id is not UNSET:
+            field_dict["scene_id"] = scene_id
+        if total_frames is not UNSET:
+            field_dict["total_frames"] = total_frames
+        if duration_seconds is not UNSET:
+            field_dict["duration_seconds"] = duration_seconds
+        if collection_time is not UNSET:
+            field_dict["collection_time"] = collection_time
+        if checker_result is not UNSET:
+            field_dict["checker_result"] = checker_result
+        if checker_info is not UNSET:
+            field_dict["checker_info"] = checker_info
+        if ego_robot is not UNSET:
+            field_dict["ego_robot"] = ego_robot
+        if model is not UNSET:
+            field_dict["model"] = model
+        if raw_type is not UNSET:
+            field_dict["raw_type"] = raw_type
+        if raw_data_uuid is not UNSET:
+            field_dict["raw_data_uuid"] = raw_data_uuid
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.single_data_update_request_lable_info_type_0 import (
+            SingleDataUpdateRequestLableInfoType0,  # noqa: PLC0415
+        )
+
+        d = dict(src_dict)
+
+        def _parse_alias(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        alias = _parse_alias(d.pop("alias", 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))
+
+        def _parse_label(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        label = _parse_label(d.pop("label", UNSET))
+
+        def _parse_extra_info(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        extra_info = _parse_extra_info(d.pop("extra_info", UNSET))
+
+        def _parse_uploaded(data: object) -> bool | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(bool | None | Unset, data)
+
+        uploaded = _parse_uploaded(d.pop("uploaded", UNSET))
+
+        def _parse_patch_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        patch_id = _parse_patch_id(d.pop("patch_id", UNSET))
+
+        def _parse_patch_name(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        patch_name = _parse_patch_name(d.pop("patch_name", UNSET))
+
+        def _parse_episode_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        episode_id = _parse_episode_id(d.pop("episode_id", UNSET))
+
+        def _parse_source_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)
+
+        source_file_name = _parse_source_file_name(d.pop("source_file_name", UNSET))
+
+        def _parse_operator(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        operator = _parse_operator(d.pop("operator", UNSET))
+
+        def _parse_reviewer(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        reviewer = _parse_reviewer(d.pop("reviewer", UNSET))
+
+        def _parse_review_status(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        review_status = _parse_review_status(d.pop("review_status", UNSET))
+
+        def _parse_review_time(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        review_time = _parse_review_time(d.pop("review_time", UNSET))
+
+        def _parse_review_info(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        review_info = _parse_review_info(d.pop("review_info", UNSET))
+
+        def _parse_collection_method(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        collection_method = _parse_collection_method(d.pop("collection_method", UNSET))
+
+        def _parse_collector_type(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        collector_type = _parse_collector_type(d.pop("collector_type", UNSET))
+
+        def _parse_collector_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        collector_id = _parse_collector_id(d.pop("collector_id", UNSET))
+
+        def _parse_task_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        task_id = _parse_task_id(d.pop("task_id", UNSET))
+
+        def _parse_task_actions(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        task_actions = _parse_task_actions(d.pop("task_actions", UNSET))
+
+        def _parse_task_description(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        task_description = _parse_task_description(d.pop("task_description", UNSET))
+
+        def _parse_task_success(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        task_success = _parse_task_success(d.pop("task_success", UNSET))
+
+        def _parse_finetune(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        finetune = _parse_finetune(d.pop("finetune", UNSET))
+
+        def _parse_isreal(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        isreal = _parse_isreal(d.pop("isreal", UNSET))
+
+        def _parse_lable_info(data: object) -> None | SingleDataUpdateRequestLableInfoType0 | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                lable_info_type_0 = SingleDataUpdateRequestLableInfoType0.from_dict(data)
+
+                return lable_info_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | SingleDataUpdateRequestLableInfoType0 | Unset, data)
+
+        lable_info = _parse_lable_info(d.pop("lable_info", UNSET))
+
+        def _parse_scene_type(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        scene_type = _parse_scene_type(d.pop("scene_type", UNSET))
+
+        def _parse_scene_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        scene_id = _parse_scene_id(d.pop("scene_id", UNSET))
+
+        def _parse_total_frames(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        total_frames = _parse_total_frames(d.pop("total_frames", UNSET))
+
+        def _parse_duration_seconds(data: object) -> float | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(float | None | Unset, data)
+
+        duration_seconds = _parse_duration_seconds(d.pop("duration_seconds", UNSET))
+
+        def _parse_collection_time(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        collection_time = _parse_collection_time(d.pop("collection_time", UNSET))
+
+        def _parse_checker_result(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        checker_result = _parse_checker_result(d.pop("checker_result", UNSET))
+
+        def _parse_checker_info(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        checker_info = _parse_checker_info(d.pop("checker_info", UNSET))
+
+        def _parse_ego_robot(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        ego_robot = _parse_ego_robot(d.pop("ego_robot", UNSET))
+
+        def _parse_model(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        model = _parse_model(d.pop("model", UNSET))
+
+        def _parse_raw_type(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        raw_type = _parse_raw_type(d.pop("raw_type", UNSET))
+
+        def _parse_raw_data_uuid(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        raw_data_uuid = _parse_raw_data_uuid(d.pop("raw_data_uuid", UNSET))
+
+        single_data_update_request = cls(
+            alias=alias,
+            description=description,
+            label=label,
+            extra_info=extra_info,
+            uploaded=uploaded,
+            patch_id=patch_id,
+            patch_name=patch_name,
+            episode_id=episode_id,
+            source_file_name=source_file_name,
+            operator=operator,
+            reviewer=reviewer,
+            review_status=review_status,
+            review_time=review_time,
+            review_info=review_info,
+            collection_method=collection_method,
+            collector_type=collector_type,
+            collector_id=collector_id,
+            task_id=task_id,
+            task_actions=task_actions,
+            task_description=task_description,
+            task_success=task_success,
+            finetune=finetune,
+            isreal=isreal,
+            lable_info=lable_info,
+            scene_type=scene_type,
+            scene_id=scene_id,
+            total_frames=total_frames,
+            duration_seconds=duration_seconds,
+            collection_time=collection_time,
+            checker_result=checker_result,
+            checker_info=checker_info,
+            ego_robot=ego_robot,
+            model=model,
+            raw_type=raw_type,
+            raw_data_uuid=raw_data_uuid,
+        )
+
+        single_data_update_request.additional_properties = d
+        return single_data_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