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

zaber_motion/dto/ascii/conversion_factor.py

@@ -1,81 +1,81 @@
-# 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 ...units import Units, UnitsAndLiterals, units_from_literals
-
-
-@dataclass
-class ConversionFactor:
-    """
-    Represents unit conversion factor for a single dimension.
-    """
-
-    setting: str
-    """
-    Setting representing the dimension.
-    """
-
-    value: float
-    """
-    Value representing 1 native device unit in specified real-word units.
-    """
-
-    unit: UnitsAndLiterals
-    """
-    Units of the value.
-    """
-
-    @staticmethod
-    def zero_values() -> 'ConversionFactor':
-        return ConversionFactor(
-            setting="",
-            value=0,
-            unit=Units.NATIVE,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'ConversionFactor':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return ConversionFactor.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 {
-            'setting': str(self.setting or ''),
-            'value': float(self.value),
-            'unit': units_from_literals(self.unit).value,
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'ConversionFactor':
-        return ConversionFactor(
-            setting=data.get('setting'),  # type: ignore
-            value=data.get('value'),  # type: ignore
-            unit=Units(data.get('unit')),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.setting is not None:
-            if not isinstance(self.setting, str):
-                raise ValueError(f'Property "Setting" of "ConversionFactor" is not a string.')
-
-        if self.value is None:
-            raise ValueError(f'Property "Value" of "ConversionFactor" is None.')
-
-        if not isinstance(self.value, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Value" of "ConversionFactor" is not a number.')
-
-        if self.unit is None:
-            raise ValueError(f'Property "Unit" of "ConversionFactor" is None.')
-
-        if not isinstance(self.unit, (Units, str)):
-            raise ValueError(f'Property "Unit" of "ConversionFactor" is not Units.')
+# 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 ...units import Units, UnitsAndLiterals, units_from_literals
+
+
+@dataclass
+class ConversionFactor:
+    """
+    Represents unit conversion factor for a single dimension.
+    """
+
+    setting: str
+    """
+    Setting representing the dimension.
+    """
+
+    value: float
+    """
+    Value representing 1 native device unit in specified real-word units.
+    """
+
+    unit: UnitsAndLiterals
+    """
+    Units of the value.
+    """
+
+    @staticmethod
+    def zero_values() -> 'ConversionFactor':
+        return ConversionFactor(
+            setting="",
+            value=0,
+            unit=Units.NATIVE,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'ConversionFactor':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return ConversionFactor.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 {
+            'setting': str(self.setting or ''),
+            'value': float(self.value),
+            'unit': units_from_literals(self.unit).value,
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'ConversionFactor':
+        return ConversionFactor(
+            setting=data.get('setting'),  # type: ignore
+            value=data.get('value'),  # type: ignore
+            unit=Units(data.get('unit')),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.setting is not None:
+            if not isinstance(self.setting, str):
+                raise ValueError(f'Property "Setting" of "ConversionFactor" is not a string.')
+
+        if self.value is None:
+            raise ValueError(f'Property "Value" of "ConversionFactor" is None.')
+
+        if not isinstance(self.value, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Value" of "ConversionFactor" is not a number.')
+
+        if self.unit is None:
+            raise ValueError(f'Property "Unit" of "ConversionFactor" is None.')
+
+        if not isinstance(self.unit, (Units, str)):
+            raise ValueError(f'Property "Unit" of "ConversionFactor" is not Units.')

zaber_motion/dto/ascii/device_identity.py

@@ -1,136 +1,136 @@
-# 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 ..firmware_version import FirmwareVersion
-
-
-@dataclass
-class DeviceIdentity:
-    """
-    Representation of data gathered during device identification.
-    """
-
-    device_id: int
-    """
-    Unique ID of the device hardware.
-    """
-
-    serial_number: int
-    """
-    Serial number of the device.
-    """
-
-    name: str
-    """
-    Name of the product.
-    """
-
-    axis_count: int
-    """
-    Number of axes this device has.
-    """
-
-    firmware_version: FirmwareVersion
-    """
-    Version of the firmware.
-    """
-
-    is_modified: bool
-    """
-    The device has hardware modifications.
-    """
-
-    is_integrated: bool
-    """
-    The device is an integrated product.
-    """
-
-    @staticmethod
-    def zero_values() -> 'DeviceIdentity':
-        return DeviceIdentity(
-            device_id=0,
-            serial_number=0,
-            name="",
-            axis_count=0,
-            firmware_version=FirmwareVersion.zero_values(),
-            is_modified=False,
-            is_integrated=False,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'DeviceIdentity':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return DeviceIdentity.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 {
-            'deviceId': int(self.device_id),
-            'serialNumber': int(self.serial_number),
-            'name': str(self.name or ''),
-            'axisCount': int(self.axis_count),
-            'firmwareVersion': self.firmware_version.to_dict(),
-            'isModified': bool(self.is_modified),
-            'isIntegrated': bool(self.is_integrated),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'DeviceIdentity':
-        return DeviceIdentity(
-            device_id=data.get('deviceId'),  # type: ignore
-            serial_number=data.get('serialNumber'),  # type: ignore
-            name=data.get('name'),  # type: ignore
-            axis_count=data.get('axisCount'),  # type: ignore
-            firmware_version=FirmwareVersion.from_dict(data.get('firmwareVersion')),  # type: ignore
-            is_modified=data.get('isModified'),  # type: ignore
-            is_integrated=data.get('isIntegrated'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.device_id is None:
-            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is None.')
-
-        if not isinstance(self.device_id, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is not a number.')
-
-        if int(self.device_id) != self.device_id:
-            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is not integer value.')
-
-        if self.serial_number is None:
-            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is None.')
-
-        if not isinstance(self.serial_number, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is not a number.')
-
-        if int(self.serial_number) != self.serial_number:
-            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is not integer value.')
-
-        if self.name is not None:
-            if not isinstance(self.name, str):
-                raise ValueError(f'Property "Name" of "DeviceIdentity" is not a string.')
-
-        if self.axis_count is None:
-            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is None.')
-
-        if not isinstance(self.axis_count, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is not a number.')
-
-        if int(self.axis_count) != self.axis_count:
-            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is not integer value.')
-
-        if self.firmware_version is None:
-            raise ValueError(f'Property "FirmwareVersion" of "DeviceIdentity" is None.')
-
-        if not isinstance(self.firmware_version, FirmwareVersion):
-            raise ValueError(f'Property "FirmwareVersion" of "DeviceIdentity" is not an instance of "FirmwareVersion".')
-
-        self.firmware_version.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
+import decimal
+import zaber_bson
+from ..firmware_version import FirmwareVersion
+
+
+@dataclass
+class DeviceIdentity:
+    """
+    Representation of data gathered during device identification.
+    """
+
+    device_id: int
+    """
+    Unique ID of the device hardware.
+    """
+
+    serial_number: int
+    """
+    Serial number of the device.
+    """
+
+    name: str
+    """
+    Name of the product.
+    """
+
+    axis_count: int
+    """
+    Number of axes this device has.
+    """
+
+    firmware_version: FirmwareVersion
+    """
+    Version of the firmware.
+    """
+
+    is_modified: bool
+    """
+    The device has hardware modifications.
+    """
+
+    is_integrated: bool
+    """
+    The device is an integrated product.
+    """
+
+    @staticmethod
+    def zero_values() -> 'DeviceIdentity':
+        return DeviceIdentity(
+            device_id=0,
+            serial_number=0,
+            name="",
+            axis_count=0,
+            firmware_version=FirmwareVersion.zero_values(),
+            is_modified=False,
+            is_integrated=False,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'DeviceIdentity':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return DeviceIdentity.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 {
+            'deviceId': int(self.device_id),
+            'serialNumber': int(self.serial_number),
+            'name': str(self.name or ''),
+            'axisCount': int(self.axis_count),
+            'firmwareVersion': self.firmware_version.to_dict(),
+            'isModified': bool(self.is_modified),
+            'isIntegrated': bool(self.is_integrated),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'DeviceIdentity':
+        return DeviceIdentity(
+            device_id=data.get('deviceId'),  # type: ignore
+            serial_number=data.get('serialNumber'),  # type: ignore
+            name=data.get('name'),  # type: ignore
+            axis_count=data.get('axisCount'),  # type: ignore
+            firmware_version=FirmwareVersion.from_dict(data.get('firmwareVersion')),  # type: ignore
+            is_modified=data.get('isModified'),  # type: ignore
+            is_integrated=data.get('isIntegrated'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.device_id is None:
+            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is None.')
+
+        if not isinstance(self.device_id, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is not a number.')
+
+        if int(self.device_id) != self.device_id:
+            raise ValueError(f'Property "DeviceId" of "DeviceIdentity" is not integer value.')
+
+        if self.serial_number is None:
+            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is None.')
+
+        if not isinstance(self.serial_number, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is not a number.')
+
+        if int(self.serial_number) != self.serial_number:
+            raise ValueError(f'Property "SerialNumber" of "DeviceIdentity" is not integer value.')
+
+        if self.name is not None:
+            if not isinstance(self.name, str):
+                raise ValueError(f'Property "Name" of "DeviceIdentity" is not a string.')
+
+        if self.axis_count is None:
+            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is None.')
+
+        if not isinstance(self.axis_count, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is not a number.')
+
+        if int(self.axis_count) != self.axis_count:
+            raise ValueError(f'Property "AxisCount" of "DeviceIdentity" is not integer value.')
+
+        if self.firmware_version is None:
+            raise ValueError(f'Property "FirmwareVersion" of "DeviceIdentity" is None.')
+
+        if not isinstance(self.firmware_version, FirmwareVersion):
+            raise ValueError(f'Property "FirmwareVersion" of "DeviceIdentity" is not an instance of "FirmwareVersion".')
+
+        self.firmware_version.validate()

zaber_motion/dto/ascii/device_io_info.py

@@ -1,108 +1,108 @@
-# 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
-
-
-@dataclass
-class DeviceIOInfo:
-    """
-    Class representing information on the I/O channels of the device.
-    """
-
-    number_analog_outputs: int
-    """
-    Number of analog output channels.
-    """
-
-    number_analog_inputs: int
-    """
-    Number of analog input channels.
-    """
-
-    number_digital_outputs: int
-    """
-    Number of digital output channels.
-    """
-
-    number_digital_inputs: int
-    """
-    Number of digital input channels.
-    """
-
-    @staticmethod
-    def zero_values() -> 'DeviceIOInfo':
-        return DeviceIOInfo(
-            number_analog_outputs=0,
-            number_analog_inputs=0,
-            number_digital_outputs=0,
-            number_digital_inputs=0,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'DeviceIOInfo':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return DeviceIOInfo.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 {
-            'numberAnalogOutputs': int(self.number_analog_outputs),
-            'numberAnalogInputs': int(self.number_analog_inputs),
-            'numberDigitalOutputs': int(self.number_digital_outputs),
-            'numberDigitalInputs': int(self.number_digital_inputs),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'DeviceIOInfo':
-        return DeviceIOInfo(
-            number_analog_outputs=data.get('numberAnalogOutputs'),  # type: ignore
-            number_analog_inputs=data.get('numberAnalogInputs'),  # type: ignore
-            number_digital_outputs=data.get('numberDigitalOutputs'),  # type: ignore
-            number_digital_inputs=data.get('numberDigitalInputs'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.number_analog_outputs is None:
-            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is None.')
-
-        if not isinstance(self.number_analog_outputs, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is not a number.')
-
-        if int(self.number_analog_outputs) != self.number_analog_outputs:
-            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is not integer value.')
-
-        if self.number_analog_inputs is None:
-            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is None.')
-
-        if not isinstance(self.number_analog_inputs, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is not a number.')
-
-        if int(self.number_analog_inputs) != self.number_analog_inputs:
-            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is not integer value.')
-
-        if self.number_digital_outputs is None:
-            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is None.')
-
-        if not isinstance(self.number_digital_outputs, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is not a number.')
-
-        if int(self.number_digital_outputs) != self.number_digital_outputs:
-            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is not integer value.')
-
-        if self.number_digital_inputs is None:
-            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" is None.')
-
-        if not isinstance(self.number_digital_inputs, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" is not a number.')
-
-        if int(self.number_digital_inputs) != self.number_digital_inputs:
-            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" 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
+import decimal
+import zaber_bson
+
+
+@dataclass
+class DeviceIOInfo:
+    """
+    Class representing information on the I/O channels of the device.
+    """
+
+    number_analog_outputs: int
+    """
+    Number of analog output channels.
+    """
+
+    number_analog_inputs: int
+    """
+    Number of analog input channels.
+    """
+
+    number_digital_outputs: int
+    """
+    Number of digital output channels.
+    """
+
+    number_digital_inputs: int
+    """
+    Number of digital input channels.
+    """
+
+    @staticmethod
+    def zero_values() -> 'DeviceIOInfo':
+        return DeviceIOInfo(
+            number_analog_outputs=0,
+            number_analog_inputs=0,
+            number_digital_outputs=0,
+            number_digital_inputs=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'DeviceIOInfo':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return DeviceIOInfo.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 {
+            'numberAnalogOutputs': int(self.number_analog_outputs),
+            'numberAnalogInputs': int(self.number_analog_inputs),
+            'numberDigitalOutputs': int(self.number_digital_outputs),
+            'numberDigitalInputs': int(self.number_digital_inputs),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'DeviceIOInfo':
+        return DeviceIOInfo(
+            number_analog_outputs=data.get('numberAnalogOutputs'),  # type: ignore
+            number_analog_inputs=data.get('numberAnalogInputs'),  # type: ignore
+            number_digital_outputs=data.get('numberDigitalOutputs'),  # type: ignore
+            number_digital_inputs=data.get('numberDigitalInputs'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.number_analog_outputs is None:
+            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is None.')
+
+        if not isinstance(self.number_analog_outputs, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is not a number.')
+
+        if int(self.number_analog_outputs) != self.number_analog_outputs:
+            raise ValueError(f'Property "NumberAnalogOutputs" of "DeviceIOInfo" is not integer value.')
+
+        if self.number_analog_inputs is None:
+            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is None.')
+
+        if not isinstance(self.number_analog_inputs, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is not a number.')
+
+        if int(self.number_analog_inputs) != self.number_analog_inputs:
+            raise ValueError(f'Property "NumberAnalogInputs" of "DeviceIOInfo" is not integer value.')
+
+        if self.number_digital_outputs is None:
+            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is None.')
+
+        if not isinstance(self.number_digital_outputs, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is not a number.')
+
+        if int(self.number_digital_outputs) != self.number_digital_outputs:
+            raise ValueError(f'Property "NumberDigitalOutputs" of "DeviceIOInfo" is not integer value.')
+
+        if self.number_digital_inputs is None:
+            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" is None.')
+
+        if not isinstance(self.number_digital_inputs, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" is not a number.')
+
+        if int(self.number_digital_inputs) != self.number_digital_inputs:
+            raise ValueError(f'Property "NumberDigitalInputs" of "DeviceIOInfo" is not integer value.')