wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/v2/models/robot_controller_configuration_request.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: 2.3.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
+from typing import Any, ClassVar, Dict, List
+from wandelbots_api_client.v2.models.network_device import NetworkDevice
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RobotControllerConfigurationRequest(BaseModel):
+    """
+    Information to generate all robot controller configurations that match a given ARP scan result.
+    """  # noqa: E501
+
+    ip: StrictStr = Field(description="The IPv4 address assigned to the network interface where the ARP scan was performed. ")
+    network_devices: List[NetworkDevice] = Field(description="Array of network devices.")
+    __properties: ClassVar[List[str]] = ["ip", "network_devices"]
+
+    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 RobotControllerConfigurationRequest 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 network_devices (list)
+        _items = []
+        if self.network_devices:
+            for _item_network_devices in self.network_devices:
+                if _item_network_devices:
+                    _items.append(_item_network_devices.to_dict())
+            _dict["network_devices"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RobotControllerConfigurationRequest 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"),
+                "network_devices": [NetworkDevice.from_dict(_item) for _item in obj["network_devices"]]
+                if obj.get("network_devices") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/robot_controller_state.py

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.motion_group_state import MotionGroupState
+from wandelbots_api_client.v2.models.operation_mode import OperationMode
+from wandelbots_api_client.v2.models.robot_system_mode import RobotSystemMode
+from wandelbots_api_client.v2.models.safety_state_type import SafetyStateType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RobotControllerState(BaseModel):
+    """
+    Returns the whole current state of robot controller.
+    """  # noqa: E501
+
+    mode: RobotSystemMode = Field(description="Mode of communication and control between NOVA and the robot controller.")
+    last_error: Optional[List[StrictStr]] = Field(
+        default=None,
+        description="Last error stack encountered during initialization process or after a controller disconnect. At this stage, it's unclear whether the error is fatal.  Evaluate `last_error` to decide whether to remove the controller using `deleteController`. Examples: - Delete required: Host resolution fails repeatedly due to an incorrect IP. - Delete not required: Temporary network delay caused a disconnect; the system will auto-reconnect. ",
+    )
+    timestamp: datetime = Field(description="Timestamp indicating when the represented information was received from the robot controller.")
+    sequence_number: Annotated[int, Field(le=4294967295, strict=True, ge=0)] = Field(
+        description="Sequence number of the controller state. It starts with 0 upon establishing the connection with a physical controller. The sequence number is reset when the connection to the physical controller is closed and re-established. "
+    )
+    controller: StrictStr = Field(description="Identifier of the configured robot controller.")
+    operation_mode: OperationMode
+    safety_state: SafetyStateType
+    velocity_override: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = Field(
+        default=None,
+        description="If made available by the robot controller, returns the current velocity override in [percentage] for movements adjusted on robot control panel. Valid value range: 1 - 100. ",
+    )
+    motion_groups: List[MotionGroupState] = Field(
+        description="State of indicated motion groups. In case of state request via controller all configured motion groups are returned. In case of executing a motion only the affected motion groups are returned. "
+    )
+    __properties: ClassVar[List[str]] = [
+        "mode",
+        "last_error",
+        "timestamp",
+        "sequence_number",
+        "controller",
+        "operation_mode",
+        "safety_state",
+        "velocity_override",
+        "motion_groups",
+    ]
+
+    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 RobotControllerState 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 motion_groups (list)
+        _items = []
+        if self.motion_groups:
+            for _item_motion_groups in self.motion_groups:
+                if _item_motion_groups:
+                    _items.append(_item_motion_groups.to_dict())
+            _dict["motion_groups"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RobotControllerState 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"),
+                "last_error": obj.get("last_error"),
+                "timestamp": obj.get("timestamp"),
+                "sequence_number": obj.get("sequence_number"),
+                "controller": obj.get("controller") if obj.get("controller") is not None else "controller",
+                "operation_mode": obj.get("operation_mode"),
+                "safety_state": obj.get("safety_state"),
+                "velocity_override": obj.get("velocity_override"),
+                "motion_groups": [MotionGroupState.from_dict(_item) for _item in obj["motion_groups"]]
+                if obj.get("motion_groups") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/robot_system_mode.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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 RobotSystemMode(str, Enum):
+    """
+    Defines the current system mode of the robot system, including NOVA communicating with the robot controller.  ### MODE_CONTROLLER_NOT_CONFIGURED  No controller with the specified identifier is configured. Call [addRobotController](#/operations/addRobotController) to register a controller.  ### MODE_INITIALIZING  Indicates that a connection to the robot controller is established or reestablished in case of a disconnect. On success, the controller is set to MODE_MONITOR. On failure, the initialization process is retried until successful or cancelled by the user.  ### MODE_MONITOR  Read-only mode with an active controller connection. - Receives robot state and I/O signals - Move requests are rejected - No commands are sent to the controller  ### MODE_CONTROL  Active control mode.  **Movement is possible in this mode**  The robot is cyclically commanded to hold its current position. The robot state is received in sync with the controller cycle. Motion and jogging requests are accepted and executed. Input/Output interaction is enabled.  ### MODE_FREE_DRIVE  Read-only mode with servo motors enabled for manual movement (Free Drive).  Move requests are rejected.  Not supported by all robots: Use [getSupportedModes](#/operations/getSupportedModes) to check Free Drive availability.
+    """
+
+    """
+    allowed enum values
+    """
+    MODE_CONTROLLER_NOT_CONFIGURED = "MODE_CONTROLLER_NOT_CONFIGURED"
+    MODE_INITIALIZING = "MODE_INITIALIZING"
+    MODE_MONITOR = "MODE_MONITOR"
+    MODE_CONTROL = "MODE_CONTROL"
+    MODE_FREE_DRIVE = "MODE_FREE_DRIVE"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of RobotSystemMode from a JSON string"""
+        return cls(json.loads(json_str))

wandelbots_api_client/v2/models/robot_tcp.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.flange_payload import FlangePayload
+from wandelbots_api_client.v2.models.orientation_type import OrientationType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RobotTcp(BaseModel):
+    """
+    RobotTcp
+    """  # noqa: E501
+
+    name: Optional[StrictStr] = Field(default=None, description="A readable and changeable name for frontend visualization.")
+    position: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="A three-dimensional vector [x, y, z] with double precision. "
+    )
+    orientation: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=4)]] = Field(
+        default=None,
+        description="Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. ",
+    )
+    orientation_type: Optional[OrientationType] = OrientationType.ROTATION_VECTOR
+    payload: Optional[FlangePayload] = None
+    id: StrictStr = Field(description="Identifier of this tcp.")
+    __properties: ClassVar[List[str]] = ["name", "position", "orientation", "orientation_type", "payload", "id"]
+
+    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 RobotTcp 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 payload
+        if self.payload:
+            _dict["payload"] = self.payload.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RobotTcp 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"),
+                "position": obj.get("position"),
+                "orientation": obj.get("orientation"),
+                "orientation_type": obj.get("orientation_type")
+                if obj.get("orientation_type") is not None
+                else OrientationType.ROTATION_VECTOR,
+                "payload": FlangePayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+                "id": obj.get("id"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/robot_tcp_data.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: 2.3.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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.flange_payload import FlangePayload
+from wandelbots_api_client.v2.models.orientation_type import OrientationType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class RobotTcpData(BaseModel):
+    """
+    RobotTcpData
+    """  # noqa: E501
+
+    name: Optional[StrictStr] = Field(default=None, description="A readable and changeable name for frontend visualization.")
+    position: Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)] = Field(
+        description="A three-dimensional vector [x, y, z] with double precision. "
+    )
+    orientation: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=4)]] = Field(
+        default=None,
+        description="Describes an orientation in 3D space. A tree-to-four-dimensional vector [x, y, z, w] with double precision. ",
+    )
+    orientation_type: Optional[OrientationType] = OrientationType.ROTATION_VECTOR
+    payload: Optional[FlangePayload] = None
+    __properties: ClassVar[List[str]] = ["name", "position", "orientation", "orientation_type", "payload"]
+
+    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 RobotTcpData 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 payload
+        if self.payload:
+            _dict["payload"] = self.payload.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RobotTcpData 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"),
+                "position": obj.get("position"),
+                "orientation": obj.get("orientation"),
+                "orientation_type": obj.get("orientation_type")
+                if obj.get("orientation_type") is not None
+                else OrientationType.ROTATION_VECTOR,
+                "payload": FlangePayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/rrt_connect_algorithm.py

@@ -0,0 +1,127 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.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, 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 RRTConnectAlgorithm(BaseModel):
+    """
+    RRTConnectAlgorithm
+    """  # noqa: E501
+
+    algorithm_name: StrictStr = Field(
+        description="Algorithm discriminator.  RRT Connect algorithm configuration for collision-free path planning. Rapidly-exploring Random Trees (RRT) builds trees of valid configurations by randomly sampling the joint space and connecting feasible points with JointPTP motions. RRT Connect grows two trees simultaneously from start and target positions until they meet. This is a custom implementation optimized for manipulator kinematics and collision checking in industrial contexts. "
+    )
+    max_iterations: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(
+        default=10000,
+        description="Maximum number of iterations for the RRT Connect algorithm. Higher values increase likelihood of success, but also computation time. ",
+    )
+    max_step_size: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=1, description="Maximum step size for tree extension in joint space."
+    )
+    adaptive_step_size: Optional[StrictBool] = Field(
+        default=True, description="Adjust the maximum step size during the search based on the recent success rate of tree expansion."
+    )
+    apply_smoothing: Optional[StrictBool] = Field(
+        default=True,
+        description="Apply smoothing after the search has succeeded. This will remove as many intermediate points as possible while keeping the path valid.",
+    )
+    apply_blending: Optional[StrictBool] = Field(
+        default=True,
+        description="Apply blending after the search has succeeded and smoothing has been applied. This will apply the largest viable blending at each intermediate point.",
+    )
+    __properties: ClassVar[List[str]] = [
+        "algorithm_name",
+        "max_iterations",
+        "max_step_size",
+        "adaptive_step_size",
+        "apply_smoothing",
+        "apply_blending",
+    ]
+
+    @field_validator("algorithm_name")
+    def algorithm_name_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["RRTConnectAlgorithm"]):
+            raise ValueError("must be one of enum values ('RRTConnectAlgorithm')")
+        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 RRTConnectAlgorithm 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 RRTConnectAlgorithm from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "algorithm_name": obj.get("algorithm_name"),
+                "max_iterations": obj.get("max_iterations") if obj.get("max_iterations") is not None else 10000,
+                "max_step_size": obj.get("max_step_size") if obj.get("max_step_size") is not None else 1,
+                "adaptive_step_size": obj.get("adaptive_step_size") if obj.get("adaptive_step_size") is not None else True,
+                "apply_smoothing": obj.get("apply_smoothing") if obj.get("apply_smoothing") is not None else True,
+                "apply_blending": obj.get("apply_blending") if obj.get("apply_blending") is not None else True,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/safety_state_type.py

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 2.3.0 dev
+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 SafetyStateType(str, Enum):
+    """
+    Current safety state of the configured robot controller. Operation modes in which the attached motion groups can be moved are: - SAFETY_STATE_NORMAL - SAFETY_STATE_REDUCED All other modes are considered as non-operational.
+    """
+
+    """
+    allowed enum values
+    """
+    SAFETY_STATE_UNKNOWN = "SAFETY_STATE_UNKNOWN"
+    SAFETY_STATE_FAULT = "SAFETY_STATE_FAULT"
+    SAFETY_STATE_NORMAL = "SAFETY_STATE_NORMAL"
+    SAFETY_STATE_MASTERING = "SAFETY_STATE_MASTERING"
+    SAFETY_STATE_CONFIRM_SAFETY = "SAFETY_STATE_CONFIRM_SAFETY"
+    SAFETY_STATE_OPERATOR_SAFETY = "SAFETY_STATE_OPERATOR_SAFETY"
+    SAFETY_STATE_PROTECTIVE_STOP = "SAFETY_STATE_PROTECTIVE_STOP"
+    SAFETY_STATE_REDUCED = "SAFETY_STATE_REDUCED"
+    SAFETY_STATE_STOP = "SAFETY_STATE_STOP"
+    SAFETY_STATE_STOP_0 = "SAFETY_STATE_STOP_0"
+    SAFETY_STATE_STOP_1 = "SAFETY_STATE_STOP_1"
+    SAFETY_STATE_STOP_2 = "SAFETY_STATE_STOP_2"
+    SAFETY_STATE_RECOVERY = "SAFETY_STATE_RECOVERY"
+    SAFETY_STATE_DEVICE_EMERGENCY_STOP = "SAFETY_STATE_DEVICE_EMERGENCY_STOP"
+    SAFETY_STATE_ROBOT_EMERGENCY_STOP = "SAFETY_STATE_ROBOT_EMERGENCY_STOP"
+    SAFETY_STATE_VIOLATION = "SAFETY_STATE_VIOLATION"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of SafetyStateType from a JSON string"""
+        return cls(json.loads(json_str))