wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/models/io.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class IO(BaseModel):
+    """
+    IO
+    """  # noqa: E501
+
+    name: StrictStr
+    direction: StrictStr
+    bool: Optional[StrictBool] = None
+    integer: Optional[StrictStr] = None
+    double: Optional[Union[StrictFloat, StrictInt]] = None
+    __properties: ClassVar[List[str]] = ["name", "direction", "bool", "integer", "double"]
+
+    @field_validator("direction")
+    def direction_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["ControllerIn", "ControllerOut"]):
+            raise ValueError("must be one of enum values ('ControllerIn', 'ControllerOut')")
+        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 IO 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 IO 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"),
+                "direction": obj.get("direction"),
+                "bool": obj.get("bool"),
+                "integer": obj.get("integer"),
+                "double": obj.get("double"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/io_description.py

@@ -0,0 +1,156 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from wandelbots_api_client.models.io_value import IOValue
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class IODescription(BaseModel):
+    """
+    IODescription
+    """  # noqa: E501
+
+    id: StrictStr = Field(
+        description="Unique identifier defined by the controller. Identifiers are only defined uniquely per controller, e.g. I/Os for two different robots on the same controller can have the same identifier."
+    )
+    name: StrictStr = Field(description="Name of the I/O. Customize it on the physical controller or in the virtual robot specification.")
+    group: Optional[StrictStr] = Field(
+        default=None, description="Name of the I/O group. Customize it on the physical controller or in the virtual robot specification."
+    )
+    type: StrictStr = Field(description='Identifies the I/O type. Possible responses "input" or "output".')
+    value_type: StrictStr = Field(description="Data type of the I/O.")
+    bit_size: StrictInt = Field(description="OBSOLETE! Replaced by min/max. Amount of bits the value is encoded in.")
+    unit: Optional[StrictStr] = Field(default=None, description="The unit of I/O value.")
+    min: Optional[IOValue] = None
+    max: Optional[IOValue] = None
+    __properties: ClassVar[List[str]] = ["id", "name", "group", "type", "value_type", "bit_size", "unit", "min", "max"]
+
+    @field_validator("type")
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["IO_TYPE_INPUT", "IO_TYPE_OUTPUT"]):
+            raise ValueError("must be one of enum values ('IO_TYPE_INPUT', 'IO_TYPE_OUTPUT')")
+        return value
+
+    @field_validator("value_type")
+    def value_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["IO_VALUE_DIGITAL", "IO_VALUE_ANALOG_FLOATING", "IO_VALUE_ANALOG_INTEGER"]):
+            raise ValueError("must be one of enum values ('IO_VALUE_DIGITAL', 'IO_VALUE_ANALOG_FLOATING', 'IO_VALUE_ANALOG_INTEGER')")
+        return value
+
+    @field_validator("unit")
+    def unit_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(
+            [
+                "UNIT_NONE",
+                "UNIT_KILOGRAM",
+                "UNIT_AMPERE",
+                "UNIT_KELVIN",
+                "UNIT_HERTZ",
+                "UNIT_NEWTON",
+                "UNIT_VOLT",
+                "UNIT_CELSIUS",
+                "UNIT_NEWTON_METER",
+                "UNIT_METER",
+            ]
+        ):
+            raise ValueError(
+                "must be one of enum values ('UNIT_NONE', 'UNIT_KILOGRAM', 'UNIT_AMPERE', 'UNIT_KELVIN', 'UNIT_HERTZ', 'UNIT_NEWTON', 'UNIT_VOLT', 'UNIT_CELSIUS', 'UNIT_NEWTON_METER', 'UNIT_METER')"
+            )
+        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 IODescription 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 min
+        if self.min:
+            _dict["min"] = self.min.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of max
+        if self.max:
+            _dict["max"] = self.max.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of IODescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "id": obj.get("id"),
+                "name": obj.get("name"),
+                "group": obj.get("group"),
+                "type": obj.get("type"),
+                "value_type": obj.get("value_type"),
+                "bit_size": obj.get("bit_size"),
+                "unit": obj.get("unit"),
+                "min": IOValue.from_dict(obj["min"]) if obj.get("min") is not None else None,
+                "max": IOValue.from_dict(obj["max"]) if obj.get("max") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/models/io_value.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class IOValue(BaseModel):
+    """
+    I/O value representation. Depending on the I/O type, only one of the value fields will be set.
+    """  # noqa: E501
+
+    io: StrictStr = Field(description="Unique identifier of the I/O.")
+    boolean_value: Optional[StrictBool] = Field(
+        default=None, description="Value of a digital I/O. This field is only set if the I/O is of type IO_VALUE_DIGITAL. "
+    )
+    integer_value: Optional[StrictStr] = Field(
+        default=None,
+        description="Value of an analog I/O with integer representation. This field is only set if the I/O is of type IO_VALUE_ANALOG_INTEGER.  > The integral value is transmitted as a string to avoid precision loss in conversion to JSON. > We recommend to use int64 for implementation. If you want to interact with int64 in numbers, > there are some JS bigint libraries availible to parse the string into an integral value. ",
+    )
+    floating_value: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=None,
+        description="Value of an analog I/O with floating number representation. This field is only set if the I/O is of type IO_VALUE_ANALOG_FLOATING. ",
+    )
+    __properties: ClassVar[List[str]] = ["io", "boolean_value", "integer_value", "floating_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 IOValue 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 IOValue from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "io": obj.get("io"),
+                "boolean_value": obj.get("boolean_value"),
+                "integer_value": obj.get("integer_value"),
+                "floating_value": obj.get("floating_value"),
+            }
+        )
+        return _obj

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

wandelbots_api_client/models/jogging_response.py

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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
+from wandelbots_api_client.models.robot_controller_state import RobotControllerState
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class JoggingResponse(BaseModel):
+    """
+    A response for a Jogging Request, is streamed during an active Jogging Movement.
+    """  # noqa: E501
+
+    motion_group: StrictStr = Field(description="Identifier of the motion group.")
+    state: RobotControllerState
+    movement_state: StrictStr = Field(description="State of the current movement, e.g. ongoing or stopped due to a particular reason.")
+    __properties: ClassVar[List[str]] = ["motion_group", "state", "movement_state"]
+
+    @field_validator("movement_state")
+    def movement_state_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(
+            [
+                "MOVEMENT_STATE_UNKNOWN",
+                "MOVEMENT_STATE_ERROR",
+                "MOVEMENT_STATE_MOVING",
+                "MOVEMENT_STATE_STOP_BY_REQUEST",
+                "MOVEMENT_STATE_JOINT_LIMIT_REACHED",
+                "MOVEMENT_STATE_STOP_FOR_IO",
+                "MOVEMENT_STATE_STOP_FOR_FORCE_LIMIT",
+            ]
+        ):
+            raise ValueError(
+                "must be one of enum values ('MOVEMENT_STATE_UNKNOWN', 'MOVEMENT_STATE_ERROR', 'MOVEMENT_STATE_MOVING', 'MOVEMENT_STATE_STOP_BY_REQUEST', 'MOVEMENT_STATE_JOINT_LIMIT_REACHED', 'MOVEMENT_STATE_STOP_FOR_IO', 'MOVEMENT_STATE_STOP_FOR_FORCE_LIMIT')"
+            )
+        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 JoggingResponse 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 state
+        if self.state:
+            _dict["state"] = self.state.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of JoggingResponse 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": obj.get("motion_group"),
+                "state": RobotControllerState.from_dict(obj["state"]) if obj.get("state") is not None else None,
+                "movement_state": obj.get("movement_state"),
+            }
+        )
+        return _obj

wandelbots_api_client/models/jogging_service_capabilities.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 1.4.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, StrictBool
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class JoggingServiceCapabilities(BaseModel):
+    """
+    JoggingServiceCapabilities
+    """  # noqa: E501
+
+    joint_jogging: StrictBool = Field(description="Can this motion group be moved via joint jogging.")
+    cartesian_jogging: StrictBool = Field(description="Can this motion group be moved via cartesian jogging.")
+    __properties: ClassVar[List[str]] = ["joint_jogging", "cartesian_jogging"]
+
+    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 JoggingServiceCapabilities 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 JoggingServiceCapabilities from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"joint_jogging": obj.get("joint_jogging"), "cartesian_jogging": obj.get("cartesian_jogging")})
+        return _obj