wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/v2/models/motion_group_setup.py

@@ -0,0 +1,140 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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.collision_setup import CollisionSetup
+from wandelbots_api_client.v2.models.limit_set import LimitSet
+from wandelbots_api_client.v2.models.payload import Payload
+from wandelbots_api_client.v2.models.pose import Pose
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupSetup(BaseModel):
+    """
+    MotionGroupSetup
+    """  # noqa: E501
+
+    motion_group_model: StrictStr = Field(
+        description="Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. "
+    )
+    cycle_time: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="[ms] cycle time of the motion group controller. A trajectory for this motion group should be computed to this resolution."
+    )
+    mounting: Optional[Pose] = Field(default=None, description="The offset from the world frame to the motion group base.")
+    tcp_offset: Optional[Pose] = None
+    global_limits: Optional[LimitSet] = None
+    payload: Optional[Payload] = None
+    collision_setups: Optional[Dict[str, CollisionSetup]] = Field(
+        default=None,
+        description="Collision layers to be respected by the motion planner when planning for a single motion group. Each setup represents one layer, e.g., the safety zones and shapes or a fine grained tool and workpiece model. Layers are checked individually along the trajectory and independently of other layers.  To respect the safety zones of the controller and check for collision: 1. Fetch the safety zones, link and tool shapes from the controller. 2. Add the fetched zones, links and tools to a layer. 3. Create other layers from your own 3D data as needed. 4. Plan trajectory. 5. The response highlights the layer in which a collision was detected by key. ",
+    )
+    __properties: ClassVar[List[str]] = [
+        "motion_group_model",
+        "cycle_time",
+        "mounting",
+        "tcp_offset",
+        "global_limits",
+        "payload",
+        "collision_setups",
+    ]
+
+    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 MotionGroupSetup 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 tcp_offset
+        if self.tcp_offset:
+            _dict["tcp_offset"] = self.tcp_offset.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of global_limits
+        if self.global_limits:
+            _dict["global_limits"] = self.global_limits.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of payload
+        if self.payload:
+            _dict["payload"] = self.payload.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each value in collision_setups (dict)
+        _field_dict = {}
+        if self.collision_setups:
+            for _key_collision_setups in self.collision_setups:
+                if self.collision_setups[_key_collision_setups]:
+                    _field_dict[_key_collision_setups] = self.collision_setups[_key_collision_setups].to_dict()
+            _dict["collision_setups"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupSetup 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"),
+                "cycle_time": obj.get("cycle_time"),
+                "mounting": Pose.from_dict(obj["mounting"]) if obj.get("mounting") is not None else None,
+                "tcp_offset": Pose.from_dict(obj["tcp_offset"]) if obj.get("tcp_offset") is not None else None,
+                "global_limits": LimitSet.from_dict(obj["global_limits"]) if obj.get("global_limits") is not None else None,
+                "payload": Payload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+                "collision_setups": dict((_k, CollisionSetup.from_dict(_v)) for _k, _v in obj["collision_setups"].items())
+                if obj.get("collision_setups") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/motion_group_state.py

@@ -0,0 +1,182 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.execute import Execute
+from wandelbots_api_client.v2.models.motion_group_state_joint_limit_reached import MotionGroupStateJointLimitReached
+from wandelbots_api_client.v2.models.pose import Pose
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupState(BaseModel):
+    """
+    Presents the current state of the motion group.
+    """  # noqa: E501
+
+    timestamp: datetime = Field(description="Timestamp for when data was received from the robot controller.")
+    sequence_number: Annotated[int, Field(le=4294967295, strict=True, ge=0)] = Field(
+        description="Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. "
+    )
+    motion_group: StrictStr = Field(description="Identifier of the motion group.")
+    controller: StrictStr = Field(description="Convenience: Identifier of the robot controller the motion group is attached to.")
+    joint_position: List[Union[StrictFloat, StrictInt]] = Field(
+        description="Current joint position of each joint. The unit depends on the type of joint: For revolute joints, the angle is given in [rad]; for prismatic joints, the displacement is given in [mm]. "
+    )
+    joint_limit_reached: MotionGroupStateJointLimitReached = Field(
+        description="Indicates whether the joint is in a limit for all joints of the motion group. "
+    )
+    joint_torque: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None,
+        description="Current joint torque of each joint in [Nm]. Is only available if the robot controller supports it, e.g., available for UR controllers. ",
+    )
+    joint_current: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None,
+        description="Current at TCP in [A]. Is only available if the robot controller supports it, e.g., available for UR controllers. ",
+    )
+    flange_pose: Optional[Pose] = Field(
+        default=None,
+        description="Pose of the flange. Positions are in [mm]. Orientations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. For robot arms, a flange pose is always returned. For positioners, the flange might not be available, depending on the model. ",
+    )
+    tcp: Optional[StrictStr] = Field(
+        default=None,
+        description="Unique identifier addressing the active TCP. Might not be returned for positioners as some do not support TCPs, depending on the model. ",
+    )
+    tcp_pose: Optional[Pose] = Field(
+        default=None,
+        description="Pose of the TCP selected on the robot control panel. Positions are in [mm]. Orientations are in [rad]. The pose is relative to the response_coordinate_system specified in the request. Might not be returned for positioners as some do not support TCPs, depending on the model. ",
+    )
+    coordinate_system: Optional[StrictStr] = Field(
+        default=None,
+        description="Unique identifier addressing the reference coordinate system of the cartesian data. Might not be returned for positioners as some do not support TCPs, depending on the model. Default: world coordinate system of corresponding controller. ",
+    )
+    payload: Optional[StrictStr] = Field(
+        default=None,
+        description="Unique identifier addressing the active payload. Only fetchable via GET endpoint, not available in WebSocket. ",
+    )
+    standstill: StrictBool = Field(
+        description="Indicates whether the motion group is in standstill. Convenience: Signals that NOVA treats measured joint velocities as 0. "
+    )
+    execute: Optional[Execute] = Field(
+        default=None,
+        description="Data that was commanded to the motion group. Includes additional data on NOVA's execution components for executing trajectories and jogging. This is a convenience field to indicate the last command sent to the motion group. It is not available in all cases, e.g., if the motion group is not moved by NOVA. ",
+    )
+    __properties: ClassVar[List[str]] = [
+        "timestamp",
+        "sequence_number",
+        "motion_group",
+        "controller",
+        "joint_position",
+        "joint_limit_reached",
+        "joint_torque",
+        "joint_current",
+        "flange_pose",
+        "tcp",
+        "tcp_pose",
+        "coordinate_system",
+        "payload",
+        "standstill",
+        "execute",
+    ]
+
+    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 MotionGroupState 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 joint_limit_reached
+        if self.joint_limit_reached:
+            _dict["joint_limit_reached"] = self.joint_limit_reached.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of flange_pose
+        if self.flange_pose:
+            _dict["flange_pose"] = self.flange_pose.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of tcp_pose
+        if self.tcp_pose:
+            _dict["tcp_pose"] = self.tcp_pose.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of execute
+        if self.execute:
+            _dict["execute"] = self.execute.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupState from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "timestamp": obj.get("timestamp"),
+                "sequence_number": obj.get("sequence_number"),
+                "motion_group": obj.get("motion_group"),
+                "controller": obj.get("controller"),
+                "joint_position": obj.get("joint_position"),
+                "joint_limit_reached": MotionGroupStateJointLimitReached.from_dict(obj["joint_limit_reached"])
+                if obj.get("joint_limit_reached") is not None
+                else None,
+                "joint_torque": obj.get("joint_torque"),
+                "joint_current": obj.get("joint_current"),
+                "flange_pose": Pose.from_dict(obj["flange_pose"]) if obj.get("flange_pose") is not None else None,
+                "tcp": obj.get("tcp"),
+                "tcp_pose": Pose.from_dict(obj["tcp_pose"]) if obj.get("tcp_pose") is not None else None,
+                "coordinate_system": obj.get("coordinate_system"),
+                "payload": obj.get("payload"),
+                "standstill": obj.get("standstill"),
+                "execute": Execute.from_dict(obj["execute"]) if obj.get("execute") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/motion_group_state_joint_limit_reached.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MotionGroupStateJointLimitReached(BaseModel):
+    """
+    Indicates which joint of the motion group is in a limit. If a joint is in its limit, only this joint can be moved. Movements that affect any other joints are not executed.
+    """  # noqa: E501
+
+    limit_reached: List[StrictBool] = Field(description="If true, operational (soft) jointLimit is reached for specific joint.")
+    __properties: ClassVar[List[str]] = ["limit_reached"]
+
+    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 MotionGroupStateJointLimitReached 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 MotionGroupStateJointLimitReached from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"limit_reached": obj.get("limit_reached")})
+        return _obj

wandelbots_api_client/v2/models/movement_error_response.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class MovementErrorResponse(BaseModel):
+    """
+    Error message in case an error occurs during movement execution.
+    """  # noqa: E501
+
+    message: StrictStr = Field(description="Detailed error message describing the issue encountered during movement execution.")
+    kind: StrictStr
+    __properties: ClassVar[List[str]] = ["message", "kind"]
+
+    @field_validator("kind")
+    def kind_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["MOTION_ERROR"]):
+            raise ValueError("must be one of enum values ('MOTION_ERROR')")
+        return value
+
+    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 MovementErrorResponse 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 MovementErrorResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"message": obj.get("message"), "kind": obj.get("kind")})
+        return _obj

wandelbots_api_client/v2/models/nan_value_error.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 dev
+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, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.v2.models.nan_value_error_nan_value import NanValueErrorNanValue
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class NanValueError(BaseModel):
+    """
+    NanValueError
+    """  # noqa: E501
+
+    kind: StrictStr
+    nan_value: Optional[NanValueErrorNanValue] = None
+    __properties: ClassVar[List[str]] = ["kind", "nan_value"]
+
+    @field_validator("kind")
+    def kind_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["NanValueError"]):
+            raise ValueError("must be one of enum values ('NanValueError')")
+        return value
+
+    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 NanValueError 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 nan_value
+        if self.nan_value:
+            _dict["nan_value"] = self.nan_value.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of NanValueError from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "kind": obj.get("kind"),
+                "nan_value": NanValueErrorNanValue.from_dict(obj["nan_value"]) if obj.get("nan_value") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/nan_value_error_nan_value.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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 NanValueErrorNanValue(BaseModel):
+    """
+    Requested joint position contains NaN values.
+    """  # noqa: E501
+
+    joint_position: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None, description="The joint position that is out of its limits."
+    )
+    __properties: ClassVar[List[str]] = ["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 NanValueErrorNanValue 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 NanValueErrorNanValue from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"joint_position": obj.get("joint_position")})
+        return _obj