wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/models/cell.py

@@ -0,0 +1,142 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from wandelbots_api_client.models.app import App
+from wandelbots_api_client.models.robot_controller import RobotController
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class Cell(BaseModel):
+    """
+    To create a robot cell, only a valid name is required. Once created, a robot cell provides access to the Wandelbots NOVA foundation services. The configuration can be customized, e.g. robot controllers, also within apps.
+    """  # noqa: E501
+
+    name: Annotated[str, Field(strict=True)] = Field(
+        description="A unique name for the cell used as an identifier for addressing the cell in all API calls. It must be a valid k8s label name as defined by [RFC 1123](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-label-names). "
+    )
+    controllers: Optional[List[RobotController]] = None
+    apps: Optional[List[App]] = None
+    __properties: ClassVar[List[str]] = ["name", "controllers", "apps"]
+
+    @field_validator("name")
+    def name_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-z][a-z0-9-]{0,61}[a-z0-9]$", value):
+            raise ValueError(r"must validate the regular expression /^[a-z][a-z0-9-]{0,61}[a-z0-9]$/")
+        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 Cell 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 controllers (list)
+        _items = []
+        if self.controllers:
+            for _item in self.controllers:
+                # >>> 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["controllers"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in apps (list)
+        _items = []
+        if self.apps:
+            for _item in self.apps:
+                # >>> 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["apps"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Cell 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"),
+                "controllers": [
+                    # >>> 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
+                    RobotController.from_dict(_item) if hasattr(RobotController, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["controllers"]
+                ]
+                if obj.get("controllers") is not None
+                else None,
+                "apps": [
+                    # >>> 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
+                    App.from_dict(_item) if hasattr(App, "from_dict") else _item
+                    # <<< End modification
+                    for _item in obj["apps"]
+                ]
+                if obj.get("apps") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/circle.py

@@ -0,0 +1,99 @@
+# 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
+from wandelbots_api_client.models.pose import Pose
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class Circle(BaseModel):
+    """
+    Circle
+    """  # noqa: E501
+
+    via_pose: Pose
+    target_pose: Pose
+    __properties: ClassVar[List[str]] = ["via_pose", "target_pose"]
+
+    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 Circle 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 via_pose
+        if self.via_pose:
+            _dict["via_pose"] = self.via_pose.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of target_pose
+        if self.target_pose:
+            _dict["target_pose"] = self.target_pose.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Circle from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "via_pose": Pose.from_dict(obj["via_pose"]) if obj.get("via_pose") is not None else None,
+                "target_pose": Pose.from_dict(obj["target_pose"]) if obj.get("target_pose") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/code_with_arguments.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: 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.collection_value import CollectionValue
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class CodeWithArguments(BaseModel):
+    """
+    CodeWithArguments
+    """  # noqa: E501
+
+    code: StrictStr = Field(description="Wandelscript code string which describes a Wandelscript Program as content/json.")
+    initial_state: Optional[Dict[str, CollectionValue]] = None
+    __properties: ClassVar[List[str]] = ["code", "initial_state"]
+
+    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 CodeWithArguments 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 initial_state (dict)
+        # >>> Modified from openapi template
+        if self.initial_state:
+            _field_dict = {}
+            for _key, _value in self.initial_state.items():
+                if self.initial_state[_key]:
+                    _field_dict[_key] = _value.to_dict()
+            _dict["initial_state"] = _field_dict
+        # set to None if initial_state (nullable) is None
+        # and model_fields_set contains the field
+        if self.initial_state is None and "initial_state" in self.model_fields_set:
+            _dict["initial_state"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CodeWithArguments from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "code": obj.get("code"),
+                "initial_state": dict((_k, CollectionValue.from_dict(_v)) for _k, _v in obj["initial_state"].items())
+                if obj.get("initial_state") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/collection_value.py

@@ -0,0 +1,322 @@
+# 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
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+from pydantic import BaseModel, ConfigDict, Field, StrictBytes, StrictFloat, StrictInt, StrictStr, ValidationError, field_validator
+from typing import Optional, Tuple, Union
+from wandelbots_api_client.models.capture import Capture
+from wandelbots_api_client.models.point_cloud import PointCloud
+from wandelbots_api_client.models.pyjectory_datatypes_serializer_orientation import PyjectoryDatatypesSerializerOrientation
+from wandelbots_api_client.models.pyjectory_datatypes_serializer_pose import PyjectoryDatatypesSerializerPose
+from wandelbots_api_client.models.pyjectory_datatypes_serializer_position import PyjectoryDatatypesSerializerPosition
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+COLLECTIONVALUE_ANY_OF_SCHEMAS = [
+    "ArrayInput",
+    "Capture",
+    "PointCloud",
+    "PyjectoryDatatypesSerializerOrientation",
+    "PyjectoryDatatypesSerializerPose",
+    "PyjectoryDatatypesSerializerPosition",
+    "bytearray",
+    "float",
+    "int",
+    "str",
+]
+
+
+class CollectionValue(BaseModel):
+    """
+    CollectionValue
+    """
+
+    # data type: float
+    anyof_schema_1_validator: Optional[Union[StrictFloat, StrictInt]] = None
+    # data type: int
+    anyof_schema_2_validator: Optional[StrictInt] = None
+    # data type: str
+    anyof_schema_3_validator: Optional[StrictStr] = None
+    # data type: bytearray
+    anyof_schema_4_validator: Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]] = None
+    # data type: PyjectoryDatatypesSerializerPose
+    anyof_schema_5_validator: Optional[PyjectoryDatatypesSerializerPose] = None
+    # data type: PyjectoryDatatypesSerializerPosition
+    anyof_schema_6_validator: Optional[PyjectoryDatatypesSerializerPosition] = None
+    # data type: PyjectoryDatatypesSerializerOrientation
+    anyof_schema_7_validator: Optional[PyjectoryDatatypesSerializerOrientation] = None
+    # data type: Capture
+    anyof_schema_8_validator: Optional[Capture] = None
+    # data type: PointCloud
+    anyof_schema_9_validator: Optional[PointCloud] = None
+    # data type: ArrayInput
+    anyof_schema_10_validator: Optional[ArrayInput] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[
+            Union[
+                ArrayInput,
+                Capture,
+                PointCloud,
+                PyjectoryDatatypesSerializerOrientation,
+                PyjectoryDatatypesSerializerPose,
+                PyjectoryDatatypesSerializerPosition,
+                bytearray,
+                float,
+                int,
+                str,
+            ]
+        ] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = {
+        "ArrayInput",
+        "Capture",
+        "PointCloud",
+        "PyjectoryDatatypesSerializerOrientation",
+        "PyjectoryDatatypesSerializerPose",
+        "PyjectoryDatatypesSerializerPosition",
+        "bytearray",
+        "float",
+        "int",
+        "str",
+    }
+
+    model_config = {
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    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_anyof(cls, v):
+        instance = CollectionValue.model_construct()
+        error_messages = []
+        # validate data type: float
+        try:
+            instance.anyof_schema_1_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: int
+        try:
+            instance.anyof_schema_2_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: str
+        try:
+            instance.anyof_schema_3_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: bytearray
+        try:
+            instance.anyof_schema_4_validator = v
+            return v
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # validate data type: PyjectoryDatatypesSerializerPose
+        if not isinstance(v, PyjectoryDatatypesSerializerPose):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PyjectoryDatatypesSerializerPose`")
+        else:
+            return v
+
+        # validate data type: PyjectoryDatatypesSerializerPosition
+        if not isinstance(v, PyjectoryDatatypesSerializerPosition):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PyjectoryDatatypesSerializerPosition`")
+        else:
+            return v
+
+        # validate data type: PyjectoryDatatypesSerializerOrientation
+        if not isinstance(v, PyjectoryDatatypesSerializerOrientation):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PyjectoryDatatypesSerializerOrientation`")
+        else:
+            return v
+
+        # validate data type: Capture
+        if not isinstance(v, Capture):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `Capture`")
+        else:
+            return v
+
+        # validate data type: PointCloud
+        if not isinstance(v, PointCloud):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `PointCloud`")
+        else:
+            return v
+
+        # validate data type: ArrayInput
+        if not isinstance(v, ArrayInput):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `ArrayInput`")
+        else:
+            return v
+
+        if error_messages:
+            # no match
+            raise ValueError(
+                "No match found when setting the actual_instance in CollectionValue with anyOf schemas: ArrayInput, Capture, PointCloud, PyjectoryDatatypesSerializerOrientation, PyjectoryDatatypesSerializerPose, PyjectoryDatatypesSerializerPosition, bytearray, float, int, str. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: 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 = []
+        # deserialize data into float
+        try:
+            # validation
+            instance.anyof_schema_1_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_1_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into int
+        try:
+            # validation
+            instance.anyof_schema_2_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_2_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into str
+        try:
+            # validation
+            instance.anyof_schema_3_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_3_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into bytearray
+        try:
+            # validation
+            instance.anyof_schema_4_validator = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.anyof_schema_4_validator
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_5_validator: Optional[PyjectoryDatatypesSerializerPose] = None
+        try:
+            instance.actual_instance = PyjectoryDatatypesSerializerPose.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_6_validator: Optional[PyjectoryDatatypesSerializerPosition] = None
+        try:
+            instance.actual_instance = PyjectoryDatatypesSerializerPosition.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_7_validator: Optional[PyjectoryDatatypesSerializerOrientation] = None
+        try:
+            instance.actual_instance = PyjectoryDatatypesSerializerOrientation.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_8_validator: Optional[Capture] = None
+        try:
+            instance.actual_instance = Capture.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_9_validator: Optional[PointCloud] = None
+        try:
+            instance.actual_instance = PointCloud.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_10_validator: Optional[ArrayInput] = None
+        try:
+            instance.actual_instance = ArrayInput.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if error_messages:
+            # no match
+            raise ValueError(
+                "No match found when deserializing the JSON string into CollectionValue with anyOf schemas: ArrayInput, Capture, PointCloud, PyjectoryDatatypesSerializerOrientation, PyjectoryDatatypesSerializerPose, PyjectoryDatatypesSerializerPosition, bytearray, float, int, str. 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],
+            ArrayInput,
+            Capture,
+            PointCloud,
+            PyjectoryDatatypesSerializerOrientation,
+            PyjectoryDatatypesSerializerPose,
+            PyjectoryDatatypesSerializerPosition,
+            bytearray,
+            float,
+            int,
+            str,
+        ]
+    ]:
+        """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:
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+
+from wandelbots_api_client.models.array_input import ArrayInput
+
+# TODO: Rewrite to not use raise_errors
+CollectionValue.model_rebuild(raise_errors=False)