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

zaber_motion/product/process_controller.py

@@ -1,134 +1,134 @@
-# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
-# ============== DO NOT EDIT DIRECTLY ============== #
-
-from typing import List
-from ..call import call, call_sync, call_async
-
-from ..dto import requests as dto
-from ..ascii.device import Device
-from .process import Process
-from ..ascii.connection import Connection
-
-
-class ProcessController:
-    """
-    Use to manage a process controller.
-    Requires at least Firmware 7.35.
-    """
-
-    @property
-    def device(self) -> Device:
-        """
-        The base device of this process controller.
-        """
-        return self._device
-
-    def __init__(self, device: Device):
-        """
-        Creates instance of `ProcessController` of the given device.
-        If the device is identified, this constructor will ensure it is a process controller.
-        """
-        self._device: Device = device
-        self.__verify_is_process_controller()
-
-    @staticmethod
-    def detect(
-            connection: Connection,
-            identify: bool = True
-    ) -> List['ProcessController']:
-        """
-        Detects the process controllers on the connection.
-
-        Args:
-            connection: The connection to detect process controllers on.
-            identify: If the Process Controllers should be identified upon detection.
-
-        Returns:
-            A list of all `ProcessController`s on the connection.
-        """
-        request = dto.DeviceDetectRequest(
-            type=dto.DeviceType.PROCESS_CONTROLLER,
-            interface_id=connection.interface_id,
-            identify_devices=identify,
-        )
-        response = call(
-            "device/detect",
-            request,
-            dto.DeviceDetectResponse.from_binary)
-        return [ProcessController(connection.get_device(device)) for device in response.devices]
-
-    @staticmethod
-    async def detect_async(
-            connection: Connection,
-            identify: bool = True
-    ) -> List['ProcessController']:
-        """
-        Detects the process controllers on the connection.
-
-        Args:
-            connection: The connection to detect process controllers on.
-            identify: If the Process Controllers should be identified upon detection.
-
-        Returns:
-            A list of all `ProcessController`s on the connection.
-        """
-        request = dto.DeviceDetectRequest(
-            type=dto.DeviceType.PROCESS_CONTROLLER,
-            interface_id=connection.interface_id,
-            identify_devices=identify,
-        )
-        response = await call_async(
-            "device/detect",
-            request,
-            dto.DeviceDetectResponse.from_binary)
-        return [ProcessController(connection.get_device(device)) for device in response.devices]
-
-    def get_process(
-            self,
-            process_number: int
-    ) -> Process:
-        """
-        Gets an Process class instance which allows you to control a particular voltage source.
-        Axes are numbered from 1.
-
-        Args:
-            process_number: Number of process to control.
-
-        Returns:
-            Process instance.
-        """
-        if process_number <= 0:
-            raise ValueError('Invalid value; processes are numbered from 1.')
-
-        return Process(self, process_number)
-
-    def __verify_is_process_controller(
-            self
-    ) -> None:
-        """
-        Checks if this is a process controller or some other type of device and throws an error if it is not.
-        """
-        request = dto.DeviceEmptyRequest(
-            interface_id=self.device.connection.interface_id,
-            device=self.device.device_address,
-        )
-        call_sync("process_controller/verify", request)
-
-    def __repr__(
-            self
-    ) -> str:
-        """
-        Returns a string that represents the device.
-
-        Returns:
-            A string that represents the device.
-        """
-        request = dto.AxisToStringRequest(
-            interface_id=self.device.connection.interface_id,
-            device=self.device.device_address,
-        )
-        response = call_sync(
-            "device/device_to_string",
-            request,
-            dto.StringResponse.from_binary)
-        return response.value
+# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
+# ============== DO NOT EDIT DIRECTLY ============== #
+
+from typing import List
+from ..call import call, call_sync, call_async
+
+from ..dto import requests as dto
+from ..ascii.device import Device
+from .process import Process
+from ..ascii.connection import Connection
+
+
+class ProcessController:
+    """
+    Use to manage a process controller.
+    Requires at least Firmware 7.35.
+    """
+
+    @property
+    def device(self) -> Device:
+        """
+        The base device of this process controller.
+        """
+        return self._device
+
+    def __init__(self, device: Device):
+        """
+        Creates instance of `ProcessController` of the given device.
+        If the device is identified, this constructor will ensure it is a process controller.
+        """
+        self._device: Device = device
+        self.__verify_is_process_controller()
+
+    @staticmethod
+    def detect(
+            connection: Connection,
+            identify: bool = True
+    ) -> List['ProcessController']:
+        """
+        Detects the process controllers on the connection.
+
+        Args:
+            connection: The connection to detect process controllers on.
+            identify: If the Process Controllers should be identified upon detection.
+
+        Returns:
+            A list of all `ProcessController`s on the connection.
+        """
+        request = dto.DeviceDetectRequest(
+            type=dto.DeviceType.PROCESS_CONTROLLER,
+            interface_id=connection.interface_id,
+            identify_devices=identify,
+        )
+        response = call(
+            "device/detect",
+            request,
+            dto.DeviceDetectResponse.from_binary)
+        return [ProcessController(connection.get_device(device)) for device in response.devices]
+
+    @staticmethod
+    async def detect_async(
+            connection: Connection,
+            identify: bool = True
+    ) -> List['ProcessController']:
+        """
+        Detects the process controllers on the connection.
+
+        Args:
+            connection: The connection to detect process controllers on.
+            identify: If the Process Controllers should be identified upon detection.
+
+        Returns:
+            A list of all `ProcessController`s on the connection.
+        """
+        request = dto.DeviceDetectRequest(
+            type=dto.DeviceType.PROCESS_CONTROLLER,
+            interface_id=connection.interface_id,
+            identify_devices=identify,
+        )
+        response = await call_async(
+            "device/detect",
+            request,
+            dto.DeviceDetectResponse.from_binary)
+        return [ProcessController(connection.get_device(device)) for device in response.devices]
+
+    def get_process(
+            self,
+            process_number: int
+    ) -> Process:
+        """
+        Gets an Process class instance which allows you to control a particular voltage source.
+        Axes are numbered from 1.
+
+        Args:
+            process_number: Number of process to control.
+
+        Returns:
+            Process instance.
+        """
+        if process_number <= 0:
+            raise ValueError('Invalid value; processes are numbered from 1.')
+
+        return Process(self, process_number)
+
+    def __verify_is_process_controller(
+            self
+    ) -> None:
+        """
+        Checks if this is a process controller or some other type of device and throws an error if it is not.
+        """
+        request = dto.DeviceEmptyRequest(
+            interface_id=self.device.connection.interface_id,
+            device=self.device.device_address,
+        )
+        call_sync("process_controller/verify", request)
+
+    def __repr__(
+            self
+    ) -> str:
+        """
+        Returns a string that represents the device.
+
+        Returns:
+            A string that represents the device.
+        """
+        request = dto.AxisToStringRequest(
+            interface_id=self.device.connection.interface_id,
+            device=self.device.device_address,
+        )
+        response = call_sync(
+            "device/device_to_string",
+            request,
+            dto.StringResponse.from_binary)
+        return response.value

zaber_motion/serialization.py

@@ -1,32 +1,32 @@
-import struct
-from ctypes import string_at, c_void_p
-from functools import reduce
-from typing import List
-
-SIZE_TYPE_SIZE = 4
-SIZE_TYPE_PACKING = "I"
-
-
-def serialize(buffers: List[bytes]) -> bytes:
-    size = SIZE_TYPE_SIZE + reduce((lambda sum, buffer: sum + len(buffer) + SIZE_TYPE_SIZE), buffers, 0)
-
-    buffer = struct.pack(SIZE_TYPE_PACKING, size)
-
-    for messageBuffer in buffers:
-        buffer = buffer + struct.pack(SIZE_TYPE_PACKING, len(messageBuffer)) + bytes(messageBuffer)
-
-    return buffer
-
-
-def deserialize(data: c_void_p) -> List[bytes]:
-    total_size = struct.unpack_from(SIZE_TYPE_PACKING, string_at(data, SIZE_TYPE_SIZE))[0]
-    offset = SIZE_TYPE_SIZE
-
-    buffers = []
-    while offset < total_size:
-        size = struct.unpack_from(SIZE_TYPE_PACKING, string_at(data + offset, SIZE_TYPE_SIZE))[0]  # type: ignore
-        offset += SIZE_TYPE_SIZE
-        buffers.append(string_at(data + offset, size))  # type: ignore
-        offset += size
-
-    return buffers
+import struct
+from ctypes import string_at, c_void_p
+from functools import reduce
+from typing import List
+
+SIZE_TYPE_SIZE = 4
+SIZE_TYPE_PACKING = "I"
+
+
+def serialize(buffers: List[bytes]) -> bytes:
+    size = SIZE_TYPE_SIZE + reduce((lambda sum, buffer: sum + len(buffer) + SIZE_TYPE_SIZE), buffers, 0)
+
+    buffer = struct.pack(SIZE_TYPE_PACKING, size)
+
+    for messageBuffer in buffers:
+        buffer = buffer + struct.pack(SIZE_TYPE_PACKING, len(messageBuffer)) + bytes(messageBuffer)
+
+    return buffer
+
+
+def deserialize(data: c_void_p) -> List[bytes]:
+    total_size = struct.unpack_from(SIZE_TYPE_PACKING, string_at(data, SIZE_TYPE_SIZE))[0]
+    offset = SIZE_TYPE_SIZE
+
+    buffers = []
+    while offset < total_size:
+        size = struct.unpack_from(SIZE_TYPE_PACKING, string_at(data + offset, SIZE_TYPE_SIZE))[0]  # type: ignore
+        offset += SIZE_TYPE_SIZE
+        buffers.append(string_at(data + offset, size))  # type: ignore
+        offset += size
+
+    return buffers

zaber_motion/tools.py

@@ -1,78 +1,78 @@
-# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
-# ============== DO NOT EDIT DIRECTLY ============== #
-
-from typing import List
-from .call import call, call_async, call_sync
-from .dto import requests as dto
-
-
-class Tools:
-    """
-    Class providing various utility functions.
-    """
-
-    @staticmethod
-    def list_serial_ports() -> List[str]:
-        """
-        Lists all serial ports on the computer.
-
-        Returns:
-            Array of serial port names.
-        """
-        request = dto.EmptyRequest(
-        )
-        response = call(
-            "tools/list_serial_ports",
-            request,
-            dto.ToolsListSerialPortsResponse.from_binary)
-        return response.ports
-
-    @staticmethod
-    async def list_serial_ports_async() -> List[str]:
-        """
-        Lists all serial ports on the computer.
-
-        Returns:
-            Array of serial port names.
-        """
-        request = dto.EmptyRequest(
-        )
-        response = await call_async(
-            "tools/list_serial_ports",
-            request,
-            dto.ToolsListSerialPortsResponse.from_binary)
-        return response.ports
-
-    @staticmethod
-    def get_message_router_pipe_path() -> str:
-        """
-        Returns path of message router named pipe on Windows
-        or file path of unix domain socket on UNIX.
-
-        Returns:
-            Path of message router's named pipe or unix domain socket.
-        """
-        request = dto.EmptyRequest(
-        )
-        response = call_sync(
-            "tools/get_message_router_pipe",
-            request,
-            dto.StringResponse.from_binary)
-        return response.value
-
-    @staticmethod
-    def get_db_service_pipe_path() -> str:
-        """
-        Returns the path for communicating with a local device database service.
-        This will be a named pipe on Windows and the file path of a unix domain socket on UNIX.
-
-        Returns:
-            Path of database service's named pipe or unix domain socket.
-        """
-        request = dto.EmptyRequest(
-        )
-        response = call_sync(
-            "tools/get_db_service_pipe",
-            request,
-            dto.StringResponse.from_binary)
-        return response.value
+# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
+# ============== DO NOT EDIT DIRECTLY ============== #
+
+from typing import List
+from .call import call, call_async, call_sync
+from .dto import requests as dto
+
+
+class Tools:
+    """
+    Class providing various utility functions.
+    """
+
+    @staticmethod
+    def list_serial_ports() -> List[str]:
+        """
+        Lists all serial ports on the computer.
+
+        Returns:
+            Array of serial port names.
+        """
+        request = dto.EmptyRequest(
+        )
+        response = call(
+            "tools/list_serial_ports",
+            request,
+            dto.ToolsListSerialPortsResponse.from_binary)
+        return response.ports
+
+    @staticmethod
+    async def list_serial_ports_async() -> List[str]:
+        """
+        Lists all serial ports on the computer.
+
+        Returns:
+            Array of serial port names.
+        """
+        request = dto.EmptyRequest(
+        )
+        response = await call_async(
+            "tools/list_serial_ports",
+            request,
+            dto.ToolsListSerialPortsResponse.from_binary)
+        return response.ports
+
+    @staticmethod
+    def get_message_router_pipe_path() -> str:
+        """
+        Returns path of message router named pipe on Windows
+        or file path of unix domain socket on UNIX.
+
+        Returns:
+            Path of message router's named pipe or unix domain socket.
+        """
+        request = dto.EmptyRequest(
+        )
+        response = call_sync(
+            "tools/get_message_router_pipe",
+            request,
+            dto.StringResponse.from_binary)
+        return response.value
+
+    @staticmethod
+    def get_db_service_pipe_path() -> str:
+        """
+        Returns the path for communicating with a local device database service.
+        This will be a named pipe on Windows and the file path of a unix domain socket on UNIX.
+
+        Returns:
+            Path of database service's named pipe or unix domain socket.
+        """
+        request = dto.EmptyRequest(
+        )
+        response = call_sync(
+            "tools/get_db_service_pipe",
+            request,
+            dto.StringResponse.from_binary)
+        return response.value

zaber_motion/unit_table.py

@@ -1,86 +1,86 @@
-# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
-# ============== DO NOT EDIT DIRECTLY ============== #
-
-from .call import call_sync
-from .dto import requests as dto
-from .units import UnitsAndLiterals
-
-
-class UnitTable:
-    """
-    Helper for working with units of measure.
-    """
-
-    @staticmethod
-    def get_symbol(
-            unit: UnitsAndLiterals
-    ) -> str:
-        """
-        Gets the standard symbol associated with a given unit.
-
-        Args:
-            unit: Unit of measure.
-
-        Returns:
-            Symbols corresponding to the given unit. Throws NoValueForKey if no symbol is defined.
-        """
-        request = dto.UnitGetSymbolRequest(
-            unit=unit,
-        )
-        response = call_sync(
-            "units/get_symbol",
-            request,
-            dto.UnitGetSymbolResponse.from_binary)
-        return response.symbol
-
-    @staticmethod
-    def get_unit(
-            symbol: str
-    ) -> UnitsAndLiterals:
-        """
-        Gets the unit enum value associated with a standard symbol.
-        Note not all units can be retrieved this way.
-
-        Args:
-            symbol: Symbol to look up.
-
-        Returns:
-            The unit enum value with the given symbols. Throws NoValueForKey if the symbol is not supported for lookup.
-        """
-        request = dto.UnitGetEnumRequest(
-            symbol=symbol,
-        )
-        response = call_sync(
-            "units/get_enum",
-            request,
-            dto.UnitGetEnumResponse.from_binary)
-        return response.unit
-
-    @staticmethod
-    def convert_units(
-            value: float,
-            from_unit: UnitsAndLiterals,
-            to_unit: UnitsAndLiterals
-    ) -> float:
-        """
-        Converts a value from one unit to a different unit of the same dimension.
-        Note that this function does not support native unit conversions.
-
-        Args:
-            value: The value to be converted.
-            from_unit: The unit which the value is being converted from.
-            to_unit: The unit which the value is being converted to.
-
-        Returns:
-            The converted value. Throws ConversionFailedException if unit is incompatible.
-        """
-        request = dto.UnitConvertUnitRequest(
-            value=value,
-            from_unit=from_unit,
-            to_unit=to_unit,
-        )
-        response = call_sync(
-            "units/convert_unit",
-            request,
-            dto.DoubleResponse.from_binary)
-        return response.value
+# ===== THIS FILE IS GENERATED FROM A TEMPLATE ===== #
+# ============== DO NOT EDIT DIRECTLY ============== #
+
+from .call import call_sync
+from .dto import requests as dto
+from .units import UnitsAndLiterals
+
+
+class UnitTable:
+    """
+    Helper for working with units of measure.
+    """
+
+    @staticmethod
+    def get_symbol(
+            unit: UnitsAndLiterals
+    ) -> str:
+        """
+        Gets the standard symbol associated with a given unit.
+
+        Args:
+            unit: Unit of measure.
+
+        Returns:
+            Symbols corresponding to the given unit. Throws NoValueForKey if no symbol is defined.
+        """
+        request = dto.UnitGetSymbolRequest(
+            unit=unit,
+        )
+        response = call_sync(
+            "units/get_symbol",
+            request,
+            dto.UnitGetSymbolResponse.from_binary)
+        return response.symbol
+
+    @staticmethod
+    def get_unit(
+            symbol: str
+    ) -> UnitsAndLiterals:
+        """
+        Gets the unit enum value associated with a standard symbol.
+        Note not all units can be retrieved this way.
+
+        Args:
+            symbol: Symbol to look up.
+
+        Returns:
+            The unit enum value with the given symbols. Throws NoValueForKey if the symbol is not supported for lookup.
+        """
+        request = dto.UnitGetEnumRequest(
+            symbol=symbol,
+        )
+        response = call_sync(
+            "units/get_enum",
+            request,
+            dto.UnitGetEnumResponse.from_binary)
+        return response.unit
+
+    @staticmethod
+    def convert_units(
+            value: float,
+            from_unit: UnitsAndLiterals,
+            to_unit: UnitsAndLiterals
+    ) -> float:
+        """
+        Converts a value from one unit to a different unit of the same dimension.
+        Note that this function does not support native unit conversions.
+
+        Args:
+            value: The value to be converted.
+            from_unit: The unit which the value is being converted from.
+            to_unit: The unit which the value is being converted to.
+
+        Returns:
+            The converted value. Throws ConversionFailedException if unit is incompatible.
+        """
+        request = dto.UnitConvertUnitRequest(
+            value=value,
+            from_unit=from_unit,
+            to_unit=to_unit,
+        )
+        response = call_sync(
+            "units/convert_unit",
+            request,
+            dto.DoubleResponse.from_binary)
+        return response.value