wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/v2/models/profinet_io_data.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: 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, Optional
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.profinet_io_direction import ProfinetIODirection
+from wandelbots_api_client.v2.models.profinet_io_type_enum import ProfinetIOTypeEnum
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ProfinetIOData(BaseModel):
+    """
+    ProfinetIOData
+    """  # noqa: E501
+
+    description: StrictStr = Field(description="Descriptive name or note for the input/output variable. ")
+    type: ProfinetIOTypeEnum
+    direction: ProfinetIODirection = Field(
+        description="The direction of the input/output variable, indicating whether it is an input or output for the PROFINET device, e.g., NOVA's PROFINET service. "
+    )
+    byte_address: Annotated[int, Field(le=65535, strict=True, ge=0)] = Field(
+        description="The byte address in the PROFINET device's process image, with offset 0. The slot is automatically determined based on this address and the configured slot layout.  For example, with two slots of 64 bytes each: - Bytes 0-63: Slot 1 - Bytes 64-127: Slot 2  When importing from a tag table, e.g., TIA Portal, use `input_offset`/`output_offset` to convert global PLC addresses to device-local addresses: `device_byte_address` = `plc_byte_address` - offset "
+    )
+    bit_address: Optional[Annotated[int, Field(le=7, strict=True, ge=0)]] = Field(
+        default=None,
+        description="The bit offset within the byte specified by `byte_address`. Only relevant for boolean/bit-type variables. Valid values are 0-7 (8 bits per byte). For byte/word/dword types, this field is typically omitted or set to 0. ",
+    )
+    __properties: ClassVar[List[str]] = ["description", "type", "direction", "byte_address", "bit_address"]
+
+    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 ProfinetIOData 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 ProfinetIOData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "description": obj.get("description"),
+                "type": obj.get("type"),
+                "direction": obj.get("direction"),
+                "byte_address": obj.get("byte_address"),
+                "bit_address": obj.get("bit_address"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/profinet_io_direction.py

@@ -0,0 +1,35 @@
+# 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 ProfinetIODirection(str, Enum):
+    """
+    The direction of the input/output variable, indicating whether it is an input or output for the PROFINET device, e.g., NOVA's PROFINET service.
+    """
+
+    """
+    allowed enum values
+    """
+    PROFINET_IO_DIRECTION_INPUT = "PROFINET_IO_DIRECTION_INPUT"
+    PROFINET_IO_DIRECTION_OUTPUT = "PROFINET_IO_DIRECTION_OUTPUT"
+    PROFINET_IO_DIRECTION_INOUT = "PROFINET_IO_DIRECTION_INOUT"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ProfinetIODirection from a JSON string"""
+        return cls(json.loads(json_str))

wandelbots_api_client/v2/models/profinet_io_type_enum.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 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 ProfinetIOTypeEnum(str, Enum):
+    """
+    Value type of the PROFINET input/output variable. Is used to interpret the corresponding bits correctly.
+    """
+
+    """
+    allowed enum values
+    """
+    PROFINET_IO_TYPE_UNKNOWN = "PROFINET_IO_TYPE_UNKNOWN"
+    PROFINET_IO_TYPE_BOOL = "PROFINET_IO_TYPE_BOOL"
+    PROFINET_IO_TYPE_USINT = "PROFINET_IO_TYPE_USINT"
+    PROFINET_IO_TYPE_SINT = "PROFINET_IO_TYPE_SINT"
+    PROFINET_IO_TYPE_UINT = "PROFINET_IO_TYPE_UINT"
+    PROFINET_IO_TYPE_INT = "PROFINET_IO_TYPE_INT"
+    PROFINET_IO_TYPE_UDINT = "PROFINET_IO_TYPE_UDINT"
+    PROFINET_IO_TYPE_DINT = "PROFINET_IO_TYPE_DINT"
+    PROFINET_IO_TYPE_REAL = "PROFINET_IO_TYPE_REAL"
+    PROFINET_IO_TYPE_LREAL = "PROFINET_IO_TYPE_LREAL"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ProfinetIOTypeEnum from a JSON string"""
+        return cls(json.loads(json_str))

wandelbots_api_client/v2/models/profinet_slot_description.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 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 typing_extensions import Annotated
+from wandelbots_api_client.v2.models.profinet_sub_slot_description import ProfinetSubSlotDescription
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ProfinetSlotDescription(BaseModel):
+    """
+    An array of PROFINET slots.  PROFINET models each device’s input/output hardware as a hierarchy of slots (modules) and subslots (submodules). A slot can represent a physical or virtual input/output card and each subslot one of its individual channels or functions. Every slot and subslot has unique identifiers that the controller uses to map cyclic input/output data and parameter records to its process image. This slot/subslot separation enables e.g., addressing each input/output stream when establishing input/output application relations (I/O-AR).
+    """  # noqa: E501
+
+    number: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="The number/index of the PROFINET slot. Per default, slot 0 is reserved for the device access point (DAP). Slots that are part of the cyclic input/output data exchange start at number 1. "
+    )
+    api: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="The application process identifier (API) number of the PROFINET input. The API identifies the application relation (AR) that is using the slot. "
+    )
+    subslots: List[ProfinetSubSlotDescription] = Field(description="An array of PROFINET subslots. ")
+    __properties: ClassVar[List[str]] = ["number", "api", "subslots"]
+
+    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 ProfinetSlotDescription 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 subslots (list)
+        _items = []
+        if self.subslots:
+            for _item_subslots in self.subslots:
+                if _item_subslots:
+                    _items.append(_item_subslots.to_dict())
+            _dict["subslots"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProfinetSlotDescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "number": obj.get("number"),
+                "api": obj.get("api"),
+                "subslots": [ProfinetSubSlotDescription.from_dict(_item) for _item in obj["subslots"]]
+                if obj.get("subslots") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/profinet_sub_slot_description.py

@@ -0,0 +1,92 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ProfinetSubSlotDescription(BaseModel):
+    """
+    ProfinetSubSlotDescription
+    """  # noqa: E501
+
+    number: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(description="The number/index of the PROFINET subslot. ")
+    input_length: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="The amount of bytes allocated for the subslot in the input process image buffer. "
+    )
+    output_length: Annotated[int, Field(le=2147483647, strict=True, ge=0)] = Field(
+        description="The amount of bytes allocated for the subslot in the output process image buffer. "
+    )
+    __properties: ClassVar[List[str]] = ["number", "input_length", "output_length"]
+
+    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 ProfinetSubSlotDescription 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 ProfinetSubSlotDescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"number": obj.get("number"), "input_length": obj.get("input_length"), "output_length": obj.get("output_length")}
+        )
+        return _obj

wandelbots_api_client/v2/models/program.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: 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, 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
+from pydantic_core import to_jsonable_python
+
+
+class Program(BaseModel):
+    """
+    A program is a collection of instructions that are executed in the robot cell.
+    """  # noqa: E501
+
+    program: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
+    name: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    app: StrictStr
+    input_schema: Optional[Dict[str, Any]] = None
+    preconditions: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[List[str]] = ["program", "name", "description", "app", "input_schema", "preconditions"]
+
+    @field_validator("program")
+    def program_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z0-9_-]+$", value):
+            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9_-]+$/")
+        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 Program 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 Program from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "program": obj.get("program"),
+                "name": obj.get("name"),
+                "description": obj.get("description"),
+                "app": obj.get("app"),
+                "input_schema": obj.get("input_schema"),
+                "preconditions": obj.get("preconditions"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/program_run.py

@@ -0,0 +1,124 @@
+# 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 wandelbots_api_client.v2.models.program_run_state import ProgramRunState
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ProgramRun(BaseModel):
+    """
+    Holds the state of a program run.
+    """  # noqa: E501
+
+    run: StrictStr = Field(description="Unique identifier of the program run")
+    program: StrictStr = Field(description="Unique identifier of the program")
+    app: Optional[StrictStr] = Field(default=None, description="Identifier of the app that produced the program run")
+    state: ProgramRunState = Field(description="State of the program run")
+    logs: Optional[StrictStr] = Field(default=None, description="Logs of the program run")
+    stdout: Optional[StrictStr] = Field(default=None, description="Stdout of the program run")
+    stderr: Optional[StrictStr] = Field(default=None, description="Stderr of the program run")
+    error: Optional[StrictStr] = Field(default=None, description="Error message of the program run, if any")
+    traceback: Optional[StrictStr] = Field(default=None, description="Traceback of the program run, if any")
+    start_time: Optional[datetime] = Field(default=None, description="Start time of the program run in RFC3339 format")
+    end_time: Optional[datetime] = Field(default=None, description="End time of the program run in RFC3339 format")
+    input_data: Optional[Dict[str, Any]] = Field(default=None, description="Input data of the program run")
+    __properties: ClassVar[List[str]] = [
+        "run",
+        "program",
+        "app",
+        "state",
+        "logs",
+        "stdout",
+        "stderr",
+        "error",
+        "traceback",
+        "start_time",
+        "end_time",
+        "input_data",
+    ]
+
+    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 ProgramRun 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 ProgramRun from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "run": obj.get("run"),
+                "program": obj.get("program"),
+                "app": obj.get("app"),
+                "state": obj.get("state"),
+                "logs": obj.get("logs"),
+                "stdout": obj.get("stdout"),
+                "stderr": obj.get("stderr"),
+                "error": obj.get("error"),
+                "traceback": obj.get("traceback"),
+                "start_time": obj.get("start_time"),
+                "end_time": obj.get("end_time"),
+                "input_data": obj.get("input_data"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/program_run_state.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 ProgramRunState(str, Enum):
+    """
+    The state of a program run.
+    """
+
+    """
+    allowed enum values
+    """
+    PREPARING = "PREPARING"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    STOPPED = "STOPPED"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ProgramRunState from a JSON string"""
+        return cls(json.loads(json_str))