wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/models/motion_group_instance_list.py

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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
+from typing import Any, ClassVar, Dict, List
+from wandelbots_api_client.models.motion_group_instance import MotionGroupInstance
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class MotionGroupInstanceList(BaseModel):
+    """
+    A list of motion groups.
+    """  # noqa: E501
+
+    instances: List[MotionGroupInstance]
+    __properties: ClassVar[List[str]] = ["instances"]
+
+    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 MotionGroupInstanceList 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 instances (list)
+        _items = []
+        if self.instances:
+            for _item in self.instances:
+                # >>> 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
+                if _item is not None:
+                    _items.append(_item.to_dict())
+                # <<< End modification
+            _dict["instances"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupInstanceList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "instances": [
+                    # >>> 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
+                    MotionGroupInstance.from_dict(_item) if hasattr(MotionGroupInstance, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["instances"]
+                ]
+                if obj.get("instances") is not None
+                else None
+            }
+        )
+        return _obj

wandelbots_api_client/models/motion_group_joints.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: 1.4.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
+
+
+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(
+        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 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

wandelbots_api_client/models/motion_group_physical.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class MotionGroupPhysical(BaseModel):
+    """
+    The data type describes the physically connected motion groups on a robot controller.
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(description="The unique identifier to address a motion group.")
+    name_from_controller: StrictStr = Field(description="The name the motion group has on the robot controller.")
+    active: StrictBool = Field(
+        description="True if this motion group is active. When a request for a motion group is made, the motion group will be activated and remain activated. The robot controller provides the current state and data for all active motion groups. See [getCurrentMotionGroupState](#/operations/getCurrentMotionGroupState). To deactivate a motion group, use [deactivateMotionGroup](#/operations/deactivateMotionGroup). "
+    )
+    model_from_controller: Optional[StrictStr] = Field(
+        default=None, description="The robot controller model if available. Usable for frontend 3D visualization."
+    )
+    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 available. If not available, then empty. ",
+    )
+    __properties: ClassVar[List[str]] = ["motion_group", "name_from_controller", "active", "model_from_controller", "serial_number"]
+
+    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 MotionGroupPhysical 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 MotionGroupPhysical 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_from_controller": obj.get("name_from_controller"),
+                "active": obj.get("active"),
+                "model_from_controller": obj.get("model_from_controller"),
+                "serial_number": obj.get("serial_number"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/motion_group_specification.py

@@ -0,0 +1,136 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.dh_parameter import DHParameter
+from wandelbots_api_client.models.joint_limit import JointLimit
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class MotionGroupSpecification(BaseModel):
+    """
+    Holding static properties of the motion group.
+    """  # noqa: E501
+
+    dh_parameters: Optional[List[DHParameter]] = Field(
+        default=None,
+        description="A list of DH (Denavit-Hartenberg) parameters. An element in this list contains a set of DH parameters that describe the relation of two cartesian reference frames. Every joint of a serial motion group has an associated cartesian reference frame located in the rotation axis of the joint. A set of DH parameters is applied in the following order: theta, d, a, alpha. ",
+    )
+    mechanical_joint_limits: Optional[List[JointLimit]] = Field(
+        default=None,
+        description="Mechanical joint limits in [rad/mm], starting with the first joint in the motion group base. For every joint there is a minimum and maximum value. Those are defined by the motion group manufacturer and can be found in its data sheet. If a mechanical joint limit is exceeded, the motion group stops immediately. The stop is triggered by the physical robot controller. This should be prevented by using proper soft joint limits. ",
+    )
+    __properties: ClassVar[List[str]] = ["dh_parameters", "mechanical_joint_limits"]
+
+    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 MotionGroupSpecification 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 dh_parameters (list)
+        _items = []
+        if self.dh_parameters:
+            for _item in self.dh_parameters:
+                # >>> 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
+                if _item is not None:
+                    _items.append(_item.to_dict())
+                # <<< End modification
+            _dict["dh_parameters"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in mechanical_joint_limits (list)
+        _items = []
+        if self.mechanical_joint_limits:
+            for _item in self.mechanical_joint_limits:
+                # >>> 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
+                if _item is not None:
+                    _items.append(_item.to_dict())
+                # <<< End modification
+            _dict["mechanical_joint_limits"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of MotionGroupSpecification from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "dh_parameters": [
+                    # >>> 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
+                    DHParameter.from_dict(_item) if hasattr(DHParameter, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["dh_parameters"]
+                ]
+                if obj.get("dh_parameters") is not None
+                else None,
+                "mechanical_joint_limits": [
+                    # >>> 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
+                    JointLimit.from_dict(_item) if hasattr(JointLimit, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["mechanical_joint_limits"]
+                ]
+                if obj.get("mechanical_joint_limits") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/motion_group_state.py

@@ -0,0 +1,180 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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 wandelbots_api_client.models.force_vector import ForceVector
+from wandelbots_api_client.models.joints import Joints
+from wandelbots_api_client.models.motion_group_state_joint_limit_reached import MotionGroupStateJointLimitReached
+from wandelbots_api_client.models.motion_vector import MotionVector
+from wandelbots_api_client.models.pose import Pose
+from wandelbots_api_client.models.tcp_pose import TcpPose
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class MotionGroupState(BaseModel):
+    """
+    Presents the current state of the motion group.
+    """  # noqa: E501
+
+    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: Joints = Field(description="Current joint position of each joint in [rad] ")
+    joint_velocity: Joints = Field(description="Current joint velocity of each joint in [rad/s] ")
+    joint_torque: Optional[Joints] = 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). ",
+    )
+    flange_pose: Optional[Pose] = Field(
+        default=None,
+        description="Current position of the Flange (last point of the motion group before the endeffector starts) in [mm]. The position is relative to the response_coordinate_system that is 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_pose: TcpPose = Field(
+        description="Current position of the TCP currently selected on the robot control panel. Attention: This TCP is not necessarily the same as specified as `tcp` in the request. If you need the information for the specified TCP, use the tcp_pose in the outer response. Position is in [mm]. The position is relative to the response_coordinate_system that is specified in the request. "
+    )
+    velocity: MotionVector = Field(
+        description="Current velocity at TCP in [mm/s]. If `tcp` is not specified, the velocity at the flange is returned. The velocity is relative to the response_coordinate_system specified in the request. "
+    )
+    force: Optional[ForceVector] = Field(
+        default=None,
+        description="Current Force at TCP in [N]. Is only available if the robot controller supports it, e.g. available for UR Controllers. The velocity is relative to the response_coordinate_system specified in the request. ",
+    )
+    joint_limit_reached: MotionGroupStateJointLimitReached = Field(
+        description="Indicates whether the joint is in a limit for all joints of the motion group. "
+    )
+    joint_current: Optional[Joints] = Field(
+        default=None,
+        description="Current Current at TCP in [A]. Is only available if the robot controller supports it, e.g. available for UR Controllers. ",
+    )
+    sequence_number: StrictStr = 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. It is of type string to represent uint64 values, which is not supported by OpenAPI. "
+    )
+    __properties: ClassVar[List[str]] = [
+        "motion_group",
+        "controller",
+        "joint_position",
+        "joint_velocity",
+        "joint_torque",
+        "flange_pose",
+        "tcp_pose",
+        "velocity",
+        "force",
+        "joint_limit_reached",
+        "joint_current",
+        "sequence_number",
+    ]
+
+    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 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_position
+        if self.joint_position:
+            _dict["joint_position"] = self.joint_position.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of joint_velocity
+        if self.joint_velocity:
+            _dict["joint_velocity"] = self.joint_velocity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of joint_torque
+        if self.joint_torque:
+            _dict["joint_torque"] = self.joint_torque.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 velocity
+        if self.velocity:
+            _dict["velocity"] = self.velocity.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of force
+        if self.force:
+            _dict["force"] = self.force.to_dict()
+        # 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 joint_current
+        if self.joint_current:
+            _dict["joint_current"] = self.joint_current.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(
+            {
+                "motion_group": obj.get("motion_group"),
+                "controller": obj.get("controller"),
+                "joint_position": Joints.from_dict(obj["joint_position"]) if obj.get("joint_position") is not None else None,
+                "joint_velocity": Joints.from_dict(obj["joint_velocity"]) if obj.get("joint_velocity") is not None else None,
+                "joint_torque": Joints.from_dict(obj["joint_torque"]) if obj.get("joint_torque") is not None else None,
+                "flange_pose": Pose.from_dict(obj["flange_pose"]) if obj.get("flange_pose") is not None else None,
+                "tcp_pose": TcpPose.from_dict(obj["tcp_pose"]) if obj.get("tcp_pose") is not None else None,
+                "velocity": MotionVector.from_dict(obj["velocity"]) if obj.get("velocity") is not None else None,
+                "force": ForceVector.from_dict(obj["force"]) if obj.get("force") is not None else None,
+                "joint_limit_reached": MotionGroupStateJointLimitReached.from_dict(obj["joint_limit_reached"])
+                if obj.get("joint_limit_reached") is not None
+                else None,
+                "joint_current": Joints.from_dict(obj["joint_current"]) if obj.get("joint_current") is not None else None,
+                "sequence_number": obj.get("sequence_number"),
+            }
+        )
+        return _obj