wandelbots_api_client 26.3.0__py3-none-any.whl

wandelbots_api_client/v2/models/nan_value_error_nan_value.py

@@ -0,0 +1,85 @@
+# 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 import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class NanValueErrorNanValue(BaseModel):
+    """
+    Requested joint position contains NaN values.
+    """  # noqa: E501
+
+    joint_position: Optional[List[Union[StrictFloat, StrictInt]]] = Field(
+        default=None, description="The joint position that is out of its limits."
+    )
+    __properties: ClassVar[List[str]] = ["joint_position"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of NanValueErrorNanValue 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 NanValueErrorNanValue from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"joint_position": obj.get("joint_position")})
+        return _obj

wandelbots_api_client/v2/models/network_device.py

@@ -0,0 +1,85 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class NetworkDevice(BaseModel):
+    """
+    NetworkDevice
+    """  # noqa: E501
+
+    ip: StrictStr = Field(description="The IPv4 address assigned to the network device. ")
+    mac: StrictStr = Field(description="The MAC address of the network device. ")
+    vendor: Optional[StrictStr] = Field(default=None, description="The vendor of the network device. ")
+    __properties: ClassVar[List[str]] = ["ip", "mac", "vendor"]
+
+    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 NetworkDevice 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 NetworkDevice from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"ip": obj.get("ip"), "mac": obj.get("mac"), "vendor": obj.get("vendor")})
+        return _obj

wandelbots_api_client/v2/models/network_interface.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0
+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
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class NetworkInterface(BaseModel):
+    """
+    NetworkInterface
+    """  # noqa: E501
+
+    name: StrictStr = Field(description="The name of the network interface. ")
+    ip: StrictStr = Field(description="The IPv4 address assigned to the network interface. ")
+    mac: StrictStr = Field(description="The MAC address of the network interface. ")
+    cidr: StrictStr = Field(description='The CIDR notation of the network interface. Example: "192.168.1.0/24" ')
+    __properties: ClassVar[List[str]] = ["name", "ip", "mac", "cidr"]
+
+    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 NetworkInterface 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 NetworkInterface 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"), "ip": obj.get("ip"), "mac": obj.get("mac"), "cidr": obj.get("cidr")})
+        return _obj

wandelbots_api_client/v2/models/network_state.py

@@ -0,0 +1,125 @@
+# 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, StrictFloat, StrictInt, StrictStr, field_validator
+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 NetworkState(BaseModel):
+    """
+    NetworkState
+    """  # noqa: E501
+
+    internet_connected: StrictBool = Field(description="Indicates whether the system is connected to the internet. ")
+    connection_type: Optional[StrictStr] = Field(
+        default=None, description="Type of the active network link (e.g., ethernet, wifi, cellular, vpn, unknown). "
+    )
+    signal_strength: Optional[StrictInt] = Field(
+        default=None, description="Received signal strength in dBm for wireless interfaces; negative values indicate weaker signals. "
+    )
+    link_quality: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(
+        default=None, description="Normalized link quality metric from 0 (poor) to 1 (excellent) when provided by the interface. "
+    )
+    latency_ms: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=None, description="Round-trip latency to the probe endpoint measured in milliseconds. "
+    )
+    bandwidth_mbps: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=None, description="Estimated downstream bandwidth in megabits per second based on the probe. "
+    )
+    __properties: ClassVar[List[str]] = [
+        "internet_connected",
+        "connection_type",
+        "signal_strength",
+        "link_quality",
+        "latency_ms",
+        "bandwidth_mbps",
+    ]
+
+    @field_validator("connection_type")
+    def connection_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["ethernet", "wifi", "cellular", "vpn", "unknown"]):
+            raise ValueError("must be one of enum values ('ethernet', 'wifi', 'cellular', 'vpn', 'unknown')")
+        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 NetworkState 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 NetworkState from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "internet_connected": obj.get("internet_connected"),
+                "connection_type": obj.get("connection_type"),
+                "signal_strength": obj.get("signal_strength"),
+                "link_quality": obj.get("link_quality"),
+                "latency_ms": obj.get("latency_ms"),
+                "bandwidth_mbps": obj.get("bandwidth_mbps"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/op_mode.py

@@ -0,0 +1,84 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from wandelbots_api_client.v2.models.operation_mode import OperationMode
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class OpMode(BaseModel):
+    """
+    Controllers have two operating modes: AUTOMATIC and MANUAL. MANUAL mode is mainly used for teaching a robot application. To ensure safe operation the velocity of the robot is limited to 250 mm/s. Running the finished application is done in AUTOMATIC operating mode without the limited velocity of the MANUAL mode.
+    """  # noqa: E501
+
+    mode: OperationMode
+    __properties: ClassVar[List[str]] = ["mode"]
+
+    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 OpMode 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 OpMode from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"mode": obj.get("mode")})
+        return _obj

wandelbots_api_client/v2/models/operating_state.py

@@ -0,0 +1,34 @@
+# 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 OperatingState(str, Enum):
+    """
+    The operating state.
+    """
+
+    """
+    allowed enum values
+    """
+    ACTIVE = "ACTIVE"
+    INACTIVE = "INACTIVE"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of OperatingState from a JSON string"""
+        return cls(json.loads(json_str))

wandelbots_api_client/v2/models/operation_limits.py

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

wandelbots_api_client/v2/models/operation_mode.py

@@ -0,0 +1,42 @@
+# 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 OperationMode(str, Enum):
+    """
+    Current operation mode of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - OPERATION_MODE_MANUAL (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T1 (if enabling switch is pressed) - OPERATION_MODE_MANUAL_T2 (if enabling switch is pressed) - OPERATION_MODE_AUTO (without needing to press enabling switch) All other modes are considered as non-operational.
+    """
+
+    """
+    allowed enum values
+    """
+    OPERATION_MODE_UNKNOWN = "OPERATION_MODE_UNKNOWN"
+    OPERATION_MODE_NO_CONTROLLER = "OPERATION_MODE_NO_CONTROLLER"
+    OPERATION_MODE_DISCONNECTED = "OPERATION_MODE_DISCONNECTED"
+    OPERATION_MODE_POWER_ON = "OPERATION_MODE_POWER_ON"
+    OPERATION_MODE_PENDING = "OPERATION_MODE_PENDING"
+    OPERATION_MODE_MANUAL = "OPERATION_MODE_MANUAL"
+    OPERATION_MODE_MANUAL_T1 = "OPERATION_MODE_MANUAL_T1"
+    OPERATION_MODE_MANUAL_T2 = "OPERATION_MODE_MANUAL_T2"
+    OPERATION_MODE_AUTO = "OPERATION_MODE_AUTO"
+    OPERATION_MODE_RECOVERY = "OPERATION_MODE_RECOVERY"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of OperationMode from a JSON string"""
+        return cls(json.loads(json_str))