zaber-motion 7.12.0__py3-none-win32.whl → 7.14.0__py3-none-win32.whl

zaber_motion/dto/ascii/axis_identity.py

@@ -1,117 +1,134 @@
-# This file is generated. Do not modify by hand.
-# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
-from dataclasses import dataclass
-from typing import Any, Dict
-import decimal
-import zaber_bson
-from .axis_type import AxisType
-
-
-@dataclass
-class AxisIdentity:
-    """
-    Representation of data gathered during axis identification.
-    """
-
-    peripheral_id: int
-    """
-    Unique ID of the peripheral hardware.
-    """
-
-    peripheral_name: str
-    """
-    Name of the peripheral.
-    """
-
-    peripheral_serial_number: int
-    """
-    Serial number of the peripheral, or 0 when not applicable.
-    """
-
-    is_peripheral: bool
-    """
-    Indicates whether the axis is a peripheral or part of an integrated device.
-    """
-
-    axis_type: AxisType
-    """
-    Determines the type of an axis and units it accepts.
-    """
-
-    is_modified: bool
-    """
-    The peripheral has hardware modifications.
-    """
-
-    @staticmethod
-    def zero_values() -> 'AxisIdentity':
-        return AxisIdentity(
-            peripheral_id=0,
-            peripheral_name="",
-            peripheral_serial_number=0,
-            is_peripheral=False,
-            axis_type=next(first for first in AxisType),
-            is_modified=False,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'AxisIdentity':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return AxisIdentity.from_dict(data)
-
-    def to_binary(self) -> bytes:
-        """" Serialize this class to a binary representation. """
-        self.validate()
-        return zaber_bson.dumps(self.to_dict())  # type: ignore
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            'peripheralId': int(self.peripheral_id),
-            'peripheralName': str(self.peripheral_name or ''),
-            'peripheralSerialNumber': int(self.peripheral_serial_number),
-            'isPeripheral': bool(self.is_peripheral),
-            'axisType': self.axis_type.value,
-            'isModified': bool(self.is_modified),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'AxisIdentity':
-        return AxisIdentity(
-            peripheral_id=data.get('peripheralId'),  # type: ignore
-            peripheral_name=data.get('peripheralName'),  # type: ignore
-            peripheral_serial_number=data.get('peripheralSerialNumber'),  # type: ignore
-            is_peripheral=data.get('isPeripheral'),  # type: ignore
-            axis_type=AxisType(data.get('axisType')),  # type: ignore
-            is_modified=data.get('isModified'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.peripheral_id is None:
-            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is None.')
-
-        if not isinstance(self.peripheral_id, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is not a number.')
-
-        if int(self.peripheral_id) != self.peripheral_id:
-            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is not integer value.')
-
-        if self.peripheral_name is not None:
-            if not isinstance(self.peripheral_name, str):
-                raise ValueError(f'Property "PeripheralName" of "AxisIdentity" is not a string.')
-
-        if self.peripheral_serial_number is None:
-            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is None.')
-
-        if not isinstance(self.peripheral_serial_number, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is not a number.')
-
-        if int(self.peripheral_serial_number) != self.peripheral_serial_number:
-            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is not integer value.')
-
-        if self.axis_type is None:
-            raise ValueError(f'Property "AxisType" of "AxisIdentity" is None.')
-
-        if not isinstance(self.axis_type, AxisType):
-            raise ValueError(f'Property "AxisType" of "AxisIdentity" is not an instance of "AxisType".')
+# This file is generated. Do not modify by hand.
+# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
+from dataclasses import dataclass
+from typing import Any, Dict
+import decimal
+import zaber_bson
+from .axis_type import AxisType
+
+
+@dataclass
+class AxisIdentity:
+    """
+    Representation of data gathered during axis identification.
+    """
+
+    peripheral_id: int
+    """
+    Unique ID of the peripheral hardware.
+    """
+
+    peripheral_name: str
+    """
+    Name of the peripheral.
+    """
+
+    peripheral_serial_number: int
+    """
+    Serial number of the peripheral, or 0 when not applicable.
+    """
+
+    is_peripheral: bool
+    """
+    Indicates whether the axis is a peripheral or part of an integrated device.
+    """
+
+    axis_type: AxisType
+    """
+    Determines the type of an axis and units it accepts.
+    """
+
+    is_modified: bool
+    """
+    The peripheral has hardware modifications.
+    """
+
+    resolution: int
+    """
+    The number of microsteps per full step for motion axes. Always equal to 0 for non-motion axes.
+    """
+
+    @staticmethod
+    def zero_values() -> 'AxisIdentity':
+        return AxisIdentity(
+            peripheral_id=0,
+            peripheral_name="",
+            peripheral_serial_number=0,
+            is_peripheral=False,
+            axis_type=next(first for first in AxisType),
+            is_modified=False,
+            resolution=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'AxisIdentity':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return AxisIdentity.from_dict(data)
+
+    def to_binary(self) -> bytes:
+        """" Serialize this class to a binary representation. """
+        self.validate()
+        return zaber_bson.dumps(self.to_dict())  # type: ignore
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'peripheralId': int(self.peripheral_id),
+            'peripheralName': str(self.peripheral_name or ''),
+            'peripheralSerialNumber': int(self.peripheral_serial_number),
+            'isPeripheral': bool(self.is_peripheral),
+            'axisType': self.axis_type.value,
+            'isModified': bool(self.is_modified),
+            'resolution': int(self.resolution),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'AxisIdentity':
+        return AxisIdentity(
+            peripheral_id=data.get('peripheralId'),  # type: ignore
+            peripheral_name=data.get('peripheralName'),  # type: ignore
+            peripheral_serial_number=data.get('peripheralSerialNumber'),  # type: ignore
+            is_peripheral=data.get('isPeripheral'),  # type: ignore
+            axis_type=AxisType(data.get('axisType')),  # type: ignore
+            is_modified=data.get('isModified'),  # type: ignore
+            resolution=data.get('resolution'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.peripheral_id is None:
+            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is None.')
+
+        if not isinstance(self.peripheral_id, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is not a number.')
+
+        if int(self.peripheral_id) != self.peripheral_id:
+            raise ValueError(f'Property "PeripheralId" of "AxisIdentity" is not integer value.')
+
+        if self.peripheral_name is not None:
+            if not isinstance(self.peripheral_name, str):
+                raise ValueError(f'Property "PeripheralName" of "AxisIdentity" is not a string.')
+
+        if self.peripheral_serial_number is None:
+            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is None.')
+
+        if not isinstance(self.peripheral_serial_number, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is not a number.')
+
+        if int(self.peripheral_serial_number) != self.peripheral_serial_number:
+            raise ValueError(f'Property "PeripheralSerialNumber" of "AxisIdentity" is not integer value.')
+
+        if self.axis_type is None:
+            raise ValueError(f'Property "AxisType" of "AxisIdentity" is None.')
+
+        if not isinstance(self.axis_type, AxisType):
+            raise ValueError(f'Property "AxisType" of "AxisIdentity" is not an instance of "AxisType".')
+
+        if self.resolution is None:
+            raise ValueError(f'Property "Resolution" of "AxisIdentity" is None.')
+
+        if not isinstance(self.resolution, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Resolution" of "AxisIdentity" is not a number.')
+
+        if int(self.resolution) != self.resolution:
+            raise ValueError(f'Property "Resolution" of "AxisIdentity" is not integer value.')

zaber_motion/dto/ascii/axis_type.py

@@ -1,14 +1,14 @@
-# This file is generated. Do not modify by hand.
-from enum import Enum
-
-
-class AxisType(Enum):
-    """
-    Denotes type of an axis and units it accepts.
-    """
-
-    UNKNOWN = 0
-    LINEAR = 1
-    ROTARY = 2
-    PROCESS = 3
-    LAMP = 4
+# This file is generated. Do not modify by hand.
+from enum import Enum
+
+
+class AxisType(Enum):
+    """
+    Denotes type of an axis and units it accepts.
+    """
+
+    UNKNOWN = 0
+    LINEAR = 1
+    ROTARY = 2
+    PROCESS = 3
+    LAMP = 4

zaber_motion/dto/ascii/can_set_state_axis_response.py

@@ -1,69 +1,69 @@
-# This file is generated. Do not modify by hand.
-# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-import decimal
-import zaber_bson
-
-
-@dataclass
-class CanSetStateAxisResponse:
-    """
-    An object containing any setup issues that will prevent setting a state to a given axis.
-    """
-
-    axis_number: int
-    """
-    The number of the axis that cannot be set.
-    """
-
-    error: Optional[str] = None
-    """
-    The error blocking applying this state to the given axis, or null if there is no error.
-    """
-
-    @staticmethod
-    def zero_values() -> 'CanSetStateAxisResponse':
-        return CanSetStateAxisResponse(
-            error=None,
-            axis_number=0,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'CanSetStateAxisResponse':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return CanSetStateAxisResponse.from_dict(data)
-
-    def to_binary(self) -> bytes:
-        """" Serialize this class to a binary representation. """
-        self.validate()
-        return zaber_bson.dumps(self.to_dict())  # type: ignore
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            'error': str(self.error) if self.error is not None else None,
-            'axisNumber': int(self.axis_number),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'CanSetStateAxisResponse':
-        return CanSetStateAxisResponse(
-            error=data.get('error'),  # type: ignore
-            axis_number=data.get('axisNumber'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.error is not None:
-            if not isinstance(self.error, str):
-                raise ValueError(f'Property "Error" of "CanSetStateAxisResponse" is not a string.')
-
-        if self.axis_number is None:
-            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is None.')
-
-        if not isinstance(self.axis_number, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is not a number.')
-
-        if int(self.axis_number) != self.axis_number:
-            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is not integer value.')
+# This file is generated. Do not modify by hand.
+# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+import decimal
+import zaber_bson
+
+
+@dataclass
+class CanSetStateAxisResponse:
+    """
+    An object containing any setup issues that will prevent setting a state to a given axis.
+    """
+
+    axis_number: int
+    """
+    The number of the axis that cannot be set.
+    """
+
+    error: Optional[str] = None
+    """
+    The error blocking applying this state to the given axis, or null if there is no error.
+    """
+
+    @staticmethod
+    def zero_values() -> 'CanSetStateAxisResponse':
+        return CanSetStateAxisResponse(
+            error=None,
+            axis_number=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'CanSetStateAxisResponse':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return CanSetStateAxisResponse.from_dict(data)
+
+    def to_binary(self) -> bytes:
+        """" Serialize this class to a binary representation. """
+        self.validate()
+        return zaber_bson.dumps(self.to_dict())  # type: ignore
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'error': str(self.error) if self.error is not None else None,
+            'axisNumber': int(self.axis_number),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'CanSetStateAxisResponse':
+        return CanSetStateAxisResponse(
+            error=data.get('error'),  # type: ignore
+            axis_number=data.get('axisNumber'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.error is not None:
+            if not isinstance(self.error, str):
+                raise ValueError(f'Property "Error" of "CanSetStateAxisResponse" is not a string.')
+
+        if self.axis_number is None:
+            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is None.')
+
+        if not isinstance(self.axis_number, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is not a number.')
+
+        if int(self.axis_number) != self.axis_number:
+            raise ValueError(f'Property "AxisNumber" of "CanSetStateAxisResponse" is not integer value.')

zaber_motion/dto/ascii/can_set_state_device_response.py

@@ -1,75 +1,75 @@
-# This file is generated. Do not modify by hand.
-# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-from collections.abc import Iterable
-import zaber_bson
-from .can_set_state_axis_response import CanSetStateAxisResponse
-
-
-@dataclass
-class CanSetStateDeviceResponse:
-    """
-    An object containing any setup issues that will prevent setting a state to a given device.
-    """
-
-    axis_responses: List[CanSetStateAxisResponse]
-    """
-    A list of axis responses, potentially with messages for errors
-    which would block setting the state of the device's axes.
-    """
-
-    error: Optional[str] = None
-    """
-    The error blocking applying this state to the given device, or null if there is no error.
-    """
-
-    @staticmethod
-    def zero_values() -> 'CanSetStateDeviceResponse':
-        return CanSetStateDeviceResponse(
-            error=None,
-            axis_responses=[],
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'CanSetStateDeviceResponse':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return CanSetStateDeviceResponse.from_dict(data)
-
-    def to_binary(self) -> bytes:
-        """" Serialize this class to a binary representation. """
-        self.validate()
-        return zaber_bson.dumps(self.to_dict())  # type: ignore
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            'error': str(self.error) if self.error is not None else None,
-            'axisResponses': [item.to_dict() for item in self.axis_responses] if self.axis_responses is not None else [],
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'CanSetStateDeviceResponse':
-        return CanSetStateDeviceResponse(
-            error=data.get('error'),  # type: ignore
-            axis_responses=[CanSetStateAxisResponse.from_dict(item) for item in data.get('axisResponses')],  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.error is not None:
-            if not isinstance(self.error, str):
-                raise ValueError(f'Property "Error" of "CanSetStateDeviceResponse" is not a string.')
-
-        if self.axis_responses is not None:
-            if not isinstance(self.axis_responses, Iterable):
-                raise ValueError('Property "AxisResponses" of "CanSetStateDeviceResponse" is not iterable.')
-
-            for i, axis_responses_item in enumerate(self.axis_responses):
-                if axis_responses_item is None:
-                    raise ValueError(f'Item {i} in property "AxisResponses" of "CanSetStateDeviceResponse" is None.')
-
-                if not isinstance(axis_responses_item, CanSetStateAxisResponse):
-                    raise ValueError(f'Item {i} in property "AxisResponses" of "CanSetStateDeviceResponse" is not an instance of "CanSetStateAxisResponse".')
-
-                axis_responses_item.validate()
+# This file is generated. Do not modify by hand.
+# pylint: disable=line-too-long, unused-argument, f-string-without-interpolation, too-many-branches, too-many-statements, unnecessary-pass
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from collections.abc import Iterable
+import zaber_bson
+from .can_set_state_axis_response import CanSetStateAxisResponse
+
+
+@dataclass
+class CanSetStateDeviceResponse:
+    """
+    An object containing any setup issues that will prevent setting a state to a given device.
+    """
+
+    axis_responses: List[CanSetStateAxisResponse]
+    """
+    A list of axis responses, potentially with messages for errors
+    which would block setting the state of the device's axes.
+    """
+
+    error: Optional[str] = None
+    """
+    The error blocking applying this state to the given device, or null if there is no error.
+    """
+
+    @staticmethod
+    def zero_values() -> 'CanSetStateDeviceResponse':
+        return CanSetStateDeviceResponse(
+            error=None,
+            axis_responses=[],
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'CanSetStateDeviceResponse':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return CanSetStateDeviceResponse.from_dict(data)
+
+    def to_binary(self) -> bytes:
+        """" Serialize this class to a binary representation. """
+        self.validate()
+        return zaber_bson.dumps(self.to_dict())  # type: ignore
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'error': str(self.error) if self.error is not None else None,
+            'axisResponses': [item.to_dict() for item in self.axis_responses] if self.axis_responses is not None else [],
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'CanSetStateDeviceResponse':
+        return CanSetStateDeviceResponse(
+            error=data.get('error'),  # type: ignore
+            axis_responses=[CanSetStateAxisResponse.from_dict(item) for item in data.get('axisResponses')],  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.error is not None:
+            if not isinstance(self.error, str):
+                raise ValueError(f'Property "Error" of "CanSetStateDeviceResponse" is not a string.')
+
+        if self.axis_responses is not None:
+            if not isinstance(self.axis_responses, Iterable):
+                raise ValueError('Property "AxisResponses" of "CanSetStateDeviceResponse" is not iterable.')
+
+            for i, axis_responses_item in enumerate(self.axis_responses):
+                if axis_responses_item is None:
+                    raise ValueError(f'Item {i} in property "AxisResponses" of "CanSetStateDeviceResponse" is None.')
+
+                if not isinstance(axis_responses_item, CanSetStateAxisResponse):
+                    raise ValueError(f'Item {i} in property "AxisResponses" of "CanSetStateDeviceResponse" is not an instance of "CanSetStateAxisResponse".')
+
+                axis_responses_item.validate()