wandelbots-api-client 25.9.0.dev2__py3-none-any.whl → 25.10.0.dev47__py3-none-any.whl

wandelbots_api_client/v2/models/blending_position.py

@@ -26,8 +26,8 @@ class BlendingPosition(BaseModel):
     """
     BlendingPosition
     """ # noqa: E501
-    position_zone_radius: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Specifies the maximum radius in [mm] around the motion command's target point where the TCP path can be altered to blend the motion command into the following one. If auto-blending blends too much of the resulting trajectory, use position-blending to restrict the blending zone radius. ")
-    blending_name: StrictStr
+    position_zone_radius: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Specifies the maximum radius in [mm] around the motion command's target point where the TCP path can be altered to blend the motion command into the following one. If auto-blending blends too much of the resulting trajectory, use position-blending to restrict the blending zone radius. ") 
+    blending_name: str = "BlendingPosition"
     __properties: ClassVar[List[str]] = ["position_zone_radius", "blending_name"]
 
     @field_validator('blending_name')

wandelbots_api_client/v2/models/boolean_value.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,16 +26,13 @@ class BooleanValue(BaseModel):
     """
     Value of a digital input/output. 
     """ # noqa: E501
-    value: StrictBool
-    value_type: Optional[StrictStr] = 'boolean'
+    value: StrictBool 
+    value_type: str = "boolean"
     __properties: ClassVar[List[str]] = ["value", "value_type"]
 
     @field_validator('value_type')
     def value_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value is None:
-            return value
-
         if value not in set(['boolean']):
             raise ValueError("must be one of enum values ('boolean')")
         return value
@@ -96,7 +93,7 @@ class BooleanValue(BaseModel):
 
         _obj = cls.model_validate({
             "value": obj.get("value"),
-            "value_type": obj.get("value_type") if obj.get("value_type") is not None else 'boolean'
+            "value_type": obj.get("value_type")
         })
         return _obj
 

wandelbots_api_client/v2/models/box.py

@@ -26,11 +26,11 @@ class Box(BaseModel):
     """
     Defines a cuboid shape centred around an origin.  If a margin is applied to the box type full, it is added to all size values. The shape will keep its edges. The hollow box type consists of thin boxes that make up its walls. If a margin is applied to the box type hollow, its size values are reduced by the margin. 
     """ # noqa: E501
-    shape_type: StrictStr
-    size_x: Union[StrictFloat, StrictInt] = Field(description="The dimension in x-direction in [mm].")
-    size_y: Union[StrictFloat, StrictInt] = Field(description="The dimension in y-direction in [mm].")
-    size_z: Union[StrictFloat, StrictInt] = Field(description="The dimension in z-direction in [mm].")
-    box_type: StrictStr = Field(description="The box type defines if the box is hollow or full.")
+    shape_type: str = "box"
+    size_x: Union[StrictFloat, StrictInt] = Field(description="The dimension in x-direction in [mm].") 
+    size_y: Union[StrictFloat, StrictInt] = Field(description="The dimension in y-direction in [mm].") 
+    size_z: Union[StrictFloat, StrictInt] = Field(description="The dimension in z-direction in [mm].") 
+    box_type: StrictStr = Field(description="The box type defines if the box is hollow or full.") 
     __properties: ClassVar[List[str]] = ["shape_type", "size_x", "size_y", "size_z", "box_type"]
 
     @field_validator('shape_type')

wandelbots_api_client/v2/models/{io_description2.py → bus_io_description.py}

@@ -19,24 +19,24 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from wandelbots_api_client.v2.models.io_description_min import IODescriptionMin
+from wandelbots_api_client.v2.models.io_boundary import IOBoundary
 from wandelbots_api_client.v2.models.io_direction import IODirection
 from wandelbots_api_client.v2.models.io_value_type import IOValueType
 from wandelbots_api_client.v2.models.unit_type import UnitType
 from typing import Optional, Set
 from typing_extensions import Self
 
-class IODescription2(BaseModel):
+class BusIODescription(BaseModel):
     """
-    IODescription2
+    BusIODescription
     """ # noqa: E501
-    io: StrictStr = Field(description="Unique identifier of the input/output. ")
-    name: StrictStr = Field(description="Name of the input/output. Customize it using the respective BUS service, e.g. [addProfinetIO](addProfinetIO) for PROFINET service. ")
-    direction: IODirection
-    value_type: IOValueType
-    unit: Optional[UnitType] = None
-    min: Optional[IODescriptionMin] = None
-    max: Optional[IODescriptionMin] = None
+    io: StrictStr = Field(description="Unique identifier of the input/output. ") 
+    name: StrictStr = Field(description="Name of the input/output. Customize it using the respective BUS service, e.g., [addProfinetIO](addProfinetIO) for PROFINET service. ") 
+    direction: IODirection 
+    value_type: IOValueType 
+    unit: Optional[UnitType] = None 
+    min: Optional[IOBoundary] = None 
+    max: Optional[IOBoundary] = None 
     __properties: ClassVar[List[str]] = ["io", "name", "direction", "value_type", "unit", "min", "max"]
 
     model_config = ConfigDict(
@@ -61,7 +61,7 @@ class IODescription2(BaseModel):
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of IODescription2 from a JSON string"""
+        """Create an instance of BusIODescription from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
     def to_dict(self) -> Dict[str, Any]:
@@ -92,7 +92,7 @@ class IODescription2(BaseModel):
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of IODescription2 from a dict"""
+        """Create an instance of BusIODescription from a dict"""
         if obj is None:
             return None
 
@@ -105,8 +105,8 @@ class IODescription2(BaseModel):
             "direction": obj.get("direction"),
             "value_type": obj.get("value_type"),
             "unit": obj.get("unit"),
-            "min": IODescriptionMin.from_dict(obj["min"]) if obj.get("min") is not None else None,
-            "max": IODescriptionMin.from_dict(obj["max"]) if obj.get("max") is not None else None
+            "min": IOBoundary.from_dict(obj["min"]) if obj.get("min") is not None else None,
+            "max": IOBoundary.from_dict(obj["max"]) if obj.get("max") is not None else None
         })
         return _obj
 

wandelbots_api_client/v2/models/bus_io_modbus_client.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Wandelbots NOVA API
+
+    Interact with robots in an easy and intuitive way.  > **Note:** API version 2 is experimental and will experience functional changes. 
+
+    The version of the OpenAPI document: 2.0.0 beta
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from wandelbots_api_client.v2.models.bus_io_modbus_tcp_client import BusIOModbusTCPClient
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BusIOModbusClient(BaseModel):
+    """
+    MODBUS client inputs/outputs service configuration. 
+    """ # noqa: E501
+    bus_type: str = "modbus_client"
+    network: BusIOModbusTCPClient 
+    __properties: ClassVar[List[str]] = ["bus_type", "network"]
+
+    @field_validator('bus_type')
+    def bus_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['modbus_client']):
+            raise ValueError("must be one of enum values ('modbus_client')")
+        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 BusIOModbusClient 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 network
+        if self.network:
+            _dict['network'] = self.network.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BusIOModbusClient from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bus_type": obj.get("bus_type"),
+            "network": BusIOModbusTCPClient.from_dict(obj["network"]) if obj.get("network") is not None else None
+        })
+        return _obj
+
+

wandelbots_api_client/v2/models/bus_io_modbus_server.py

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+    Wandelbots NOVA API
+
+    Interact with robots in an easy and intuitive way.  > **Note:** API version 2 is experimental and will experience functional changes. 
+
+    The version of the OpenAPI document: 2.0.0 beta
+    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 typing_extensions import Annotated
+from wandelbots_api_client.v2.models.bus_io_modbus_tcp_server import BusIOModbusTCPServer
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BusIOModbusServer(BaseModel):
+    """
+    MODBUS server inputs/outputs service configuration. 
+    """ # noqa: E501
+    bus_type: str = "modbus_server"
+    network: BusIOModbusTCPServer 
+    connections: Annotated[int, Field(le=255, strict=True, ge=0)] = Field(description="Number of connections this MODBUS server can handle. ") 
+    coils_size: Annotated[int, Field(le=65535, strict=True, ge=0)] = Field(description="Size of the Coils memory area. ") 
+    discrete_inputs_size: Annotated[int, Field(le=65535, strict=True, ge=0)] = Field(description="Size of the Discrete Inputs memory area. ") 
+    holding_registers_size: Annotated[int, Field(le=65535, strict=True, ge=0)] = Field(description="Size of the Holding Registers memory area. ") 
+    input_registers_size: Annotated[int, Field(le=65535, strict=True, ge=0)] = Field(description="Size of the Input Registers memory area. ") 
+    __properties: ClassVar[List[str]] = ["bus_type", "network", "connections", "coils_size", "discrete_inputs_size", "holding_registers_size", "input_registers_size"]
+
+    @field_validator('bus_type')
+    def bus_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['modbus_server']):
+            raise ValueError("must be one of enum values ('modbus_server')")
+        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 BusIOModbusServer 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 network
+        if self.network:
+            _dict['network'] = self.network.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of BusIOModbusServer from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bus_type": obj.get("bus_type"),
+            "network": BusIOModbusTCPServer.from_dict(obj["network"]) if obj.get("network") is not None else None,
+            "connections": obj.get("connections"),
+            "coils_size": obj.get("coils_size"),
+            "discrete_inputs_size": obj.get("discrete_inputs_size"),
+            "holding_registers_size": obj.get("holding_registers_size"),
+            "input_registers_size": obj.get("input_registers_size")
+        })
+        return _obj
+
+

wandelbots_api_client/v2/models/bus_io_modbus_tcp_client.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    Wandelbots NOVA API
+
+    Interact with robots in an easy and intuitive way.  > **Note:** API version 2 is experimental and will experience functional changes. 
+
+    The version of the OpenAPI document: 2.0.0 beta
+    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, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BusIOModbusTCPClient(BaseModel):
+    """
+    BusIOModbusTCPClient
+    """ # noqa: E501
+    network_type: str = "tcp"
+    ip: StrictStr = Field(description="IP address of the MODBUS server to establish communication with. ") 
+    port: Annotated[int, Field(le=65534, strict=True, ge=1)] = Field(description="Port number of the MODBUS server to establish communication with. ") 
+    __properties: ClassVar[List[str]] = ["network_type", "ip", "port"]
+
+    @field_validator('network_type')
+    def network_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['tcp']):
+            raise ValueError("must be one of enum values ('tcp')")
+        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 BusIOModbusTCPClient 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 BusIOModbusTCPClient from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "network_type": obj.get("network_type"),
+            "ip": obj.get("ip"),
+            "port": obj.get("port")
+        })
+        return _obj
+
+

wandelbots_api_client/v2/models/bus_io_modbus_tcp_server.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    Wandelbots NOVA API
+
+    Interact with robots in an easy and intuitive way.  > **Note:** API version 2 is experimental and will experience functional changes. 
+
+    The version of the OpenAPI document: 2.0.0 beta
+    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, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BusIOModbusTCPServer(BaseModel):
+    """
+    BusIOModbusTCPServer
+    """ # noqa: E501
+    network_type: str = "tcp"
+    port: Annotated[int, Field(le=65534, strict=True, ge=1)] = Field(description="Port number of the MODBUS server to establish communication with. ") 
+    __properties: ClassVar[List[str]] = ["network_type", "port"]
+
+    @field_validator('network_type')
+    def network_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['tcp']):
+            raise ValueError("must be one of enum values ('tcp')")
+        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 BusIOModbusTCPServer 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 BusIOModbusTCPServer from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "network_type": obj.get("network_type"),
+            "port": obj.get("port")
+        })
+        return _obj
+
+

wandelbots_api_client/v2/models/bus_io_modbus_virtual.py

@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+    Wandelbots NOVA API
+
+    Interact with robots in an easy and intuitive way.  > **Note:** API version 2 is experimental and will experience functional changes. 
+
+    The version of the OpenAPI document: 2.0.0 beta
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BusIOModbusVirtual(BaseModel):
+    """
+    Virtual MODBUS inputs/outputs service configuration. 
+    """ # noqa: E501
+    bus_type: str = "modbus_virtual"
+    __properties: ClassVar[List[str]] = ["bus_type"]
+
+    @field_validator('bus_type')
+    def bus_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['modbus_virtual']):
+            raise ValueError("must be one of enum values ('modbus_virtual')")
+        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 BusIOModbusVirtual 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 BusIOModbusVirtual from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bus_type": obj.get("bus_type")
+        })
+        return _obj
+
+