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

zaber_motion/dto/ascii/paramset_info.py

@@ -1,92 +1,92 @@
-# 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
-import decimal
-from collections.abc import Iterable
-import zaber_bson
-from .servo_tuning_param import ServoTuningParam
-
-
-@dataclass
-class ParamsetInfo:
-    """
-    The raw parameters currently saved to a given paramset.
-    """
-
-    type: str
-    """
-    The tuning algorithm used for this axis.
-    """
-
-    version: int
-    """
-    The version of the tuning algorithm used for this axis.
-    """
-
-    params: List[ServoTuningParam]
-    """
-    The raw tuning parameters of this device.
-    """
-
-    @staticmethod
-    def zero_values() -> 'ParamsetInfo':
-        return ParamsetInfo(
-            type="",
-            version=0,
-            params=[],
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'ParamsetInfo':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return ParamsetInfo.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 {
-            'type': str(self.type or ''),
-            'version': int(self.version),
-            'params': [item.to_dict() for item in self.params] if self.params is not None else [],
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'ParamsetInfo':
-        return ParamsetInfo(
-            type=data.get('type'),  # type: ignore
-            version=data.get('version'),  # type: ignore
-            params=[ServoTuningParam.from_dict(item) for item in data.get('params')],  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.type is not None:
-            if not isinstance(self.type, str):
-                raise ValueError(f'Property "Type" of "ParamsetInfo" is not a string.')
-
-        if self.version is None:
-            raise ValueError(f'Property "Version" of "ParamsetInfo" is None.')
-
-        if not isinstance(self.version, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Version" of "ParamsetInfo" is not a number.')
-
-        if int(self.version) != self.version:
-            raise ValueError(f'Property "Version" of "ParamsetInfo" is not integer value.')
-
-        if self.params is not None:
-            if not isinstance(self.params, Iterable):
-                raise ValueError('Property "Params" of "ParamsetInfo" is not iterable.')
-
-            for i, params_item in enumerate(self.params):
-                if params_item is None:
-                    raise ValueError(f'Item {i} in property "Params" of "ParamsetInfo" is None.')
-
-                if not isinstance(params_item, ServoTuningParam):
-                    raise ValueError(f'Item {i} in property "Params" of "ParamsetInfo" is not an instance of "ServoTuningParam".')
-
-                params_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
+import decimal
+from collections.abc import Iterable
+import zaber_bson
+from .servo_tuning_param import ServoTuningParam
+
+
+@dataclass
+class ParamsetInfo:
+    """
+    The raw parameters currently saved to a given paramset.
+    """
+
+    type: str
+    """
+    The tuning algorithm used for this axis.
+    """
+
+    version: int
+    """
+    The version of the tuning algorithm used for this axis.
+    """
+
+    params: List[ServoTuningParam]
+    """
+    The raw tuning parameters of this device.
+    """
+
+    @staticmethod
+    def zero_values() -> 'ParamsetInfo':
+        return ParamsetInfo(
+            type="",
+            version=0,
+            params=[],
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'ParamsetInfo':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return ParamsetInfo.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 {
+            'type': str(self.type or ''),
+            'version': int(self.version),
+            'params': [item.to_dict() for item in self.params] if self.params is not None else [],
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'ParamsetInfo':
+        return ParamsetInfo(
+            type=data.get('type'),  # type: ignore
+            version=data.get('version'),  # type: ignore
+            params=[ServoTuningParam.from_dict(item) for item in data.get('params')],  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.type is not None:
+            if not isinstance(self.type, str):
+                raise ValueError(f'Property "Type" of "ParamsetInfo" is not a string.')
+
+        if self.version is None:
+            raise ValueError(f'Property "Version" of "ParamsetInfo" is None.')
+
+        if not isinstance(self.version, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Version" of "ParamsetInfo" is not a number.')
+
+        if int(self.version) != self.version:
+            raise ValueError(f'Property "Version" of "ParamsetInfo" is not integer value.')
+
+        if self.params is not None:
+            if not isinstance(self.params, Iterable):
+                raise ValueError('Property "Params" of "ParamsetInfo" is not iterable.')
+
+            for i, params_item in enumerate(self.params):
+                if params_item is None:
+                    raise ValueError(f'Item {i} in property "Params" of "ParamsetInfo" is None.')
+
+                if not isinstance(params_item, ServoTuningParam):
+                    raise ValueError(f'Item {i} in property "Params" of "ParamsetInfo" is not an instance of "ServoTuningParam".')
+
+                params_item.validate()

zaber_motion/dto/ascii/pid_tuning.py

@@ -1,125 +1,125 @@
-# 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 PidTuning:
-    """
-    The tuning of this axis represented by PID parameters.
-    """
-
-    type: str
-    """
-    The tuning algorithm used to tune this axis.
-    """
-
-    version: int
-    """
-    The version of the tuning algorithm used to tune this axis.
-    """
-
-    p: float
-    """
-    The positional tuning argument.
-    """
-
-    i: float
-    """
-    The integral tuning argument.
-    """
-
-    d: float
-    """
-    The derivative tuning argument.
-    """
-
-    fc: float
-    """
-    The frequency cutoff for the tuning.
-    """
-
-    @staticmethod
-    def zero_values() -> 'PidTuning':
-        return PidTuning(
-            type="",
-            version=0,
-            p=0,
-            i=0,
-            d=0,
-            fc=0,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'PidTuning':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return PidTuning.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 {
-            'type': str(self.type or ''),
-            'version': int(self.version),
-            'p': float(self.p),
-            'i': float(self.i),
-            'd': float(self.d),
-            'fc': float(self.fc),
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'PidTuning':
-        return PidTuning(
-            type=data.get('type'),  # type: ignore
-            version=data.get('version'),  # type: ignore
-            p=data.get('p'),  # type: ignore
-            i=data.get('i'),  # type: ignore
-            d=data.get('d'),  # type: ignore
-            fc=data.get('fc'),  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.type is not None:
-            if not isinstance(self.type, str):
-                raise ValueError(f'Property "Type" of "PidTuning" is not a string.')
-
-        if self.version is None:
-            raise ValueError(f'Property "Version" of "PidTuning" is None.')
-
-        if not isinstance(self.version, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Version" of "PidTuning" is not a number.')
-
-        if int(self.version) != self.version:
-            raise ValueError(f'Property "Version" of "PidTuning" is not integer value.')
-
-        if self.p is None:
-            raise ValueError(f'Property "P" of "PidTuning" is None.')
-
-        if not isinstance(self.p, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "P" of "PidTuning" is not a number.')
-
-        if self.i is None:
-            raise ValueError(f'Property "I" of "PidTuning" is None.')
-
-        if not isinstance(self.i, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "I" of "PidTuning" is not a number.')
-
-        if self.d is None:
-            raise ValueError(f'Property "D" of "PidTuning" is None.')
-
-        if not isinstance(self.d, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "D" of "PidTuning" is not a number.')
-
-        if self.fc is None:
-            raise ValueError(f'Property "Fc" of "PidTuning" is None.')
-
-        if not isinstance(self.fc, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "Fc" of "PidTuning" is not a number.')
+# 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 PidTuning:
+    """
+    The tuning of this axis represented by PID parameters.
+    """
+
+    type: str
+    """
+    The tuning algorithm used to tune this axis.
+    """
+
+    version: int
+    """
+    The version of the tuning algorithm used to tune this axis.
+    """
+
+    p: float
+    """
+    The positional tuning argument.
+    """
+
+    i: float
+    """
+    The integral tuning argument.
+    """
+
+    d: float
+    """
+    The derivative tuning argument.
+    """
+
+    fc: float
+    """
+    The frequency cutoff for the tuning.
+    """
+
+    @staticmethod
+    def zero_values() -> 'PidTuning':
+        return PidTuning(
+            type="",
+            version=0,
+            p=0,
+            i=0,
+            d=0,
+            fc=0,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'PidTuning':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return PidTuning.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 {
+            'type': str(self.type or ''),
+            'version': int(self.version),
+            'p': float(self.p),
+            'i': float(self.i),
+            'd': float(self.d),
+            'fc': float(self.fc),
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'PidTuning':
+        return PidTuning(
+            type=data.get('type'),  # type: ignore
+            version=data.get('version'),  # type: ignore
+            p=data.get('p'),  # type: ignore
+            i=data.get('i'),  # type: ignore
+            d=data.get('d'),  # type: ignore
+            fc=data.get('fc'),  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.type is not None:
+            if not isinstance(self.type, str):
+                raise ValueError(f'Property "Type" of "PidTuning" is not a string.')
+
+        if self.version is None:
+            raise ValueError(f'Property "Version" of "PidTuning" is None.')
+
+        if not isinstance(self.version, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Version" of "PidTuning" is not a number.')
+
+        if int(self.version) != self.version:
+            raise ValueError(f'Property "Version" of "PidTuning" is not integer value.')
+
+        if self.p is None:
+            raise ValueError(f'Property "P" of "PidTuning" is None.')
+
+        if not isinstance(self.p, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "P" of "PidTuning" is not a number.')
+
+        if self.i is None:
+            raise ValueError(f'Property "I" of "PidTuning" is None.')
+
+        if not isinstance(self.i, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "I" of "PidTuning" is not a number.')
+
+        if self.d is None:
+            raise ValueError(f'Property "D" of "PidTuning" is None.')
+
+        if not isinstance(self.d, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "D" of "PidTuning" is not a number.')
+
+        if self.fc is None:
+            raise ValueError(f'Property "Fc" of "PidTuning" is None.')
+
+        if not isinstance(self.fc, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "Fc" of "PidTuning" is not a number.')

zaber_motion/dto/ascii/pvt_axis_definition.py

@@ -1,70 +1,70 @@
-# 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 .pvt_axis_type import PvtAxisType
-
-
-@dataclass
-class PvtAxisDefinition:
-    """
-    Defines an axis of the PVT sequence.
-    """
-
-    axis_number: int
-    """
-    Number of a physical axis or a lockstep group.
-    """
-
-    axis_type: Optional[PvtAxisType] = None
-    """
-    Defines the type of the axis.
-    """
-
-    @staticmethod
-    def zero_values() -> 'PvtAxisDefinition':
-        return PvtAxisDefinition(
-            axis_number=0,
-            axis_type=None,
-        )
-
-    @staticmethod
-    def from_binary(data_bytes: bytes) -> 'PvtAxisDefinition':
-        """" Deserialize a binary representation of this class. """
-        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
-        return PvtAxisDefinition.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 {
-            'axisNumber': int(self.axis_number),
-            'axisType': self.axis_type.value if self.axis_type is not None else None,
-        }
-
-    @staticmethod
-    def from_dict(data: Dict[str, Any]) -> 'PvtAxisDefinition':
-        return PvtAxisDefinition(
-            axis_number=data.get('axisNumber'),  # type: ignore
-            axis_type=PvtAxisType(data.get('axisType')) if data.get('axisType') is not None else None,  # type: ignore
-        )
-
-    def validate(self) -> None:
-        """" Validates the properties of the instance. """
-        if self.axis_number is None:
-            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is None.')
-
-        if not isinstance(self.axis_number, (int, float, decimal.Decimal)):
-            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is not a number.')
-
-        if int(self.axis_number) != self.axis_number:
-            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is not integer value.')
-
-        if self.axis_type is not None:
-            if not isinstance(self.axis_type, PvtAxisType):
-                raise ValueError(f'Property "AxisType" of "PvtAxisDefinition" is not an instance of "PvtAxisType".')
+# 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 .pvt_axis_type import PvtAxisType
+
+
+@dataclass
+class PvtAxisDefinition:
+    """
+    Defines an axis of the PVT sequence.
+    """
+
+    axis_number: int
+    """
+    Number of a physical axis or a lockstep group.
+    """
+
+    axis_type: Optional[PvtAxisType] = None
+    """
+    Defines the type of the axis.
+    """
+
+    @staticmethod
+    def zero_values() -> 'PvtAxisDefinition':
+        return PvtAxisDefinition(
+            axis_number=0,
+            axis_type=None,
+        )
+
+    @staticmethod
+    def from_binary(data_bytes: bytes) -> 'PvtAxisDefinition':
+        """" Deserialize a binary representation of this class. """
+        data = zaber_bson.loads(data_bytes)  # type: Dict[str, Any]
+        return PvtAxisDefinition.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 {
+            'axisNumber': int(self.axis_number),
+            'axisType': self.axis_type.value if self.axis_type is not None else None,
+        }
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> 'PvtAxisDefinition':
+        return PvtAxisDefinition(
+            axis_number=data.get('axisNumber'),  # type: ignore
+            axis_type=PvtAxisType(data.get('axisType')) if data.get('axisType') is not None else None,  # type: ignore
+        )
+
+    def validate(self) -> None:
+        """" Validates the properties of the instance. """
+        if self.axis_number is None:
+            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is None.')
+
+        if not isinstance(self.axis_number, (int, float, decimal.Decimal)):
+            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is not a number.')
+
+        if int(self.axis_number) != self.axis_number:
+            raise ValueError(f'Property "AxisNumber" of "PvtAxisDefinition" is not integer value.')
+
+        if self.axis_type is not None:
+            if not isinstance(self.axis_type, PvtAxisType):
+                raise ValueError(f'Property "AxisType" of "PvtAxisDefinition" is not an instance of "PvtAxisType".')

zaber_motion/dto/ascii/pvt_axis_type.py

@@ -1,11 +1,11 @@
-# This file is generated. Do not modify by hand.
-from enum import Enum
-
-
-class PvtAxisType(Enum):
-    """
-    Denotes type of the PVT sequence axis.
-    """
-
-    PHYSICAL = 0
-    LOCKSTEP = 1
+# This file is generated. Do not modify by hand.
+from enum import Enum
+
+
+class PvtAxisType(Enum):
+    """
+    Denotes type of the PVT sequence axis.
+    """
+
+    PHYSICAL = 0
+    LOCKSTEP = 1