wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/models/collision_motion_group_assembly.py

@@ -0,0 +1,128 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.collider import Collider
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CollisionMotionGroupAssembly(BaseModel):
+    """
+    CollisionMotionGroupAssembly
+    """  # noqa: E501
+
+    stored_link_chain: Optional[StrictStr] = Field(default=None, description="References a stored link chain. ")
+    stored_tool: Optional[StrictStr] = Field(default=None, description="References a stored tool. ")
+    link_chain: Optional[List[Dict[str, Collider]]] = Field(
+        default=None,
+        description="A link chain is a kinematic chain of links that is connected via joints. A motion group can be used to control the motion of the joints in a link chain.  A link is a group of colliders that is attached to the link reference frame.  The reference frame of a link is obtained after applying all sets of Denavit-Hartenberg-parameters from base to (including) the link index.  This means that the reference frame of the link is on the rotation axis of the next joint in the kinematic chain. Example: For a motion group with 2 joints, the collider reference frame (CRF) for link 1 is on the rotation axis of joint 2. The chain looks like: - Origin >> Mounting >> Base >> (CRF Base) Joint 0 >> Link 0 >> (CRF Link 0) Joint 1 >> Link 1 >> (CRF Link 1) Flange (CRF Tool) >> TCP  Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. ",
+    )
+    tool: Optional[Dict[str, Collider]] = Field(
+        default=None,
+        description="Defines the shape of a tool.  A tool is a dictionary of colliders.  All colliders that make up a tool are attached to the flange frame of the motion group. ",
+    )
+    __properties: ClassVar[List[str]] = ["stored_link_chain", "stored_tool", "link_chain", "tool"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CollisionMotionGroupAssembly from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in link_chain (list)
+        _items = []
+        if self.link_chain:
+            for _item in self.link_chain:
+                # >>> Modified from https://github.com/OpenAPITools/openapi-generator/blob/v7.6.0/modules/openapi-generator/src/main/resources/python/model_generic.mustache
+                #     to not drop empty elements in lists
+                _items.append({key: value.to_dict() for key, value in _item.items()})
+                # <<< End modification
+            _dict["link_chain"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in tool (dict)
+        # >>> Modified from openapi template
+        if self.tool:
+            _field_dict = {}
+            for _key, _value in self.tool.items():
+                if self.tool[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["tool"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionMotionGroupAssembly from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "stored_link_chain": obj.get("stored_link_chain"),
+                "stored_tool": obj.get("stored_tool"),
+                "link_chain": [
+                    # >>> Modified from https://github.com/OpenAPITools/openapi-generator/blob/v7.6.0/modules/openapi-generator/src/main/resources/python/model_generic.mustache
+                    #     to allow dicts in lists
+                    {key: Collider.from_dict(value) for key, value in _item.items()} if isinstance(_item, dict) else _item
+                    # <<< End modification
+                    for _item in obj["link_chain"]
+                ]
+                if obj.get("link_chain") is not None
+                else None,
+                "tool": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["tool"].items()) if obj.get("tool") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/collision_robot_configuration_input.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.collider_input import ColliderInput
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CollisionRobotConfigurationInput(BaseModel):
+    """
+    Configuration of a robot in the collision scene.  Default link shapes are provided for all supported robots. Apply `use_default_link_shapes` with `true`.  `link_attachements` are additional shapes that are attached to the link reference frames. The reference frame of the `link_attachements` is obtained after applying all sets of DH-parameters from base to (including) the specified index. Adjacent links in the kinematic chain of the robot are not checked for collision.  The tool is treated like another link attached to the end (flange) of the chain. All tool shapes are described in the flange frame.
+    """  # noqa: E501
+
+    use_default_link_shapes: StrictBool = Field(description="If `true`, default shapes are used for all links.")
+    link_attachements: Optional[Dict[str, Dict[str, ColliderInput]]] = Field(
+        default=None,
+        description="Shapes to attach to link reference frames, additionally to default shapes. The keys are integers representing the link indices, and the values are objects mapping shape names to their collider definitions. ",
+    )
+    tool: Optional[Dict[str, ColliderInput]] = Field(
+        default=None, description="Shapes that make up the tool, attached to the flange frame."
+    )
+    __properties: ClassVar[List[str]] = ["use_default_link_shapes", "link_attachements", "tool"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CollisionRobotConfigurationInput from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in link_attachements (dict)
+        # >>> Modified from openapi template
+        if self.link_attachements:
+            _field_dict = {}
+            for _key, _value in self.link_attachements.items():
+                if self.link_attachements[_key]:
+                    _field_dict[_key] = {_nested_key: _nested_value.to_dict() for _nested_key, _nested_value in _value.items()}
+            _dict["link_attachements"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in tool (dict)
+        # >>> Modified from openapi template
+        if self.tool:
+            _field_dict = {}
+            for _key, _value in self.tool.items():
+                if self.tool[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["tool"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionRobotConfigurationInput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "use_default_link_shapes": obj.get("use_default_link_shapes") if obj.get("use_default_link_shapes") is not None else True,
+                "link_attachements": dict(
+                    (_k, dict((_ik, ColliderInput.from_dict(_iv)) for _ik, _iv in _v.items()) if _v is not None else None)
+                    for _k, _v in obj.get("link_attachements").items()
+                )
+                if obj.get("link_attachements") is not None
+                else None,
+                "tool": dict((_k, ColliderInput.from_dict(_v)) for _k, _v in obj["tool"].items()) if obj.get("tool") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/collision_robot_configuration_output.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.collider_output import ColliderOutput
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CollisionRobotConfigurationOutput(BaseModel):
+    """
+    Configuration of a robot in the collision scene.  Default link shapes are provided for all supported robots. Apply `use_default_link_shapes` with `true`.  `link_attachements` are additional shapes that are attached to the link reference frames. The reference frame of the `link_attachements` is obtained after applying all sets of DH-parameters from base to (including) the specified index. Adjacent links in the kinematic chain of the robot are not checked for collision.  The tool is treated like another link attached to the end (flange) of the chain. All tool shapes are described in the flange frame.
+    """  # noqa: E501
+
+    use_default_link_shapes: StrictBool = Field(description="If `true`, default shapes are used for all links.")
+    link_attachements: Optional[Dict[str, Dict[str, ColliderOutput]]] = Field(
+        default=None,
+        description="Shapes to attach to link reference frames, additionally to default shapes. The keys are integers representing the link indices, and the values are objects mapping shape names to their collider definitions. ",
+    )
+    tool: Optional[Dict[str, ColliderOutput]] = Field(
+        default=None, description="Shapes that make up the tool, attached to the flange frame."
+    )
+    __properties: ClassVar[List[str]] = ["use_default_link_shapes", "link_attachements", "tool"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CollisionRobotConfigurationOutput from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in link_attachements (dict)
+        # >>> Modified from openapi template
+        if self.link_attachements:
+            _field_dict = {}
+            for _key, _value in self.link_attachements.items():
+                if self.link_attachements[_key]:
+                    _field_dict[_key] = {_nested_key: _nested_value.to_dict() for _nested_key, _nested_value in _value.items()}
+            _dict["link_attachements"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in tool (dict)
+        # >>> Modified from openapi template
+        if self.tool:
+            _field_dict = {}
+            for _key, _value in self.tool.items():
+                if self.tool[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["tool"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionRobotConfigurationOutput from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "use_default_link_shapes": obj.get("use_default_link_shapes") if obj.get("use_default_link_shapes") is not None else True,
+                "link_attachements": dict(
+                    (_k, dict((_ik, ColliderOutput.from_dict(_iv)) for _ik, _iv in _v.items()) if _v is not None else None)
+                    for _k, _v in obj.get("link_attachements").items()
+                )
+                if obj.get("link_attachements") is not None
+                else None,
+                "tool": dict((_k, ColliderOutput.from_dict(_v)) for _k, _v in obj["tool"].items()) if obj.get("tool") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/collision_scene.py

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.collider import Collider
+from wandelbots_api_client.models.collision_motion_group import CollisionMotionGroup
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CollisionScene(BaseModel):
+    """
+    Defines the collision scene.  There are two types of objects in the scene: - `colliders`: Each collider is attached directly to the origin of the scene: Origin >> Collider - `motion-groups`: Each motion group is assigned a kinematic chain of links with a special collider, called tool, attached to the last element.   The motion group is attached to the origin of the scene via its mounting: Origin >> Mounting >> Motion Group Base >> […]
+    """  # noqa: E501
+
+    colliders: Optional[Dict[str, Collider]] = Field(default=None, description="A collection of identifiable colliders.")
+    motion_groups: Optional[Dict[str, CollisionMotionGroup]] = Field(
+        default=None,
+        description="Maps a Wandelbots NOVA motion group to its configuration in the collision scene. Key must be a motion group identifier.  Values are collision motion group objects.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. ",
+    )
+    __properties: ClassVar[List[str]] = ["colliders", "motion_groups"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CollisionScene from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each value in colliders (dict)
+        # >>> Modified from openapi template
+        if self.colliders:
+            _field_dict = {}
+            for _key, _value in self.colliders.items():
+                if self.colliders[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["colliders"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in motion_groups (dict)
+        # >>> Modified from openapi template
+        if self.motion_groups:
+            _field_dict = {}
+            for _key, _value in self.motion_groups.items():
+                if self.motion_groups[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["motion_groups"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionScene from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "colliders": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["colliders"].items())
+                if obj.get("colliders") is not None
+                else None,
+                "motion_groups": dict((_k, CollisionMotionGroup.from_dict(_v)) for _k, _v in obj["motion_groups"].items())
+                if obj.get("motion_groups") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/collision_scene_assembly.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.collider import Collider
+from wandelbots_api_client.models.collision_motion_group_assembly import CollisionMotionGroupAssembly
+from wandelbots_api_client.models.collision_scene import CollisionScene
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CollisionSceneAssembly(BaseModel):
+    """
+    Defines the collision scene assembly. Merges all referenced and new scene components into a single scene.  Previously added components with identical identifiers are overwritten within the same group.  There is one group for each of the following components: - Colliders attached to the origin of the scene, - Tool per motion group, and - For each link per motion group.  The scene is assembled by adding components in the following order. 1. stored_scenes 2. scene 3. stored_colliders 4. colliders 5. stored_link_chains and stored_tools (per motion group) 6. link_chains and tools (per motion group)
+    """  # noqa: E501
+
+    stored_scenes: Optional[List[StrictStr]] = Field(
+        default=None,
+        description="Add stored scenes to the scene via their identifiers. The scenes are merged based on their order in the array. The scene at index zero serves as base. Following scenes overwrite components with identical identifiers, see [Collision Scene Assembly](Collision Scene Assembly). ",
+    )
+    scene: Optional[CollisionScene] = None
+    stored_colliders: Optional[List[StrictStr]] = Field(
+        default=None,
+        description="Add stored colliders to the scene via their identifiers. The colliders are added to the the origin of the scene. ",
+    )
+    colliders: Optional[Dict[str, Collider]] = Field(default=None, description="A collection of identifiable colliders.")
+    motion_groups: Optional[Dict[str, CollisionMotionGroupAssembly]] = Field(
+        default=None,
+        description="Maps a Wandelbots NOVA motion group to its assembly configuration in the collision scene. Key must be a motion group identifier.  A collision motion group defines a motion group in the collision scene.  The motion group is attached to the origin of the scene. To relocate the motion group, configure its mounting offset on the physical controller. This ensures that the definition of motion commands and collision scenes use the same coordinate system. The kinematic chain looks like this: - Origin >> Mounting >> Base >> Joint 0 >> Link 0 >> Joint 1 >> […] >> TCP  A `tool` is treated like another link attached to the end (flange) of the kinematic chain. All tool colliders are described in the flange frame. ",
+    )
+    __properties: ClassVar[List[str]] = ["stored_scenes", "scene", "stored_colliders", "colliders", "motion_groups"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True, exclude_none=True))
+
+    def to_json(self) -> str:
+        """
+        Returns the JSON representation of the model using alias
+
+        Do not use pydantic v2 .model_dump_json(by_alias=True, exclude_unset=True) here!
+        It is unable to resolve nested types generated by openapi-generator.
+        """
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of CollisionSceneAssembly from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of scene
+        if self.scene:
+            _dict["scene"] = self.scene.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in colliders (dict)
+        # >>> Modified from openapi template
+        if self.colliders:
+            _field_dict = {}
+            for _key, _value in self.colliders.items():
+                if self.colliders[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["colliders"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in motion_groups (dict)
+        # >>> Modified from openapi template
+        if self.motion_groups:
+            _field_dict = {}
+            for _key, _value in self.motion_groups.items():
+                if self.motion_groups[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["motion_groups"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionSceneAssembly from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "stored_scenes": obj.get("stored_scenes"),
+                "scene": CollisionScene.from_dict(obj["scene"]) if obj.get("scene") is not None else None,
+                "stored_colliders": obj.get("stored_colliders"),
+                "colliders": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["colliders"].items())
+                if obj.get("colliders") is not None
+                else None,
+                "motion_groups": dict((_k, CollisionMotionGroupAssembly.from_dict(_v)) for _k, _v in obj["motion_groups"].items())
+                if obj.get("motion_groups") is not None
+                else None,
+            }
+        )
+        return _obj