wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/v2/models/initialize_movement_response.py

@@ -0,0 +1,107 @@
+# 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, Optional
+from wandelbots_api_client.v2.models.add_trajectory_error import AddTrajectoryError
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class InitializeMovementResponse(BaseModel):
+    """
+    Response for InitializeMovementRequest message.
+    """  # noqa: E501
+
+    message: Optional[StrictStr] = Field(default=None, description="Error message in case of invalid InitializeMovementRequest.")
+    add_trajectory_error: Optional[AddTrajectoryError] = Field(
+        default=None,
+        description="Error can occur if joint trajectory was added by InitializeMovementRequest and the trajectory is invalid. ",
+    )
+    kind: StrictStr
+    __properties: ClassVar[List[str]] = ["message", "add_trajectory_error", "kind"]
+
+    @field_validator("kind")
+    def kind_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["INITIALIZE_RECEIVED"]):
+            raise ValueError("must be one of enum values ('INITIALIZE_RECEIVED')")
+        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 InitializeMovementResponse 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 add_trajectory_error
+        if self.add_trajectory_error:
+            _dict["add_trajectory_error"] = self.add_trajectory_error.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InitializeMovementResponse 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"),
+                "add_trajectory_error": AddTrajectoryError.from_dict(obj["add_trajectory_error"])
+                if obj.get("add_trajectory_error") is not None
+                else None,
+                "kind": obj.get("kind"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/integer_value.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, 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 IntegerValue(BaseModel):
+    """
+    Value of an input/output with integer representation.  > The integral value is transmitted as a string to avoid precision loss during conversion to JSON. > Recommended: Use int64 in your implementation. If you want to interact with int64 in numbers, > JS bigint libraries can help you to parse the string into an integral value.
+    """  # noqa: E501
+
+    value: StrictStr
+    value_type: StrictStr
+    __properties: ClassVar[List[str]] = ["value", "value_type"]
+
+    @field_validator("value_type")
+    def value_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["integer"]):
+            raise ValueError("must be one of enum values ('integer')")
+        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 IntegerValue 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 IntegerValue from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"value": obj.get("value"), "value_type": obj.get("value_type")})
+        return _obj

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

wandelbots_api_client/v2/models/invalid_dof_error_invalid_dof.py

@@ -0,0 +1,86 @@
+# 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 InvalidDofErrorInvalidDof(BaseModel):
+    """
+    InvalidDofErrorInvalidDof
+    """  # noqa: E501
+
+    valid_dof: Optional[StrictInt] = Field(default=None, description="The valid degrees of freedom for the motion group. ")
+    joint_position: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None, description="The joint position that is out of its limits."
+    )
+    __properties: ClassVar[List[str]] = ["valid_dof", "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 InvalidDofErrorInvalidDof 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 InvalidDofErrorInvalidDof from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"valid_dof": obj.get("valid_dof"), "joint_position": obj.get("joint_position")})
+        return _obj

wandelbots_api_client/v2/models/inverse_kinematics422_response.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 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, Optional
+from wandelbots_api_client.v2.models.inverse_kinematics_validation_error import InverseKinematicsValidationError
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class InverseKinematics422Response(BaseModel):
+    """
+    InverseKinematics422Response
+    """  # noqa: E501
+
+    detail: Optional[List[InverseKinematicsValidationError]] = None
+    __properties: ClassVar[List[str]] = ["detail"]
+
+    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 InverseKinematics422Response 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 detail (list)
+        _items = []
+        if self.detail:
+            for _item_detail in self.detail:
+                if _item_detail:
+                    _items.append(_item_detail.to_dict())
+            _dict["detail"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InverseKinematics422Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "detail": [InverseKinematicsValidationError.from_dict(_item) for _item in obj["detail"]]
+                if obj.get("detail") is not None
+                else None
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/inverse_kinematics_request.py

@@ -0,0 +1,152 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from wandelbots_api_client.v2.models.collision_setup import CollisionSetup
+from wandelbots_api_client.v2.models.limit_range import LimitRange
+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 InverseKinematicsRequest(BaseModel):
+    """
+    InverseKinematicsRequest
+    """  # noqa: E501
+
+    motion_group_model: StrictStr = Field(
+        description="Identifies a single motion group model. See [getMotionGroupModels](#/operations/getMotionGroupModels) for supported types. "
+    )
+    tcp_poses: List[Pose] = Field(description="List of TCP poses for which the inverse solutions are computed. ")
+    tcp_offset: Optional[Pose] = None
+    mounting: Optional[Pose] = Field(default=None, description="Offset from the world frame to the motion group base.")
+    joint_position_limits: Optional[List[LimitRange]] = Field(
+        default=None,
+        description="Joint position limits, indexed starting from base. The unit depends on the type of joint: For revolute joints, the limit is given in [rad]; for prismatic joints, it is given in [mm]. ",
+    )
+    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. ",
+    )
+    reference_joint_position: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None,
+        description="If present, all solutions are shifted to the same periodicity as the reference: Each individual joint angle is shifted by integer multiples of 2 pi (whole revolutions) until it's as close to the reference as possible. The solutions are sorted by ascending distance (L2 norm) from the reference. ",
+    )
+    __properties: ClassVar[List[str]] = [
+        "motion_group_model",
+        "tcp_poses",
+        "tcp_offset",
+        "mounting",
+        "joint_position_limits",
+        "collision_setups",
+        "reference_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 InverseKinematicsRequest 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 tcp_poses (list)
+        _items = []
+        if self.tcp_poses:
+            for _item_tcp_poses in self.tcp_poses:
+                if _item_tcp_poses:
+                    _items.append(_item_tcp_poses.to_dict())
+            _dict["tcp_poses"] = _items
+        # 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 mounting
+        if self.mounting:
+            _dict["mounting"] = self.mounting.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in joint_position_limits (list)
+        _items = []
+        if self.joint_position_limits:
+            for _item_joint_position_limits in self.joint_position_limits:
+                if _item_joint_position_limits:
+                    _items.append(_item_joint_position_limits.to_dict())
+            _dict["joint_position_limits"] = _items
+        # 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 InverseKinematicsRequest 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"),
+                "tcp_poses": [Pose.from_dict(_item) for _item in obj["tcp_poses"]] if obj.get("tcp_poses") is not None else None,
+                "tcp_offset": Pose.from_dict(obj["tcp_offset"]) if obj.get("tcp_offset") is not None else None,
+                "mounting": Pose.from_dict(obj["mounting"]) if obj.get("mounting") is not None else None,
+                "joint_position_limits": [LimitRange.from_dict(_item) for _item in obj["joint_position_limits"]]
+                if obj.get("joint_position_limits") 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,
+                "reference_joint_position": obj.get("reference_joint_position"),
+            }
+        )
+        return _obj