wandelbots_api_client 26.3.0.dev29__py3-none-any.whl

wandelbots_api_client/v2/models/container_image.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
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from wandelbots_api_client.v2.models.container_image_secrets_inner import ContainerImageSecretsInner
+from wandelbots_api_client.v2.models.image_credentials import ImageCredentials
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ContainerImage(BaseModel):
+    """
+    A user provided, custom container image and the required credentials to pull it from a registry.
+    """  # noqa: E501
+
+    image: Annotated[str, Field(min_length=1, strict=True)] = Field(
+        description="The location of a container image in the form of `<registry>/<image>:<tag>`."
+    )
+    credentials: Optional[ImageCredentials] = None
+    secrets: Optional[List[ContainerImageSecretsInner]] = Field(
+        default=None, description="Known secrets for authentication with the container registry."
+    )
+    __properties: ClassVar[List[str]] = ["image", "credentials", "secrets"]
+
+    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 ContainerImage 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 credentials
+        if self.credentials:
+            _dict["credentials"] = self.credentials.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in secrets (list)
+        _items = []
+        if self.secrets:
+            for _item_secrets in self.secrets:
+                if _item_secrets:
+                    _items.append(_item_secrets.to_dict())
+            _dict["secrets"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ContainerImage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "image": obj.get("image"),
+                "credentials": ImageCredentials.from_dict(obj["credentials"]) if obj.get("credentials") is not None else None,
+                "secrets": [ContainerImageSecretsInner.from_dict(_item) for _item in obj["secrets"]]
+                if obj.get("secrets") is not None
+                else None,
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/container_image_secrets_inner.py

@@ -0,0 +1,83 @@
+# 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, 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 ContainerImageSecretsInner(BaseModel):
+    """
+    ContainerImageSecretsInner
+    """  # noqa: E501
+
+    name: StrictStr
+    __properties: ClassVar[List[str]] = ["name"]
+
+    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 ContainerImageSecretsInner 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 ContainerImageSecretsInner 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")})
+        return _obj

wandelbots_api_client/v2/models/container_resources.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+Wandelbots NOVA API
+
+Interact with robots in an easy and intuitive way.
+
+The version of the OpenAPI document: 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ContainerResources(BaseModel):
+    """
+    Additional resources that the application requires.
+    """  # noqa: E501
+
+    intel_gpu: Optional[Annotated[int, Field(le=1, strict=True, ge=0)]] = Field(
+        default=None, description="Number of GPUs the application requires."
+    )
+    memory_limit: Optional[StrictStr] = Field(default=None, description="The maximum memory allocated to this application.")
+    __properties: ClassVar[List[str]] = ["intel_gpu", "memory_limit"]
+
+    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 ContainerResources 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 ContainerResources from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"intel_gpu": obj.get("intel_gpu"), "memory_limit": obj.get("memory_limit")})
+        return _obj

wandelbots_api_client/v2/models/container_storage.py

@@ -0,0 +1,94 @@
+# 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
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ContainerStorage(BaseModel):
+    """
+    The path and capacity of a volume that retains data across application restarts. The maximal requestable capacity is 300Mi. If you need more capacity consider using [storeObject](#/operations/storeObject).
+    """  # noqa: E501
+
+    mount_path: StrictStr
+    capacity: Annotated[str, Field(strict=True)] = Field(
+        description="The amount of local storage available for the application.  **NOTE:** The capacity can NEVER be reduced! "
+    )
+    __properties: ClassVar[List[str]] = ["mount_path", "capacity"]
+
+    @field_validator("capacity")
+    def capacity_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[0-9]+(\\.[0-9]+)?(Ki|Mi|Gi|Ti|Pi|Ei|B)?$", value):
+            raise ValueError(r"must validate the regular expression /^[0-9]+(\\.[0-9]+)?(Ki|Mi|Gi|Ti|Pi|Ei|B)?$/")
+        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 ContainerStorage 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 ContainerStorage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"mount_path": obj.get("mount_path"), "capacity": obj.get("capacity")})
+        return _obj

wandelbots_api_client/v2/models/controller_description.py

@@ -0,0 +1,97 @@
+# 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, 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 ControllerDescription(BaseModel):
+    """
+    The data type to describe a robot controller.
+    """  # noqa: E501
+
+    connected_motion_groups: List[StrictStr]
+    supports_freedrive: StrictBool = Field(description="Can this controller be moved through freedrive (true), or not (false).")
+    supports_control: StrictBool = Field(
+        description="Can this controller be controlled with NOVA (true) or is it only possible to read data (false)."
+    )
+    supports_safety_zones: StrictBool = Field(
+        description="True if NOVA supports reading safety zone-, tool- and link-geometries for this motion group. Safety zones are used to define areas where the robot should slow down or stop. If false, NOVA can't guarantee that the executed motions respect safety zones defined on the controller. "
+    )
+    __properties: ClassVar[List[str]] = ["connected_motion_groups", "supports_freedrive", "supports_control", "supports_safety_zones"]
+
+    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 ControllerDescription 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 ControllerDescription from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "connected_motion_groups": obj.get("connected_motion_groups"),
+                "supports_freedrive": obj.get("supports_freedrive"),
+                "supports_control": obj.get("supports_control"),
+                "supports_safety_zones": obj.get("supports_safety_zones"),
+            }
+        )
+        return _obj

wandelbots_api_client/v2/models/convex_hull.py

@@ -0,0 +1,94 @@
+# 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, field_validator
+from typing import Any, ClassVar, Dict, List, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class ConvexHull(BaseModel):
+    """
+    Defines a convex hull encapsulating a set of vertices.
+    """  # noqa: E501
+
+    shape_type: StrictStr
+    vertices: List[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)]] = Field(
+        description="The list of encapsulated points."
+    )
+    __properties: ClassVar[List[str]] = ["shape_type", "vertices"]
+
+    @field_validator("shape_type")
+    def shape_type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(["convex_hull"]):
+            raise ValueError("must be one of enum values ('convex_hull')")
+        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 ConvexHull 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 ConvexHull from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"shape_type": obj.get("shape_type"), "vertices": obj.get("vertices")})
+        return _obj

wandelbots_api_client/v2/models/coordinate_system.py

@@ -0,0 +1,115 @@
+# 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.orientation_type import OrientationType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+
+class CoordinateSystem(BaseModel):
+    """
+    CoordinateSystem
+    """  # noqa: E501
+
+    name: Optional[StrictStr] = Field(default=None, description="Human readable name of this coordinate system.")
+    reference_coordinate_system: Optional[StrictStr] = Field(
+        default=None, description="The identifier of the reference coordinate system. Empty if world is used."
+    )
+    position: Optional[Annotated[List[Union[StrictFloat, StrictInt]], Field(min_length=3, max_length=3)]] = Field(
+        default=None, 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
+    coordinate_system: StrictStr = Field(description="Unique identifier of the coordinate system.")
+    __properties: ClassVar[List[str]] = [
+        "name",
+        "reference_coordinate_system",
+        "position",
+        "orientation",
+        "orientation_type",
+        "coordinate_system",
+    ]
+
+    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 CoordinateSystem 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 CoordinateSystem 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"),
+                "reference_coordinate_system": obj.get("reference_coordinate_system"),
+                "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,
+                "coordinate_system": obj.get("coordinate_system"),
+            }
+        )
+        return _obj