wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/models/feedback_out_of_workspace.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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.models.pose2 import Pose2
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class FeedbackOutOfWorkspace(BaseModel):
+    """
+    Requested TCP pose is outside of motion group's workspace.
+    """  # noqa: E501
+
+    invalid_tcp_pose: Optional[Pose2] = None
+    error_feedback_name: str = "FeedbackOutOfWorkspace"
+    __properties: ClassVar[List[str]] = ["invalid_tcp_pose", "error_feedback_name"]
+
+    @field_validator("error_feedback_name")
+    def error_feedback_name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["FeedbackOutOfWorkspace"]):
+            raise ValueError("must be one of enum values ('FeedbackOutOfWorkspace')")
+        return value
+
+    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 FeedbackOutOfWorkspace 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_tcp_pose
+        if self.invalid_tcp_pose:
+            _dict["invalid_tcp_pose"] = self.invalid_tcp_pose.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FeedbackOutOfWorkspace from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "invalid_tcp_pose": Pose2.from_dict(obj["invalid_tcp_pose"]) if obj.get("invalid_tcp_pose") is not None else None,
+                "error_feedback_name": obj.get("error_feedback_name"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/feedback_singularity.py

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from wandelbots_api_client.models.singularity_type_enum import SingularityTypeEnum
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class FeedbackSingularity(BaseModel):
+    """
+    A singularity is a point in the robot's workspace where the robot loses one or more degrees of freedom with regards to moving its TCP. This means the robot cannot move or rotate the TCP in a certain direction from this specific point.  Use PTP motions if possible. They will almost never fail due to singularities (only if the target point is at a singularity).  Alternatively change the robot TCP's path to avoid moving through this point or try to move the TCP through this point in a different direction.
+    """  # noqa: E501
+
+    singularity_type: Optional[SingularityTypeEnum] = None
+    singular_joint_position: Optional[List[Union[StrictFloat, StrictInt]]] = None
+    error_feedback_name: str = "FeedbackSingularity"
+    __properties: ClassVar[List[str]] = ["singularity_type", "singular_joint_position", "error_feedback_name"]
+
+    @field_validator("error_feedback_name")
+    def error_feedback_name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["FeedbackSingularity"]):
+            raise ValueError("must be one of enum values ('FeedbackSingularity')")
+        return value
+
+    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 FeedbackSingularity 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 FeedbackSingularity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "singularity_type": obj.get("singularity_type"),
+                "singular_joint_position": obj.get("singular_joint_position"),
+                "error_feedback_name": obj.get("error_feedback_name"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/flag.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: 1.4.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, StrictBool
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class Flag(BaseModel):
+    """
+    Flag
+    """  # noqa: E501
+
+    active: StrictBool
+    __properties: ClassVar[List[str]] = ["active"]
+
+    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 Flag 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 Flag from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"active": obj.get("active")})
+        return _obj

wandelbots_api_client/models/force_vector.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.vector3d import Vector3d
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class ForceVector(BaseModel):
+    """
+    Representing a force on a specific point in operational space (e.g. on robot flange).
+    """  # noqa: E501
+
+    force: Optional[Vector3d] = None
+    moment: Optional[Vector3d] = None
+    coordinate_system: Optional[StrictStr] = Field(
+        default=None, description="optional, unique name of base coordinate system, if empty world is used"
+    )
+    __properties: ClassVar[List[str]] = ["force", "moment", "coordinate_system"]
+
+    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 ForceVector 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 force
+        if self.force:
+            _dict["force"] = self.force.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of moment
+        if self.moment:
+            _dict["moment"] = self.moment.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ForceVector from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "force": Vector3d.from_dict(obj["force"]) if obj.get("force") is not None else None,
+                "moment": Vector3d.from_dict(obj["moment"]) if obj.get("moment") is not None else None,
+                "coordinate_system": obj.get("coordinate_system"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/geometry.py

@@ -0,0 +1,167 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.box import Box
+from wandelbots_api_client.models.capsule import Capsule
+from wandelbots_api_client.models.convex_hull import ConvexHull
+from wandelbots_api_client.models.cylinder import Cylinder
+from wandelbots_api_client.models.planner_pose import PlannerPose
+from wandelbots_api_client.models.rectangle import Rectangle
+from wandelbots_api_client.models.rectangular_capsule import RectangularCapsule
+from wandelbots_api_client.models.sphere import Sphere
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class Geometry(BaseModel):
+    """
+    A Geometry is defined by a shape and a pose.
+    """  # noqa: E501
+
+    sphere: Optional[Sphere] = None
+    box: Optional[Box] = None
+    rectangle: Optional[Rectangle] = None
+    plane: Optional[Dict[str, Any]] = Field(default=None, description="Defines an x-y plane with infinite size.")
+    cylinder: Optional[Cylinder] = None
+    convex_hull: Optional[ConvexHull] = None
+    capsule: Optional[Capsule] = None
+    rectangular_capsule: Optional[RectangularCapsule] = None
+    compound: Optional[Compound] = None
+    init_pose: PlannerPose
+    id: Optional[StrictStr] = Field(
+        default=None, description="An identifier may be used to refer to this geometry, e.g. when giving feedback."
+    )
+    __properties: ClassVar[List[str]] = [
+        "sphere",
+        "box",
+        "rectangle",
+        "plane",
+        "cylinder",
+        "convex_hull",
+        "capsule",
+        "rectangular_capsule",
+        "compound",
+        "init_pose",
+        "id",
+    ]
+
+    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 Geometry 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 box
+        if self.box:
+            _dict["box"] = self.box.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of rectangle
+        if self.rectangle:
+            _dict["rectangle"] = self.rectangle.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of cylinder
+        if self.cylinder:
+            _dict["cylinder"] = self.cylinder.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of convex_hull
+        if self.convex_hull:
+            _dict["convex_hull"] = self.convex_hull.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 rectangular_capsule
+        if self.rectangular_capsule:
+            _dict["rectangular_capsule"] = self.rectangular_capsule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of compound
+        if self.compound:
+            _dict["compound"] = self.compound.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of init_pose
+        if self.init_pose:
+            _dict["init_pose"] = self.init_pose.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Geometry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "sphere": Sphere.from_dict(obj["sphere"]) if obj.get("sphere") is not None else None,
+                "box": Box.from_dict(obj["box"]) if obj.get("box") is not None else None,
+                "rectangle": Rectangle.from_dict(obj["rectangle"]) if obj.get("rectangle") is not None else None,
+                "plane": obj.get("plane"),
+                "cylinder": Cylinder.from_dict(obj["cylinder"]) if obj.get("cylinder") is not None else None,
+                "convex_hull": ConvexHull.from_dict(obj["convex_hull"]) if obj.get("convex_hull") is not None else None,
+                "capsule": Capsule.from_dict(obj["capsule"]) if obj.get("capsule") is not None else None,
+                "rectangular_capsule": RectangularCapsule.from_dict(obj["rectangular_capsule"])
+                if obj.get("rectangular_capsule") is not None
+                else None,
+                "compound": Compound.from_dict(obj["compound"]) if obj.get("compound") is not None else None,
+                "init_pose": PlannerPose.from_dict(obj["init_pose"]) if obj.get("init_pose") is not None else None,
+                "id": obj.get("id"),
+            }
+        )
+        return _obj
+
+
+from wandelbots_api_client.models.compound import Compound
+
+# TODO: Rewrite to not use raise_errors
+Geometry.model_rebuild(raise_errors=False)

wandelbots_api_client/models/get_all_program_runs200_response.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
+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.models.program_run_object import ProgramRunObject
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class GetAllProgramRuns200Response(BaseModel):
+    """
+    GetAllProgramRuns200Response
+    """  # noqa: E501
+
+    program_runs: Optional[List[ProgramRunObject]] = None
+    __properties: ClassVar[List[str]] = ["program_runs"]
+
+    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 GetAllProgramRuns200Response 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 program_runs (list)
+        _items = []
+        if self.program_runs:
+            for _item in self.program_runs:
+                # >>> 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["program_runs"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of GetAllProgramRuns200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "program_runs": [
+                    # >>> 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
+                    ProgramRunObject.from_dict(_item) if hasattr(ProgramRunObject, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["program_runs"]
+                ]
+                if obj.get("program_runs") is not None
+                else None
+            }
+        )
+        return _obj