ephys-link 2.0.0__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

ephys_link/bindings/mpm_binding.py

@@ -1,315 +0,0 @@
-"""Bindings for New Scale Pathfinder MPM HTTP server platform.
-
-Usage: Instantiate MPMBindings to interact with the New Scale Pathfinder MPM HTTP server platform.
-"""
-
-from asyncio import get_running_loop, sleep
-from json import dumps
-from typing import Any, final, override
-
-from requests import JSONDecodeError, get, put
-from vbl_aquarium.models.unity import Vector3, Vector4
-
-from ephys_link.utils.base_binding import BaseBinding
-from ephys_link.utils.converters import scalar_mm_to_um, vector4_to_array
-
-
-@final
-class MPMBinding(BaseBinding):
-    """Bindings for New Scale Pathfinder MPM HTTP server platform."""
-
-    # Valid New Scale manipulator IDs
-    VALID_MANIPULATOR_IDS = (
-        "A",
-        "B",
-        "C",
-        "D",
-        "E",
-        "F",
-        "G",
-        "H",
-        "I",
-        "J",
-        "K",
-        "L",
-        "M",
-        "N",
-        "O",
-        "P",
-        "Q",
-        "R",
-        "S",
-        "T",
-        "U",
-        "V",
-        "W",
-        "X",
-        "Y",
-        "Z",
-        "AA",
-        "AB",
-        "AC",
-        "AD",
-        "AE",
-        "AF",
-        "AG",
-        "AH",
-        "AI",
-        "AJ",
-        "AK",
-        "AL",
-        "AM",
-        "AN",
-    )
-
-    # Server cache lifetime (60 FPS).
-    CACHE_LIFETIME = 1 / 60
-
-    # Movement polling preferences.
-    UNCHANGED_COUNTER_LIMIT = 10
-    POLL_INTERVAL = 0.1
-
-    # Speed preferences (mm/s to use coarse mode).
-    COARSE_SPEED_THRESHOLD = 0.1
-    INSERTION_SPEED_LIMIT = 9_000
-
-    def __init__(self, port: int = 8080) -> None:
-        """Initialize connection to MPM HTTP server.
-
-        Args:
-            port: Port number for MPM HTTP server.
-        """
-        self._url = f"http://localhost:{port}"
-        self._movement_stopped = False
-
-        # Data cache.
-        self.cache: dict[str, Any] = {}  # pyright: ignore [reportExplicitAny]
-        self.cache_time = 0
-
-    @staticmethod
-    @override
-    def get_display_name() -> str:
-        return "Pathfinder MPM Control v2.8.8+"
-
-    @staticmethod
-    @override
-    def get_cli_name() -> str:
-        return "pathfinder-mpm"
-
-    @override
-    async def get_manipulators(self) -> list[str]:
-        return [manipulator["Id"] for manipulator in (await self._query_data())["ProbeArray"]]  # pyright: ignore [reportAny]
-
-    @override
-    async def get_axes_count(self) -> int:
-        return 3
-
-    @override
-    def get_dimensions(self) -> Vector4:
-        return Vector4(x=15, y=15, z=15, w=15)
-
-    @override
-    async def get_position(self, manipulator_id: str) -> Vector4:
-        manipulator_data: dict[str, float] = await self._manipulator_data(manipulator_id)
-        stage_z: float = manipulator_data["Stage_Z"]
-
-        await sleep(self.POLL_INTERVAL)  # Wait for the stage to stabilize.
-
-        return Vector4(
-            x=manipulator_data["Stage_X"],
-            y=manipulator_data["Stage_Y"],
-            z=stage_z,
-            w=stage_z,
-        )
-
-    @override
-    async def get_angles(self, manipulator_id: str) -> Vector3:
-        manipulator_data: dict[str, float] = await self._manipulator_data(manipulator_id)
-
-        # Apply PosteriorAngle to Polar to get the correct angle.
-        adjusted_polar: int = manipulator_data["Polar"] - (await self._query_data())["PosteriorAngle"]
-
-        return Vector3(
-            x=adjusted_polar if adjusted_polar > 0 else 360 + adjusted_polar,
-            y=manipulator_data["Pitch"],
-            z=manipulator_data["ShankOrientation"],
-        )
-
-    @override
-    async def get_shank_count(self, manipulator_id: str) -> int:
-        return int((await self._manipulator_data(manipulator_id))["ShankCount"])  # pyright: ignore [reportAny]
-
-    @override
-    def get_movement_tolerance(self) -> float:
-        return 0.01
-
-    @override
-    async def set_position(self, manipulator_id: str, position: Vector4, speed: float) -> Vector4:
-        # Keep track of the previous position to check if the manipulator stopped advancing.
-        current_position = await self.get_position(manipulator_id)
-        previous_position = current_position
-        unchanged_counter = 0
-
-        # Set step mode based on speed.
-        await self._put_request(
-            {
-                "PutId": "ProbeStepMode",
-                "Probe": self.VALID_MANIPULATOR_IDS.index(manipulator_id),
-                "StepMode": 0 if speed > self.COARSE_SPEED_THRESHOLD else 1,
-            }
-        )
-
-        # Send move request.
-        await self._put_request(
-            {
-                "PutId": "ProbeMotion",
-                "Probe": self.VALID_MANIPULATOR_IDS.index(manipulator_id),
-                "Absolute": 1,
-                "Stereotactic": 0,
-                "AxisMask": 7,
-                "X": position.x,
-                "Y": position.y,
-                "Z": position.z,
-            }
-        )
-
-        # Wait for the manipulator to reach the target position or be stopped or stuck.
-        while (
-            not self._movement_stopped
-            and not self._is_vector_close(current_position, position)
-            and unchanged_counter < self.UNCHANGED_COUNTER_LIMIT
-        ):
-            # Wait for a short time before checking again.
-            await sleep(self.POLL_INTERVAL)
-
-            # Update current position.
-            current_position = await self.get_position(manipulator_id)
-
-            # Check if manipulator is not moving.
-            if self._is_vector_close(previous_position, current_position):
-                # Position did not change.
-                unchanged_counter += 1
-            else:
-                # Position changed.
-                unchanged_counter = 0
-                previous_position = current_position
-
-        # Reset movement stopped flag.
-        self._movement_stopped = False
-
-        # Return the final position.
-        return await self.get_position(manipulator_id)
-
-    @override
-    async def set_depth(self, manipulator_id: str, depth: float, speed: float) -> float:
-        # Keep track of the previous depth to check if the manipulator stopped advancing unexpectedly.
-        current_depth = (await self.get_position(manipulator_id)).w
-        previous_depth = current_depth
-        unchanged_counter = 0
-
-        # Send move request.
-        # Convert mm/s to um/min and cap speed at the limit.
-        await self._put_request(
-            {
-                "PutId": "ProbeInsertion",
-                "Probe": self.VALID_MANIPULATOR_IDS.index(manipulator_id),
-                "Distance": scalar_mm_to_um(current_depth - depth),
-                "Rate": min(scalar_mm_to_um(speed) * 60, self.INSERTION_SPEED_LIMIT),
-            }
-        )
-
-        # Wait for the manipulator to reach the target depth or be stopped or get stuck.
-        while not self._movement_stopped and not abs(current_depth - depth) <= self.get_movement_tolerance():
-            # Wait for a short time before checking again.
-            await sleep(self.POLL_INTERVAL)
-
-            # Get the current depth.
-            current_depth = (await self.get_position(manipulator_id)).w
-
-            # Check if manipulator is not moving.
-            if abs(previous_depth - current_depth) <= self.get_movement_tolerance():
-                # Depth did not change.
-                unchanged_counter += 1
-            else:
-                # Depth changed.
-                unchanged_counter = 0
-                previous_depth = current_depth
-
-        # Reset movement stopped flag.
-        self._movement_stopped = False
-
-        # Return the final depth.
-        return float((await self.get_position(manipulator_id)).w)
-
-    @override
-    async def stop(self, manipulator_id: str) -> None:
-        request: dict[str, str | int | float] = {
-            "PutId": "ProbeStop",
-            "Probe": self.VALID_MANIPULATOR_IDS.index(manipulator_id),
-        }
-        await self._put_request(request)
-        self._movement_stopped = True
-
-    @override
-    def platform_space_to_unified_space(self, platform_space: Vector4) -> Vector4:
-        # unified   <-  platform
-        # +x        <-  -x
-        # +y        <-  +z
-        # +z        <-  +y
-        # +w        <-  -w
-
-        return Vector4(
-            x=self.get_dimensions().x - platform_space.x,
-            y=platform_space.z,
-            z=platform_space.y,
-            w=self.get_dimensions().w - platform_space.w,
-        )
-
-    @override
-    def unified_space_to_platform_space(self, unified_space: Vector4) -> Vector4:
-        # platform  <-  unified
-        # +x        <-  -x
-        # +y        <-  +z
-        # +z        <-  +y
-        # +w        <-  -w
-
-        return Vector4(
-            x=self.get_dimensions().x - unified_space.x,
-            y=unified_space.z,
-            z=unified_space.y,
-            w=self.get_dimensions().w - unified_space.w,
-        )
-
-    # Helper functions.
-    async def _query_data(self) -> dict[str, Any]:  # pyright: ignore [reportExplicitAny]
-        try:
-            # Update cache if it's expired.
-            if get_running_loop().time() - self.cache_time > self.CACHE_LIFETIME:
-                # noinspection PyTypeChecker
-                self.cache = (await get_running_loop().run_in_executor(None, get, self._url)).json()
-                self.cache_time = get_running_loop().time()
-        except ConnectionError as connectionError:
-            error_message = f"Unable to connect to MPM HTTP server: {connectionError}"
-            raise RuntimeError(error_message) from connectionError
-        except JSONDecodeError as jsonDecodeError:
-            error_message = f"Unable to decode JSON response from MPM HTTP server: {jsonDecodeError}"
-            raise ValueError(error_message) from jsonDecodeError
-        else:
-            # Return cached data.
-            return self.cache
-
-    async def _manipulator_data(self, manipulator_id: str) -> dict[str, Any]:  # pyright: ignore [reportExplicitAny]
-        probe_data: list[dict[str, Any]] = (await self._query_data())["ProbeArray"]  # pyright: ignore [reportExplicitAny]
-        for probe in probe_data:
-            if probe["Id"] == manipulator_id:
-                return probe
-
-        # If we get here, that means the manipulator doesn't exist.
-        error_message = f"Manipulator {manipulator_id} not found."
-        raise ValueError(error_message)
-
-    async def _put_request(self, request: dict[str, Any]) -> None:  # pyright: ignore [reportExplicitAny]
-        _ = await get_running_loop().run_in_executor(None, put, self._url, dumps(request))
-
-    def _is_vector_close(self, target: Vector4, current: Vector4) -> bool:
-        return all(abs(axis) <= self.get_movement_tolerance() for axis in vector4_to_array(target - current)[:3])

ephys_link/bindings/ump_4_binding.py

@@ -1,157 +0,0 @@
-"""Bindings for Sensapex uMp-4 platform.
-
-Usage: Instantiate Ump4Bindings to interact with the Sensapex uMp-4 platform.
-"""
-
-from asyncio import get_running_loop
-from typing import NoReturn, final, override
-
-from sensapex import UMP, SensapexDevice  # pyright: ignore [reportMissingTypeStubs]
-from vbl_aquarium.models.unity import Vector4
-
-from ephys_link.utils.base_binding import BaseBinding
-from ephys_link.utils.constants import RESOURCES_DIRECTORY
-from ephys_link.utils.converters import (
-    list_to_vector4,
-    scalar_mm_to_um,
-    um_to_mm,
-    vector4_to_array,
-    vector_mm_to_um,
-)
-
-
-@final
-class Ump4Binding(BaseBinding):
-    """Bindings for UMP-4 platform"""
-
-    def __init__(self) -> None:
-        """Initialize UMP-4 bindings."""
-
-        # Establish connection to Sensapex API (exit if connection fails).
-        UMP.set_library_path(RESOURCES_DIRECTORY)
-        self._ump = UMP.get_ump()  # pyright: ignore [reportUnknownMemberType]
-
-    @staticmethod
-    @override
-    def get_display_name() -> str:
-        return "Sensapex uMp-4"
-
-    @staticmethod
-    @override
-    def get_cli_name() -> str:
-        return "ump-4"
-
-    @override
-    async def get_manipulators(self) -> list[str]:
-        return list(map(str, self._ump.list_devices()))
-
-    @override
-    async def get_axes_count(self) -> int:
-        return 4
-
-    @override
-    def get_dimensions(self) -> Vector4:
-        return Vector4(x=20, y=20, z=20, w=20)
-
-    @override
-    async def get_position(self, manipulator_id: str) -> Vector4:
-        return um_to_mm(list_to_vector4(self._get_device(manipulator_id).get_pos(1)))  # pyright: ignore [reportUnknownMemberType]
-
-    @override
-    async def get_angles(self, manipulator_id: str) -> NoReturn:
-        """uMp-4 does not support getting angles so raise an error.
-
-        Raises:
-            AttributeError: uMp-4 does not support getting angles.
-        """
-        error_message = "UMP-4 does not support getting angles"
-        raise AttributeError(error_message)
-
-    @override
-    async def get_shank_count(self, manipulator_id: str) -> NoReturn:
-        """uMp-4 does not support getting shank count so raise an error.
-
-        Raises:
-            AttributeError: uMp-4 does not support getting shank count.
-        """
-        error_message = "UMP-4 does not support getting shank count"
-        raise AttributeError(error_message)
-
-    @override
-    def get_movement_tolerance(self) -> float:
-        return 0.001
-
-    @override
-    async def set_position(self, manipulator_id: str, position: Vector4, speed: float) -> Vector4:
-        # Convert position to micrometers.
-        target_position_um = vector_mm_to_um(position)
-
-        # Request movement.
-        movement = self._get_device(manipulator_id).goto_pos(  # pyright: ignore [reportUnknownMemberType]
-            vector4_to_array(target_position_um), scalar_mm_to_um(speed)
-        )
-
-        # Wait for movement to finish.
-        _ = await get_running_loop().run_in_executor(None, movement.finished_event.wait, None)
-
-        # Handle interrupted movement.
-        if movement.interrupted:
-            error_message = f"Manipulator {manipulator_id} interrupted: {movement.interrupt_reason}"  # pyright: ignore [reportUnknownMemberType]
-            raise RuntimeError(error_message)
-
-        # Handle empty end position.
-        if movement.last_pos is None or len(movement.last_pos) == 0:  # pyright: ignore [reportUnknownMemberType, reportUnknownArgumentType]
-            error_message = f"Manipulator {manipulator_id} did not reach target position"
-            raise RuntimeError(error_message)
-
-        return um_to_mm(list_to_vector4(movement.last_pos))  # pyright: ignore [reportArgumentType, reportUnknownMemberType]
-
-    @override
-    async def set_depth(self, manipulator_id: str, depth: float, speed: float) -> float:
-        # Augment current position with depth.
-        current_position = await self.get_position(manipulator_id)
-        new_platform_position = current_position.model_copy(update={"w": depth})
-
-        # Make the movement.
-        final_platform_position = await self.set_position(manipulator_id, new_platform_position, speed)
-
-        # Return the final depth.
-        return float(final_platform_position.w)
-
-    @override
-    async def stop(self, manipulator_id: str) -> None:
-        self._get_device(manipulator_id).stop()
-
-    @override
-    def platform_space_to_unified_space(self, platform_space: Vector4) -> Vector4:
-        # unified   <-  platform
-        # +x        <-  +y
-        # +y        <-  -z
-        # +z        <-  +x
-        # +d        <-  +d
-
-        return Vector4(
-            x=platform_space.y,
-            y=self.get_dimensions().z - platform_space.z,
-            z=platform_space.x,
-            w=platform_space.w,
-        )
-
-    @override
-    def unified_space_to_platform_space(self, unified_space: Vector4) -> Vector4:
-        # platform  <-  unified
-        # +x        <-  +z
-        # +y        <-  +x
-        # +z        <-  -y
-        # +d        <-  +d
-
-        return Vector4(
-            x=unified_space.z,
-            y=unified_space.x,
-            z=self.get_dimensions().z - unified_space.y,
-            w=unified_space.w,
-        )
-
-    # Helper methods.
-    def _get_device(self, manipulator_id: str) -> SensapexDevice:
-        return self._ump.get_device(int(manipulator_id))  # pyright: ignore [reportUnknownMemberType]

ephys_link/utils/console.py

@@ -1,127 +0,0 @@
-"""Console class for printing messages to the console.
-
-Configure the console to print error and debug messages.
-
-Usage:
-    Create a Console object and call the appropriate method to print messages.
-"""
-
-from logging import DEBUG, ERROR, INFO, basicConfig, getLogger
-from typing import final
-
-from rich.logging import RichHandler
-from rich.traceback import install
-
-
-@final
-class Console:
-    def __init__(self, *, enable_debug: bool) -> None:
-        """Initialize console properties.
-
-        Args:
-            enable_debug: Enable debug mode.
-        """
-        # Repeat message fields.
-        self._last_message = (0, "", "")
-        self._repeat_counter = 0
-
-        # Config logger.
-        basicConfig(
-            format="%(message)s",
-            datefmt="[%I:%M:%S %p]",
-            handlers=[RichHandler(rich_tracebacks=True, markup=True)],
-        )
-        self._log = getLogger("rich")
-        self._log.setLevel(DEBUG if enable_debug else INFO)
-
-        # Install Rich traceback.
-        _ = install()
-
-    def debug_print(self, label: str, msg: str) -> None:
-        """Print a debug message to the console.
-
-        Args:
-            label: Label for the debug message.
-            msg: Debug message to print.
-        """
-        self._repeatable_log(DEBUG, f"[b green]{label}", f"[green]{msg}")
-
-    def info_print(self, label: str, msg: str) -> None:
-        """Print info to console.
-
-        Args:
-            label: Label for the message.
-            msg: Message to print.
-        """
-        self._repeatable_log(INFO, f"[b blue]{label}", msg)
-
-    def error_print(self, label: str, msg: str) -> None:
-        """Print an error message to the console.
-
-        Args:
-            label: Label for the error message.
-            msg: Error message to print.
-        """
-        self._repeatable_log(ERROR, f"[b red]{label}", f"[red]{msg}")
-
-    def critical_print(self, msg: str) -> None:
-        """Print a critical message to the console.
-
-        Args:
-            msg: Critical message to print.
-        """
-        self._log.critical(f"[b i red]{msg}")
-
-    @staticmethod
-    def pretty_exception(exception: Exception) -> str:
-        """Pretty print an exception.
-
-        Args:
-            exception: Exception to pretty print.
-
-        Returns:
-            Pretty printed exception.
-        """
-        return f"{type(exception).__name__}: {exception}"
-
-    def exception_error_print(self, label: str, exception: Exception) -> None:
-        """Print an error message with exception details to the console.
-
-        Args:
-            label: Label for the error message.
-            exception: Exception to print.
-        """
-        self._log.exception(f"[b magenta]{label}:[/] [magenta]{Console.pretty_exception(exception)}")
-
-    # Helper methods.
-    def _repeatable_log(self, log_type: int, label: str, message: str) -> None:
-        """Add a row to the output table.
-
-        Args:
-            log_type: Type of log.
-            label: Label for the message.
-            message: Message.
-        """
-
-        # Compute if this is a repeated message.
-        message_set = (log_type, label, message)
-        if message_set == self._last_message:
-            # Handle repeat.
-            self._repeat_counter += 1
-
-            # Add an ellipsis row for first repeat.
-            if self._repeat_counter == 1:
-                self._log.log(log_type, "...")
-        else:
-            # Handle novel message.
-            if self._repeat_counter > 0:
-                # Complete previous repeat.
-                self._log.log(
-                    self._last_message[0],
-                    f"{self._last_message[1]}:[/] {self._last_message[2]}[/] x {self._repeat_counter}",
-                )
-                self._repeat_counter = 0
-
-            # Log new message.
-            self._log.log(log_type, f"{label}:[/] {message}")
-            self._last_message = message_set

ephys_link/utils/constants.py

@@ -1,23 +0,0 @@
-"""Globally accessible constants"""
-
-from os.path import abspath, dirname, join
-
-# Ephys Link ASCII.
-ASCII = r"""
- ______       _                 _      _       _
-|  ____|     | |               | |    (_)     | |
-| |__   _ __ | |__  _   _ ___  | |     _ _ __ | | __
-|  __| | '_ \| '_ \| | | / __| | |    | | '_ \| |/ /
-| |____| |_) | | | | |_| \__ \ | |____| | | | |   <
-|______| .__/|_| |_|\__, |___/ |______|_|_| |_|_|\_\
-       | |           __/ |
-       |_|          |___/
-"""
-
-# Absolute path to the resource folder.
-PACKAGE_DIRECTORY = dirname(dirname(abspath(__file__)))
-RESOURCES_DIRECTORY = join(PACKAGE_DIRECTORY, "resources")
-BINDINGS_DIRECTORY = join(PACKAGE_DIRECTORY, "bindings")
-
-# Ephys Link Port
-PORT = 3000