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

zaber_motion/dto/firmware_version.py

@@ -1,91 +1,91 @@
-# 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 FirmwareVersion:
-    """
-    Class representing version of firmware in the controller.
-    """
-
-    major: int
-    """
-    Major version number.
-    """
-
-    minor: int
-    """
-    Minor version number.
-    """
-
-    build: int
-    """
-    Build version number.
-    """
-
-    @staticmethod
-    def zero_values() -> 'FirmwareVersion':
-        return FirmwareVersion(
-            major=0,
-            minor=0,
-            build=0,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'FirmwareVersion':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return FirmwareVersion.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 {
-            'major': int(self.major),
-            'minor': int(self.minor),
-            'build': int(self.build),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'FirmwareVersion':
-        return FirmwareVersion(
-            major=data.get('major'),  # type: ignore
-            minor=data.get('minor'),  # type: ignore
-            build=data.get('build'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.major is None:
-            raise ValueError(f'Property "Major" of "FirmwareVersion" is None.')
-
-        if not isinstance(self.major, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Major" of "FirmwareVersion" is not a number.')
-
-        if int(self.major) != self.major:
-            raise ValueError(f'Property "Major" of "FirmwareVersion" is not integer value.')
-
-        if self.minor is None:
-            raise ValueError(f'Property "Minor" of "FirmwareVersion" is None.')
-
-        if not isinstance(self.minor, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Minor" of "FirmwareVersion" is not a number.')
-
-        if int(self.minor) != self.minor:
-            raise ValueError(f'Property "Minor" of "FirmwareVersion" is not integer value.')
-
-        if self.build is None:
-            raise ValueError(f'Property "Build" of "FirmwareVersion" is None.')
-
-        if not isinstance(self.build, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Build" of "FirmwareVersion" is not a number.')
-
-        if int(self.build) != self.build:
-            raise ValueError(f'Property "Build" of "FirmwareVersion" 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 FirmwareVersion:
+    """
+    Class representing version of firmware in the controller.
+    """
+
+    major: int
+    """
+    Major version number.
+    """
+
+    minor: int
+    """
+    Minor version number.
+    """
+
+    build: int
+    """
+    Build version number.
+    """
+
+    @staticmethod
+    def zero_values() -> 'FirmwareVersion':
+        return FirmwareVersion(
+            major=0,
+            minor=0,
+            build=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'FirmwareVersion':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return FirmwareVersion.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 {
+            'major': int(self.major),
+            'minor': int(self.minor),
+            'build': int(self.build),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'FirmwareVersion':
+        return FirmwareVersion(
+            major=data.get('major'),  # type: ignore
+            minor=data.get('minor'),  # type: ignore
+            build=data.get('build'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.major is None:
+            raise ValueError(f'Property "Major" of "FirmwareVersion" is None.')
+
+        if not isinstance(self.major, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Major" of "FirmwareVersion" is not a number.')
+
+        if int(self.major) != self.major:
+            raise ValueError(f'Property "Major" of "FirmwareVersion" is not integer value.')
+
+        if self.minor is None:
+            raise ValueError(f'Property "Minor" of "FirmwareVersion" is None.')
+
+        if not isinstance(self.minor, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Minor" of "FirmwareVersion" is not a number.')
+
+        if int(self.minor) != self.minor:
+            raise ValueError(f'Property "Minor" of "FirmwareVersion" is not integer value.')
+
+        if self.build is None:
+            raise ValueError(f'Property "Build" of "FirmwareVersion" is None.')
+
+        if not isinstance(self.build, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Build" of "FirmwareVersion" is not a number.')
+
+        if int(self.build) != self.build:
+            raise ValueError(f'Property "Build" of "FirmwareVersion" is not integer value.')

zaber_motion/dto/gcode/__init__.py

@@ -1,9 +1,9 @@
-# This file is generated. Do not modify by hand.
-# pylint: disable=line-too-long
-from .axis_definition import AxisDefinition as AxisDefinition
-from .axis_mapping import AxisMapping as AxisMapping
-from .axis_transformation import AxisTransformation as AxisTransformation
-from .device_definition import DeviceDefinition as DeviceDefinition
-from .translate_message import TranslateMessage as TranslateMessage
-from .translate_result import TranslateResult as TranslateResult
-from .translator_config import TranslatorConfig as TranslatorConfig
+# This file is generated. Do not modify by hand.
+# pylint: disable=line-too-long
+from .axis_definition import AxisDefinition as AxisDefinition
+from .axis_mapping import AxisMapping as AxisMapping
+from .axis_transformation import AxisTransformation as AxisTransformation
+from .device_definition import DeviceDefinition as DeviceDefinition
+from .translate_message import TranslateMessage as TranslateMessage
+from .translate_result import TranslateResult as TranslateResult
+from .translator_config import TranslatorConfig as TranslatorConfig

zaber_motion/dto/gcode/axis_definition.py

@@ -1,74 +1,74 @@
-# 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 AxisDefinition:
-    """
-    Defines an axis of the translator.
-    """
-
-    peripheral_id: int
-    """
-    ID of the peripheral.
-    """
-
-    microstep_resolution: Optional[int] = None
-    """
-    Microstep resolution of the axis.
-    Can be obtained by reading the resolution setting.
-    Leave empty if the axis does not have the setting.
-    """
-
-    @staticmethod
-    def zero_values() -> 'AxisDefinition':
-        return AxisDefinition(
-            peripheral_id=0,
-            microstep_resolution=None,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'AxisDefinition':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return AxisDefinition.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),
-            'microstepResolution': int(self.microstep_resolution) if self.microstep_resolution is not None else None,
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'AxisDefinition':
-        return AxisDefinition(
-            peripheral_id=data.get('peripheralId'),  # type: ignore
-            microstep_resolution=data.get('microstepResolution'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.peripheral_id is None:
-            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is None.')
-
-        if not isinstance(self.peripheral_id, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is not a number.')
-
-        if int(self.peripheral_id) != self.peripheral_id:
-            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is not integer value.')
-
-        if self.microstep_resolution is not None:
-            if not isinstance(self.microstep_resolution, (int, float, decimal.Decimal)):
-                raise ValueError(f'Property "MicrostepResolution" of "AxisDefinition" is not a number.')
-
-            if int(self.microstep_resolution) != self.microstep_resolution:
-                raise ValueError(f'Property "MicrostepResolution" of "AxisDefinition" 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 AxisDefinition:
+    """
+    Defines an axis of the translator.
+    """
+
+    peripheral_id: int
+    """
+    ID of the peripheral.
+    """
+
+    microstep_resolution: Optional[int] = None
+    """
+    Microstep resolution of the axis.
+    Can be obtained by reading the resolution setting.
+    Leave empty if the axis does not have the setting.
+    """
+
+    @staticmethod
+    def zero_values() -> 'AxisDefinition':
+        return AxisDefinition(
+            peripheral_id=0,
+            microstep_resolution=None,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'AxisDefinition':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return AxisDefinition.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),
+            'microstepResolution': int(self.microstep_resolution) if self.microstep_resolution is not None else None,
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'AxisDefinition':
+        return AxisDefinition(
+            peripheral_id=data.get('peripheralId'),  # type: ignore
+            microstep_resolution=data.get('microstepResolution'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.peripheral_id is None:
+            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is None.')
+
+        if not isinstance(self.peripheral_id, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is not a number.')
+
+        if int(self.peripheral_id) != self.peripheral_id:
+            raise ValueError(f'Property "PeripheralId" of "AxisDefinition" is not integer value.')
+
+        if self.microstep_resolution is not None:
+            if not isinstance(self.microstep_resolution, (int, float, decimal.Decimal)):
+                raise ValueError(f'Property "MicrostepResolution" of "AxisDefinition" is not a number.')
+
+            if int(self.microstep_resolution) != self.microstep_resolution:
+                raise ValueError(f'Property "MicrostepResolution" of "AxisDefinition" is not integer value.')

zaber_motion/dto/gcode/axis_mapping.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
-import decimal
-import zaber_bson
-
-
-@dataclass
-class AxisMapping:
-    """
-    Maps a translator axis to a Zaber stream axis.
-    """
-
-    axis_letter: str
-    """
-    Letter of the translator axis (X,Y,Z,A,B,C,E).
-    """
-
-    axis_index: int
-    """
-    Index of the stream axis.
-    """
-
-    @staticmethod
-    def zero_values() -> 'AxisMapping':
-        return AxisMapping(
-            axis_letter="",
-            axis_index=0,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'AxisMapping':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return AxisMapping.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 {
-            'axisLetter': str(self.axis_letter or ''),
-            'axisIndex': int(self.axis_index),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'AxisMapping':
-        return AxisMapping(
-            axis_letter=data.get('axisLetter'),  # type: ignore
-            axis_index=data.get('axisIndex'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.axis_letter is not None:
-            if not isinstance(self.axis_letter, str):
-                raise ValueError(f'Property "AxisLetter" of "AxisMapping" is not a string.')
-
-        if self.axis_index is None:
-            raise ValueError(f'Property "AxisIndex" of "AxisMapping" is None.')
-
-        if not isinstance(self.axis_index, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "AxisIndex" of "AxisMapping" is not a number.')
-
-        if int(self.axis_index) != self.axis_index:
-            raise ValueError(f'Property "AxisIndex" of "AxisMapping" 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 AxisMapping:
+    """
+    Maps a translator axis to a Zaber stream axis.
+    """
+
+    axis_letter: str
+    """
+    Letter of the translator axis (X,Y,Z,A,B,C,E).
+    """
+
+    axis_index: int
+    """
+    Index of the stream axis.
+    """
+
+    @staticmethod
+    def zero_values() -> 'AxisMapping':
+        return AxisMapping(
+            axis_letter="",
+            axis_index=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'AxisMapping':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return AxisMapping.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 {
+            'axisLetter': str(self.axis_letter or ''),
+            'axisIndex': int(self.axis_index),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'AxisMapping':
+        return AxisMapping(
+            axis_letter=data.get('axisLetter'),  # type: ignore
+            axis_index=data.get('axisIndex'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.axis_letter is not None:
+            if not isinstance(self.axis_letter, str):
+                raise ValueError(f'Property "AxisLetter" of "AxisMapping" is not a string.')
+
+        if self.axis_index is None:
+            raise ValueError(f'Property "AxisIndex" of "AxisMapping" is None.')
+
+        if not isinstance(self.axis_index, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "AxisIndex" of "AxisMapping" is not a number.')
+
+        if int(self.axis_index) != self.axis_index:
+            raise ValueError(f'Property "AxisIndex" of "AxisMapping" is not integer value.')

zaber_motion/dto/gcode/axis_transformation.py

@@ -1,79 +1,79 @@
-# 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
-from ..measurement import Measurement
-
-
-@dataclass
-class AxisTransformation:
-    """
-    Represents a transformation of a translator axis.
-    """
-
-    axis_letter: str
-    """
-    Letter of the translator axis (X,Y,Z,A,B,C,E).
-    """
-
-    scaling: Optional[float] = None
-    """
-    Scaling factor.
-    """
-
-    translation: Optional[Measurement] = None
-    """
-    Translation distance.
-    """
-
-    @staticmethod
-    def zero_values() -> 'AxisTransformation':
-        return AxisTransformation(
-            axis_letter="",
-            scaling=None,
-            translation=None,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'AxisTransformation':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return AxisTransformation.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 {
-            'axisLetter': str(self.axis_letter or ''),
-            'scaling': float(self.scaling) if self.scaling is not None else None,
-            'translation': self.translation.to_dict() if self.translation is not None else None,
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'AxisTransformation':
-        return AxisTransformation(
-            axis_letter=data.get('axisLetter'),  # type: ignore
-            scaling=data.get('scaling'),  # type: ignore
-            translation=Measurement.from_dict(data.get('translation')) if data.get('translation') is not None else None,  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.axis_letter is not None:
-            if not isinstance(self.axis_letter, str):
-                raise ValueError(f'Property "AxisLetter" of "AxisTransformation" is not a string.')
-
-        if self.scaling is not None:
-            if not isinstance(self.scaling, (int, float, decimal.Decimal)):
-                raise ValueError(f'Property "Scaling" of "AxisTransformation" is not a number.')
-
-        if self.translation is not None:
-            if not isinstance(self.translation, Measurement):
-                raise ValueError(f'Property "Translation" of "AxisTransformation" is not an instance of "Measurement".')
-
-            self.translation.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, Optional
+import decimal
+import zaber_bson
+from ..measurement import Measurement
+
+
+@dataclass
+class AxisTransformation:
+    """
+    Represents a transformation of a translator axis.
+    """
+
+    axis_letter: str
+    """
+    Letter of the translator axis (X,Y,Z,A,B,C,E).
+    """
+
+    scaling: Optional[float] = None
+    """
+    Scaling factor.
+    """
+
+    translation: Optional[Measurement] = None
+    """
+    Translation distance.
+    """
+
+    @staticmethod
+    def zero_values() -> 'AxisTransformation':
+        return AxisTransformation(
+            axis_letter="",
+            scaling=None,
+            translation=None,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'AxisTransformation':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return AxisTransformation.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 {
+            'axisLetter': str(self.axis_letter or ''),
+            'scaling': float(self.scaling) if self.scaling is not None else None,
+            'translation': self.translation.to_dict() if self.translation is not None else None,
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'AxisTransformation':
+        return AxisTransformation(
+            axis_letter=data.get('axisLetter'),  # type: ignore
+            scaling=data.get('scaling'),  # type: ignore
+            translation=Measurement.from_dict(data.get('translation')) if data.get('translation') is not None else None,  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.axis_letter is not None:
+            if not isinstance(self.axis_letter, str):
+                raise ValueError(f'Property "AxisLetter" of "AxisTransformation" is not a string.')
+
+        if self.scaling is not None:
+            if not isinstance(self.scaling, (int, float, decimal.Decimal)):
+                raise ValueError(f'Property "Scaling" of "AxisTransformation" is not a number.')
+
+        if self.translation is not None:
+            if not isinstance(self.translation, Measurement):
+                raise ValueError(f'Property "Translation" of "AxisTransformation" is not an instance of "Measurement".')
+
+            self.translation.validate()