wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/v2/models/collision_contact.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, 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 CollisionContact(BaseModel):
+    """
+    CollisionContact
+    """  # noqa: E501
+
+    local: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)]] = Field(
+        default=None, description="A three-dimensional vector [x, y, z] with double precision. "
+    )
+    root: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)]] = Field(
+        default=None, description="A three-dimensional vector [x, y, z] with double precision. "
+    )
+    __properties: ClassVar[List[str]] = ["local", "root"]
+
+    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 CollisionContact 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 CollisionContact from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"local": obj.get("local"), "root": obj.get("root")})
+        return _obj

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

wandelbots_api_client/v2/models/collision_free_algorithm.py

@@ -0,0 +1,164 @@
+# 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 json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from wandelbots_api_client.v2.models.midpoint_insertion_algorithm import MidpointInsertionAlgorithm
+from wandelbots_api_client.v2.models.rrt_connect_algorithm import RRTConnectAlgorithm
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+COLLISIONFREEALGORITHM_ONE_OF_SCHEMAS = ["MidpointInsertionAlgorithm", "RRTConnectAlgorithm"]
+
+
+class CollisionFreeAlgorithm(BaseModel):
+    """
+    Configuration for collision-free path planning algorithms. Different algorithms may have different parameters and behavior.  Recommendation: - For **cells with many obstacles**, use the RRTConnect algorithm. Use it as a starting point. - For **simple cells with very few obstacles** and when a faster solution is needed, try the MidpointInsertion algorithm.
+    """
+
+    # data type: RRTConnectAlgorithm
+    oneof_schema_1_validator: Optional[RRTConnectAlgorithm] = None
+    # data type: MidpointInsertionAlgorithm
+    oneof_schema_2_validator: Optional[MidpointInsertionAlgorithm] = None
+    actual_instance: Optional[Union[MidpointInsertionAlgorithm, RRTConnectAlgorithm]] = None
+    one_of_schemas: Set[str] = {"MidpointInsertionAlgorithm", "RRTConnectAlgorithm"}
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    discriminator_value_class_map: Dict[str, str] = {}
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator("actual_instance")
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = CollisionFreeAlgorithm.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: RRTConnectAlgorithm
+        if not isinstance(v, RRTConnectAlgorithm):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `RRTConnectAlgorithm`")
+        else:
+            match += 1
+        # validate data type: MidpointInsertionAlgorithm
+        if not isinstance(v, MidpointInsertionAlgorithm):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `MidpointInsertionAlgorithm`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError(
+                "Multiple matches found when setting `actual_instance` in CollisionFreeAlgorithm with oneOf schemas: MidpointInsertionAlgorithm, RRTConnectAlgorithm. Details: "
+                + ", ".join(error_messages)
+            )
+        elif match == 0:
+            # no match
+            raise ValueError(
+                "No match found when setting `actual_instance` in CollisionFreeAlgorithm with oneOf schemas: MidpointInsertionAlgorithm, RRTConnectAlgorithm. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # use oneOf discriminator to lookup the data type
+        _data_type = json.loads(json_str).get("algorithm_name")
+        if not _data_type:
+            raise ValueError("Failed to lookup data type from the field `algorithm_name` in the input.")
+
+        # check if data type is `MidpointInsertionAlgorithm`
+        if _data_type == "MidpointInsertionAlgorithm":
+            instance.actual_instance = MidpointInsertionAlgorithm.from_json(json_str)
+            return instance
+
+        # check if data type is `RRTConnectAlgorithm`
+        if _data_type == "RRTConnectAlgorithm":
+            instance.actual_instance = RRTConnectAlgorithm.from_json(json_str)
+            return instance
+
+        # deserialize data into RRTConnectAlgorithm
+        try:
+            instance.actual_instance = RRTConnectAlgorithm.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into MidpointInsertionAlgorithm
+        try:
+            instance.actual_instance = MidpointInsertionAlgorithm.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError(
+                "Multiple matches found when deserializing the JSON string into CollisionFreeAlgorithm with oneOf schemas: MidpointInsertionAlgorithm, RRTConnectAlgorithm. Details: "
+                + ", ".join(error_messages)
+            )
+        elif match == 0:
+            # no match
+            raise ValueError(
+                "No match found when deserializing the JSON string into CollisionFreeAlgorithm with oneOf schemas: MidpointInsertionAlgorithm, RRTConnectAlgorithm. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], MidpointInsertionAlgorithm, RRTConnectAlgorithm]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())

wandelbots_api_client/v2/models/collision_motion_group.py

@@ -0,0 +1,119 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.v2.models.collider import Collider
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class CollisionMotionGroup(BaseModel):
+    """
+    CollisionMotionGroup
+    """  # noqa: E501
+
+    link_chain: Optional[List[Dict[str, Collider]]] = Field(
+        default=None,
+        description="The shape of the motion groups links to validate against colliders. Indexed along the kinematic chain, starting with a static base shape before first joint. The base of the motion group is not checked for collision against the environment. ",
+    )
+    tool: Optional[Dict[str, Collider]] = Field(default=None, description="Shape of the tool to validate against colliders. ")
+    self_collision_detection: Optional[StrictBool] = Field(
+        default=True,
+        description="If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true. ",
+    )
+    __properties: ClassVar[List[str]] = ["link_chain", "tool", "self_collision_detection"]
+
+    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 CollisionMotionGroup 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 link_chain (list of dict)
+        _items = []
+        if self.link_chain:
+            for _item_link_chain in self.link_chain:
+                if _item_link_chain:
+                    _items.append({_inner_key: _inner_value.to_dict() for _inner_key, _inner_value in _item_link_chain.items()})
+            _dict["link_chain"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in tool (dict)
+        _field_dict = {}
+        if self.tool:
+            for _key_tool in self.tool:
+                if self.tool[_key_tool]:
+                    _field_dict[_key_tool] = self.tool[_key_tool].to_dict()
+            _dict["tool"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionMotionGroup from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "link_chain": [
+                    {_inner_key: Collider.from_dict(_inner_value) for _inner_key, _inner_value in _item.items()}
+                    for _item in obj["link_chain"]
+                ]
+                if obj.get("link_chain") is not None
+                else None,
+                "tool": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["tool"].items()) if obj.get("tool") is not None else None,
+                "self_collision_detection": obj.get("self_collision_detection")
+                if obj.get("self_collision_detection") is not None
+                else True,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/collision_setup.py

@@ -0,0 +1,130 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.v2.models.collider import Collider
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class CollisionSetup(BaseModel):
+    """
+    CollisionSetup
+    """  # noqa: E501
+
+    colliders: Optional[Dict[str, Collider]] = Field(default=None, description="Colliders are checked against links and tool. ")
+    link_chain: Optional[List[Dict[str, Collider]]] = Field(
+        default=None,
+        description="The shape of the motion groups links to validate against colliders. Indexed along the kinematic chain, starting with a static base shape before first joint. The base of the motion group is not checked for collision against the environment. ",
+    )
+    tool: Optional[Dict[str, Collider]] = Field(default=None, description="Shape of the tool to validate against colliders. ")
+    self_collision_detection: Optional[StrictBool] = Field(
+        default=True,
+        description="If true, self-collision detection is enabled for the motion group.  Self-collision detection checks if links in the kinematic chain of the motion group collide with each other. Adjacent links in the kinematic chain of the motion group are not checked for mutual collision. The tool is treated like a link at the end of the kinematic chain. It is checked against all links except the last one.  Default is true. ",
+    )
+    __properties: ClassVar[List[str]] = ["colliders", "link_chain", "tool", "self_collision_detection"]
+
+    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 CollisionSetup 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 value in colliders (dict)
+        _field_dict = {}
+        if self.colliders:
+            for _key_colliders in self.colliders:
+                if self.colliders[_key_colliders]:
+                    _field_dict[_key_colliders] = self.colliders[_key_colliders].to_dict()
+            _dict["colliders"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each item in link_chain (list of dict)
+        _items = []
+        if self.link_chain:
+            for _item_link_chain in self.link_chain:
+                if _item_link_chain:
+                    _items.append({_inner_key: _inner_value.to_dict() for _inner_key, _inner_value in _item_link_chain.items()})
+            _dict["link_chain"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in tool (dict)
+        _field_dict = {}
+        if self.tool:
+            for _key_tool in self.tool:
+                if self.tool[_key_tool]:
+                    _field_dict[_key_tool] = self.tool[_key_tool].to_dict()
+            _dict["tool"] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CollisionSetup from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "colliders": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["colliders"].items())
+                if obj.get("colliders") is not None
+                else None,
+                "link_chain": [
+                    {_inner_key: Collider.from_dict(_inner_value) for _inner_key, _inner_value in _item.items()}
+                    for _item in obj["link_chain"]
+                ]
+                if obj.get("link_chain") is not None
+                else None,
+                "tool": dict((_k, Collider.from_dict(_v)) for _k, _v in obj["tool"].items()) if obj.get("tool") is not None else None,
+                "self_collision_detection": obj.get("self_collision_detection")
+                if obj.get("self_collision_detection") is not None
+                else True,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/comparator.py

@@ -0,0 +1,38 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class Comparator(str, Enum):
+    """
+    Comparator for the comparison of two values. The comparator is used to compare two values and return a boolean result. The default comparator is unknown.
+    """
+
+    """
+    allowed enum values
+    """
+    COMPARATOR_EQUALS = "COMPARATOR_EQUALS"
+    COMPARATOR_NOT_EQUALS = "COMPARATOR_NOT_EQUALS"
+    COMPARATOR_GREATER = "COMPARATOR_GREATER"
+    COMPARATOR_GREATER_EQUAL = "COMPARATOR_GREATER_EQUAL"
+    COMPARATOR_LESS = "COMPARATOR_LESS"
+    COMPARATOR_LESS_EQUAL = "COMPARATOR_LESS_EQUAL"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of Comparator from a JSON string"""
+        return cls(json.loads(json_str))