wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/v2/models/robot_tcp_data.py

@@ -0,0 +1,108 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.flange_payload import FlangePayload
+from wandelbots_api_client.v2.models.orientation_type import OrientationType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RobotTcpData(BaseModel):
+    """
+    RobotTcpData
+    """  # noqa: E501
+
+    name: Optional[StrictStr] = Field(default=None, description="A readable and changeable name for frontend visualization.")
+    position: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="A three-dimensional vector [x, y, z] with double precision. "
+    )
+    orientation: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=4)]] = Field(
+        default=None,
+        description="Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. ",
+    )
+    orientation_type: Optional[OrientationType] = OrientationType.ROTATION_VECTOR
+    payload: Optional[FlangePayload] = None
+    __properties: ClassVar[List[str]] = ["name", "position", "orientation", "orientation_type", "payload"]
+
+    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 RobotTcpData 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 payload
+        if self.payload:
+            _dict["payload"] = self.payload.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RobotTcpData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "name": obj.get("name"),
+                "position": obj.get("position"),
+                "orientation": obj.get("orientation"),
+                "orientation_type": obj.get("orientation_type")
+                if obj.get("orientation_type") is not None
+                else OrientationType.ROTATION_VECTOR,
+                "payload": FlangePayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/rrt_connect_algorithm.py

@@ -0,0 +1,127 @@
+# 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, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RRTConnectAlgorithm(BaseModel):
+    """
+    RRTConnectAlgorithm
+    """  # noqa: E501
+
+    algorithm_name: StrictStr = Field(
+        description="Algorithm discriminator.  RRT Connect algorithm configuration for collision-free path planning. Rapidly-exploring Random Trees (RRT) builds trees of valid configurations by randomly sampling the joint space and connecting feasible points with JointPTP motions. RRT Connect grows two trees simultaneously from start and target positions until they meet. This is a custom implementation optimized for manipulator kinematics and collision checking in industrial contexts. "
+    )
+    max_iterations: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(
+        default=10000,
+        description="Maximum number of iterations for the RRT Connect algorithm. Higher values increase likelihood of success, but also computation time. ",
+    )
+    max_step_size: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=1, description="Maximum step size for tree extension in joint space."
+    )
+    adaptive_step_size: Optional[StrictBool] = Field(
+        default=True, description="Adjust the maximum step size during the search based on the recent success rate of tree expansion."
+    )
+    apply_smoothing: Optional[StrictBool] = Field(
+        default=True,
+        description="Apply smoothing after the search has succeeded. This will remove as many intermediate points as possible while keeping the path valid.",
+    )
+    apply_blending: Optional[StrictBool] = Field(
+        default=True,
+        description="Apply blending after the search has succeeded and smoothing has been applied. This will apply the largest viable blending at each intermediate point.",
+    )
+    __properties: ClassVar[List[str]] = [
+        "algorithm_name",
+        "max_iterations",
+        "max_step_size",
+        "adaptive_step_size",
+        "apply_smoothing",
+        "apply_blending",
+    ]
+
+    @field_validator("algorithm_name")
+    def algorithm_name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["RRTConnectAlgorithm"]):
+            raise ValueError("must be one of enum values ('RRTConnectAlgorithm')")
+        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 RRTConnectAlgorithm 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 RRTConnectAlgorithm from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "algorithm_name": obj.get("algorithm_name"),
+                "max_iterations": obj.get("max_iterations") if obj.get("max_iterations") is not None else 10000,
+                "max_step_size": obj.get("max_step_size") if obj.get("max_step_size") is not None else 1,
+                "adaptive_step_size": obj.get("adaptive_step_size") if obj.get("adaptive_step_size") is not None else True,
+                "apply_smoothing": obj.get("apply_smoothing") if obj.get("apply_smoothing") is not None else True,
+                "apply_blending": obj.get("apply_blending") if obj.get("apply_blending") is not None else True,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/safety_geometry.py

@@ -0,0 +1,125 @@
+# 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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.v2.models.safety_geometry_box import SafetyGeometryBox
+from wandelbots_api_client.v2.models.safety_geometry_capsule import SafetyGeometryCapsule
+from wandelbots_api_client.v2.models.safety_geometry_lozenge import SafetyGeometryLozenge
+from wandelbots_api_client.v2.models.safety_geometry_plane import SafetyGeometryPlane
+from wandelbots_api_client.v2.models.safety_geometry_prism import SafetyGeometryPrism
+from wandelbots_api_client.v2.models.safety_geometry_sphere import SafetyGeometrySphere
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class SafetyGeometry(BaseModel):
+    """
+    Geometric shape definition for a safety zone.  Exactly one shape field (sphere, capsule, lozenge, box, prism, or plane) should be set.
+    """  # noqa: E501
+
+    id: StrictStr = Field(description="Unique identifier of this geometry.")
+    sphere: Optional[SafetyGeometrySphere] = None
+    capsule: Optional[SafetyGeometryCapsule] = None
+    lozenge: Optional[SafetyGeometryLozenge] = None
+    box: Optional[SafetyGeometryBox] = None
+    prism: Optional[SafetyGeometryPrism] = None
+    plane: Optional[SafetyGeometryPlane] = None
+    inverted: StrictBool = Field(description="If `true`, the geometry is inverted (outside is restricted, inside is safe).")
+    __properties: ClassVar[List[str]] = ["id", "sphere", "capsule", "lozenge", "box", "prism", "plane", "inverted"]
+
+    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 SafetyGeometry 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 sphere
+        if self.sphere:
+            _dict["sphere"] = self.sphere.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of capsule
+        if self.capsule:
+            _dict["capsule"] = self.capsule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of lozenge
+        if self.lozenge:
+            _dict["lozenge"] = self.lozenge.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of box
+        if self.box:
+            _dict["box"] = self.box.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of prism
+        if self.prism:
+            _dict["prism"] = self.prism.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of plane
+        if self.plane:
+            _dict["plane"] = self.plane.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SafetyGeometry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "id": obj.get("id"),
+                "sphere": SafetyGeometrySphere.from_dict(obj["sphere"]) if obj.get("sphere") is not None else None,
+                "capsule": SafetyGeometryCapsule.from_dict(obj["capsule"]) if obj.get("capsule") is not None else None,
+                "lozenge": SafetyGeometryLozenge.from_dict(obj["lozenge"]) if obj.get("lozenge") is not None else None,
+                "box": SafetyGeometryBox.from_dict(obj["box"]) if obj.get("box") is not None else None,
+                "prism": SafetyGeometryPrism.from_dict(obj["prism"]) if obj.get("prism") is not None else None,
+                "plane": SafetyGeometryPlane.from_dict(obj["plane"]) if obj.get("plane") is not None else None,
+                "inverted": obj.get("inverted") if obj.get("inverted") is not None else False,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/safety_geometry_box.py

@@ -0,0 +1,89 @@
+# 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, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class SafetyGeometryBox(BaseModel):
+    """
+    Box shape defined by a center point and three orthogonal edge midpoints. This representation matches the robot controller's internal format and the `Box` message in the virtual robot.  Unlike a parametric size-and-pose box definition, this format can represent all box orientations produced by the robot controller, including left-handed coordinate systems.
+    """  # noqa: E501
+
+    center: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="Center of the box as Vector3 [x, y, z] in [mm]."
+    )
+    neighbour: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=9, max_length=9)] = Field(
+        description="Three edge midpoint coordinates as a flattened array [x1, y1, z1, x2, y2, z2, x3, y3, z3] in [mm]. Each triplet represents the midpoint of one of the three orthogonal box edges originating from the center. Together, these points define an orthogonal basis that encodes the box’s orientation and size. The distance from the center to each midpoint equals half of the corresponding edge length. This representation supports arbitrary orientations, including left-handed coordinate systems used by robot controllers. "
+    )
+    __properties: ClassVar[List[str]] = ["center", "neighbour"]
+
+    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 SafetyGeometryBox 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 SafetyGeometryBox from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"center": obj.get("center"), "neighbour": obj.get("neighbour")})
+        return _obj

wandelbots_api_client/v2/models/safety_geometry_capsule.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, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class SafetyGeometryCapsule(BaseModel):
+    """
+    Capsule shape defined by two axis endpoints and a radius.
+    """  # noqa: E501
+
+    top: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="Top endpoint of the capsule axis as Vector3 [x, y, z] in [mm]."
+    )
+    bottom: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="Bottom endpoint of the capsule axis as Vector3 [x, y, z] in [mm]."
+    )
+    radius: Union[StrictFloat, StrictInt] = Field(description="Radius of the capsule in [mm].")
+    __properties: ClassVar[List[str]] = ["top", "bottom", "radius"]
+
+    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 SafetyGeometryCapsule 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 SafetyGeometryCapsule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"top": obj.get("top"), "bottom": obj.get("bottom"), "radius": obj.get("radius")})
+        return _obj

wandelbots_api_client/v2/models/safety_geometry_lozenge.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, Union
+from wandelbots_api_client.v2.models.safety_zone_pose import SafetyZonePose
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class SafetyGeometryLozenge(BaseModel):
+    """
+    Lozenge shape defined by a center pose, two dimensions, and a corner radius.
+    """  # noqa: E501
+
+    center: SafetyZonePose = Field(description="Center pose of the lozenge (position and quaternion orientation).")
+    x_dimension: Union[StrictFloat, StrictInt] = Field(description="Dimension in x-direction in [mm].")
+    y_dimension: Union[StrictFloat, StrictInt] = Field(description="Dimension in y-direction in [mm].")
+    radius: Union[StrictFloat, StrictInt] = Field(description="Corner radius in [mm].")
+    __properties: ClassVar[List[str]] = ["center", "x_dimension", "y_dimension", "radius"]
+
+    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 SafetyGeometryLozenge 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 center
+        if self.center:
+            _dict["center"] = self.center.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SafetyGeometryLozenge from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "center": SafetyZonePose.from_dict(obj["center"]) if obj.get("center") is not None else None,
+                "x_dimension": obj.get("x_dimension"),
+                "y_dimension": obj.get("y_dimension"),
+                "radius": obj.get("radius"),
+            }
+        )
+        return _obj