wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/v2/models/motion_group_description.py

@@ -0,0 +1,241 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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 typing_extensions import Annotated
+from wandelbots_api_client.v2.models.collider import Collider
+from wandelbots_api_client.v2.models.dh_parameter import DHParameter
+from wandelbots_api_client.v2.models.operation_limits import OperationLimits
+from wandelbots_api_client.v2.models.payload import Payload
+from wandelbots_api_client.v2.models.pose import Pose
+from wandelbots_api_client.v2.models.tcp_offset import TcpOffset
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupDescription(BaseModel):
+    """
+    The configuration of a motion-group used for motion planning. The parameters `mounting`, `kinematic_chain_offset`, `dh_parameters`, `flange_offset` and `tcp_offset` are used to model the kinematic structure of the motion group. They can be used to compute the coordinate transformations from world to tcp frame: [world frame] -> mounting -> [base frame] -> kinematic chain offset + motion group kinematics (Denavit-Hartenberg parameters) -> [end of kinematic chain frame] -> flange_offset -> [flange frame] -> tcp_offset -> [tcp frame].
+    """  # noqa: E501
+
+    motion_group_model: StrictStr = Field(
+        description="Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. "
+    )
+    mounting: Optional[Pose] = Field(default=None, description="The offset from the world frame to the motion group base.")
+    tcps: Optional[Dict[str, TcpOffset]] = Field(
+        default=None,
+        description="Maps a TCP name to its offset relative to the flange coordinate system. Key must be a TCP identifier. Values are TcpOffsets. ",
+    )
+    safety_zones: Optional[Dict[str, Collider]] = Field(
+        default=None, description="SafetyZones are areas which cannot be entered or where certain limits apply."
+    )
+    safety_link_colliders: Optional[List[Dict[str, Collider]]] = Field(
+        default=None,
+        description="The shape of the MotionGroups links to validate against safety zones. Indexed along the kinematic chain, starting with a static base shape before first joint. ",
+    )
+    safety_tool_colliders: Optional[Dict[str, Dict[str, Collider]]] = Field(
+        default=None,
+        description="Maps a TCP name to its tool collider. Key must be a TCP identifier. Values are ColliderDictionaries that make up the shape of one tool to validate against safety zones. ",
+    )
+    operation_limits: OperationLimits
+    payloads: Optional[Dict[str, Payload]] = Field(
+        default=None, description="Maps a payload name to its configuration. Key must be a payload identifier. Values are payload objects. "
+    )
+    cycle_time: Optional[Annotated[int, Field(le=2147483647, strict=True, ge=0)]] = Field(
+        default=None,
+        description="[ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution.",
+    )
+    dh_parameters: Optional[List[DHParameter]] = Field(
+        default=None, description="The Denavit-Hartenberg parameters describing the motion group kinematics."
+    )
+    kinematic_chain_offset: Optional[Pose] = Field(
+        default=None,
+        description="Constant coordinate transformation between the motion group base frame and the start of the kinematic chain modelled by Denavit-Hartenberg parameters. Unlike the mounting, which is used to set the actual position and orientation of the motion group within a cell, this offset is fixed. It is part of the description of the kinematical structure of the motion group. ",
+    )
+    flange_offset: Optional[Pose] = Field(
+        default=None,
+        description="Constant coordinate transformation between the end of the kinematic chain modelled by Denavit-Hartenberg parameters and the flange frame. This can be used, e.g., to ensure that the flange frame has a certain orientation. ",
+    )
+    serial_number: Optional[StrictStr] = Field(
+        default=None,
+        description="The serial number of the motion group, if available. If not available, the serial number of the robot controller. If not available, empty. ",
+    )
+    description_revision: Optional[Annotated[int, Field(le=2147483647, strict=True, ge=0)]] = Field(
+        default=None,
+        description="Revision number of the motion group description. The revision is incremented whenever the motion group description changes due to a modification of the tools or the payloads in the robot configuration. The robot controller is polled every 10 s in Monitoring Mode to detect those changes. Use to detect changes since the last retrieval. ",
+    )
+    __properties: ClassVar[List[str]] = [
+        "motion_group_model",
+        "mounting",
+        "tcps",
+        "safety_zones",
+        "safety_link_colliders",
+        "safety_tool_colliders",
+        "operation_limits",
+        "payloads",
+        "cycle_time",
+        "dh_parameters",
+        "kinematic_chain_offset",
+        "flange_offset",
+        "serial_number",
+        "description_revision",
+    ]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MotionGroupDescription 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 mounting
+        if self.mounting:
+            _dict["mounting"] = self.mounting.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in tcps (dict)
+        _field_dict = {}
+        if self.tcps:
+            for _key_tcps in self.tcps:
+                if self.tcps[_key_tcps]:
+                    _field_dict[_key_tcps] = self.tcps[_key_tcps].to_dict()
+            _dict["tcps"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in safety_zones (dict)
+        _field_dict = {}
+        if self.safety_zones:
+            for _key_safety_zones in self.safety_zones:
+                if self.safety_zones[_key_safety_zones]:
+                    _field_dict[_key_safety_zones] = self.safety_zones[_key_safety_zones].to_dict()
+            _dict["safety_zones"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each item in safety_link_colliders (list of dict)
+        _items = []
+        if self.safety_link_colliders:
+            for _item_safety_link_colliders in self.safety_link_colliders:
+                if _item_safety_link_colliders:
+                    _items.append({_inner_key: _inner_value.to_dict() for _inner_key, _inner_value in _item_safety_link_colliders.items()})
+            _dict["safety_link_colliders"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in safety_tool_colliders (dict of dict)
+        _field_dict_of_dict = {}
+        if self.safety_tool_colliders:
+            for _key_safety_tool_colliders, _value_safety_tool_colliders in self.safety_tool_colliders.items():
+                if _value_safety_tool_colliders is not None:
+                    _field_dict_of_dict[_key_safety_tool_colliders] = {
+                        _key: _value.to_dict() for _key, _value in _value_safety_tool_colliders.items()
+                    }
+            _dict["safety_tool_colliders"] = _field_dict_of_dict
+        # override the default output from pydantic by calling `to_dict()` of operation_limits
+        if self.operation_limits:
+            _dict["operation_limits"] = self.operation_limits.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in payloads (dict)
+        _field_dict = {}
+        if self.payloads:
+            for _key_payloads in self.payloads:
+                if self.payloads[_key_payloads]:
+                    _field_dict[_key_payloads] = self.payloads[_key_payloads].to_dict()
+            _dict["payloads"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each item in dh_parameters (list)
+        _items = []
+        if self.dh_parameters:
+            for _item_dh_parameters in self.dh_parameters:
+                if _item_dh_parameters:
+                    _items.append(_item_dh_parameters.to_dict())
+            _dict["dh_parameters"] = _items
+        # override the default output from pydantic by calling `to_dict()` of kinematic_chain_offset
+        if self.kinematic_chain_offset:
+            _dict["kinematic_chain_offset"] = self.kinematic_chain_offset.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of flange_offset
+        if self.flange_offset:
+            _dict["flange_offset"] = self.flange_offset.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupDescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "motion_group_model": obj.get("motion_group_model"),
+                "mounting": Pose.from_dict(obj["mounting"]) if obj.get("mounting") is not None else None,
+                "tcps": dict((_k, TcpOffset.from_dict(_v)) for _k, _v in obj["tcps"].items()) if obj.get("tcps") is not None else None,
+                "safety_zones": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["safety_zones"].items())
+                if obj.get("safety_zones") is not None
+                else None,
+                "safety_link_colliders": [
+                    {_inner_key: Collider.from_dict(_inner_value) for _inner_key, _inner_value in _item.items()}
+                    for _item in obj["safety_link_colliders"]
+                ]
+                if obj.get("safety_link_colliders") is not None
+                else None,
+                "safety_tool_colliders": dict(
+                    (_k, dict((_ik, Collider.from_dict(_iv)) for _ik, _iv in _v.items()) if _v is not None else None)
+                    for _k, _v in obj["safety_tool_colliders"].items()
+                )
+                if obj.get("safety_tool_colliders") is not None
+                else None,
+                "operation_limits": OperationLimits.from_dict(obj["operation_limits"]) if obj.get("operation_limits") is not None else None,
+                "payloads": dict((_k, Payload.from_dict(_v)) for _k, _v in obj["payloads"].items())
+                if obj.get("payloads") is not None
+                else None,
+                "cycle_time": obj.get("cycle_time"),
+                "dh_parameters": [DHParameter.from_dict(_item) for _item in obj["dh_parameters"]]
+                if obj.get("dh_parameters") is not None
+                else None,
+                "kinematic_chain_offset": Pose.from_dict(obj["kinematic_chain_offset"])
+                if obj.get("kinematic_chain_offset") is not None
+                else None,
+                "flange_offset": Pose.from_dict(obj["flange_offset"]) if obj.get("flange_offset") is not None else None,
+                "serial_number": obj.get("serial_number"),
+                "description_revision": obj.get("description_revision"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/motion_group_from_json.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupFromJson(BaseModel):
+    """
+    MotionGroupFromJson
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(description="Unique identifier for the motion group to be added.")
+    json_data: StrictStr = Field(
+        description="Full JSON configuration of the virtual robot controller. This can be obtained from the physical controller's configuration via [getVirtualControllerConfiguration](#/operations/getVirtualControllerConfiguration). "
+    )
+    extracted_motion_group_id: StrictStr = Field(
+        description="The identifier of the motion group that needs to be extracted from the provided JSON configuration. "
+    )
+    initial_joint_position: Optional[StrictStr] = Field(
+        default=None,
+        description="Initial joint position of the added motion group. Provides the joint position as a JSON array of float values in radians, where the array length must match the robot's degrees of freedom (DOF), e.g., `\"[0, 0, 0, 0, 0, 0]\"` for a 6-DOF robot. If the provided array length does not match the robot's DOF, the array will be adjusted: if it is longer, extra values will be truncated; if it is shorter, missing values will be filled with zeros. ",
+    )
+    __properties: ClassVar[List[str]] = ["motion_group", "json_data", "extracted_motion_group_id", "initial_joint_position"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MotionGroupFromJson 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupFromJson from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "motion_group": obj.get("motion_group"),
+                "json_data": obj.get("json_data"),
+                "extracted_motion_group_id": obj.get("extracted_motion_group_id"),
+                "initial_joint_position": obj.get("initial_joint_position"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/motion_group_from_type.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupFromType(BaseModel):
+    """
+    MotionGroupFromType
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(description="Unique identifier for the motion group to be added.")
+    motion_group_model: StrictStr = Field(
+        description="Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. "
+    )
+    initial_joint_position: Optional[StrictStr] = Field(
+        default=None,
+        description="Initial joint position of the added motion group. Provides the joint position as a JSON array of float values in radians, where the array length must match the robot's degrees of freedom (DOF), e.g., `\"[0, 0, 0, 0, 0, 0]\"` for a 6-DOF robot. If the provided array length does not match the robot's DOF, the array will be adjusted; if it is longer, extra values will be truncated; if it is shorter, missing values will be filled with zeros. ",
+    )
+    __properties: ClassVar[List[str]] = ["motion_group", "motion_group_model", "initial_joint_position"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MotionGroupFromType 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupFromType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "motion_group": obj.get("motion_group"),
+                "motion_group_model": obj.get("motion_group_model"),
+                "initial_joint_position": obj.get("initial_joint_position"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/motion_group_info.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupInfo(BaseModel):
+    """
+    MotionGroupInfo
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(
+        description="The unique identifier of the motion group. Use it to refer to the motion group in other calls. "
+    )
+    name: StrictStr = Field(description="The name of the motion group for display purposes. ")
+    dof: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="The number of joints aka degrees of freedom in the motion group. "
+    )
+    __properties: ClassVar[List[str]] = ["motion_group", "name", "dof"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MotionGroupInfo 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"motion_group": obj.get("motion_group"), "name": obj.get("name"), "dof": obj.get("dof")})
+        return _obj

wandelbots_api_client/v2/models/motion_group_joints.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupJoints(BaseModel):
+    """
+    Ensure to provide one value for each joint. See [getMotionGroups](#/operations/getMotionGroups) for the number of joints. Everything but positions is optional.
+    """  # noqa: E501
+
+    positions: List[Union[StrictFloat, StrictInt]] = Field(description="The joint positions of the motion group. ")
+    velocities: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None, description="The joint velocities of the motion group. "
+    )
+    accelerations: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None, description="The joint accelerations of the motion group. "
+    )
+    torques: Optional[List[Union[StrictFloat, StrictInt]]] = Field(default=None, description="The joint torques of the motion group. ")
+    __properties: ClassVar[List[str]] = ["positions", "velocities", "accelerations", "torques"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=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))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of MotionGroupJoints 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupJoints from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "positions": obj.get("positions"),
+                "velocities": obj.get("velocities"),
+                "accelerations": obj.get("accelerations"),
+                "torques": obj.get("torques"),
+            }
+        )
+        return _obj