ephys-link 1.3.0b2__py3-none-any.whl → 2.0.0__py3-none-any.whl

ephys_link/platforms/new_scale_manipulator.py

@@ -1,312 +0,0 @@
-"""New Scale Manipulator class
-
-Handles logic for calling New Scale API functions. Also includes extra logic for safe
-function calls, error handling, managing per-manipulator attributes, and returning the
-appropriate callback parameters like in :mod:`ephys_link.new_scale_handler`.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import threading
-from typing import TYPE_CHECKING
-
-from vbl_aquarium.models.ephys_link import (
-    CanWriteRequest,
-    DriveToDepthRequest,
-    DriveToDepthResponse,
-    GotoPositionRequest,
-    PositionalResponse,
-)
-from vbl_aquarium.models.unity import Vector4
-
-import ephys_link.common as com
-from ephys_link.common import vector4_to_array
-from ephys_link.platform_manipulator import (
-    HOURS_TO_SECONDS,
-    MM_TO_UM,
-    POSITION_POLL_DELAY,
-    PlatformManipulator,
-)
-
-if TYPE_CHECKING:
-    # noinspection PyUnresolvedReferences
-    from NstMotorCtrl import NstCtrlAxis
-
-# Constants
-ACCELERATION_MULTIPLIER = 5
-CUTOFF_MULTIPLIER = 0.005
-AT_TARGET_FLAG = 0x040000
-
-
-class NewScaleManipulator(PlatformManipulator):
-    def __init__(
-        self,
-        manipulator_id: str,
-        x_axis: NstCtrlAxis,
-        y_axis: NstCtrlAxis,
-        z_axis: NstCtrlAxis,
-    ) -> None:
-        """Construct a new Manipulator object
-
-        :param manipulator_id: Manipulator ID
-        :param x_axis: X axis object
-        :param y_axis: Y axis object
-        :param z_axis: Z axis object
-        """
-
-        super().__init__()
-        self._id = manipulator_id
-        self._movement_tolerance = 0.01
-        self._x = x_axis
-        self._y = y_axis
-        self._z = z_axis
-        self._axes = [self._x, self._y, self._z]
-
-        # Set to CL control
-        self._x.SetCL_Enable(True)
-        self._y.SetCL_Enable(True)
-        self._z.SetCL_Enable(True)
-
-    def query_all_axes(self):
-        """Query all axes for their position and status"""
-        for axis in self._axes:
-            axis.QueryPosStatus()
-
-    def get_pos(self) -> PositionalResponse:
-        """Get the current position of the manipulator and convert it into mm.
-
-        :return: Position of manipulator in (x, y, z, z) in mm (or an empty array on error) and error message (if any).
-        :rtype: :class:`ephys_link.common.PositionalOutputData`
-        """
-        self.query_all_axes()
-
-        # Get position data and convert from µm to mm
-        try:
-            # com.dprint(f"[SUCCESS]\t Got position of manipulator {self._id}\n")
-            return PositionalResponse(
-                position=Vector4(
-                    x=self._x.CurPosition / MM_TO_UM,
-                    y=self._y.CurPosition / MM_TO_UM,
-                    z=self._z.CurPosition / MM_TO_UM,
-                    w=self._z.CurPosition / MM_TO_UM,
-                )
-            )
-        except Exception as e:
-            print(f"[ERROR]\t\t Getting position of manipulator {self._id}")
-            print(f"{e}\n")
-            return PositionalResponse(error="Error getting position")
-
-    async def goto_pos(self, request: GotoPositionRequest) -> PositionalResponse:
-        """Move manipulator to position.
-
-        :param request: The goto request parsed from the server.
-        :type request: :class:`vbl_aquarium.models.ephys_link.GotoPositionRequest`
-        :return: Resulting position of manipulator in (x, y, z, z) in mm (or an empty array on error)
-         and error message (if any).
-        :rtype: :class:`ephys_link.common.PositionalOutputData`
-        """
-        # Check if able to write
-        if not self._can_write:
-            print(f"[ERROR]\t\t Manipulator {self._id} movement canceled")
-            return PositionalResponse(error="Manipulator movement canceled")
-
-        # Stop current movement
-        if self._is_moving:
-            for axis in self._axes:
-                axis.Stop()
-            self._is_moving = False
-
-        try:
-            target_position_um = request.position * MM_TO_UM
-
-            # Restrict target position to just z-axis if inside brain
-            if self._inside_brain:
-                z_axis = target_position_um.z
-                target_position_um = target_position_um.model_copy(
-                    update={**self.get_pos().position.model_dump(), "z": z_axis}
-                )
-
-            # Mark movement as started
-            self._is_moving = True
-
-            # Send move command
-            speed_um = request.speed * MM_TO_UM
-            for i in range(3):
-                self._axes[i].SetCL_Speed(
-                    speed_um,
-                    speed_um * ACCELERATION_MULTIPLIER,
-                    speed_um * CUTOFF_MULTIPLIER,
-                )
-                self._axes[i].MoveAbsolute(vector4_to_array(target_position_um)[i])
-
-            # Check and wait for completion (while able to write)
-            self.query_all_axes()
-            while (
-                not (self._x.CurStatus & AT_TARGET_FLAG)
-                or not (self._y.CurStatus & AT_TARGET_FLAG)
-                or not (self._z.CurStatus & AT_TARGET_FLAG)
-            ) and self._can_write:
-                await asyncio.sleep(POSITION_POLL_DELAY)
-                self.query_all_axes()
-
-            # Get position
-            final_position = self.get_pos().position
-
-            # Mark movement as finished
-            self._is_moving = False
-
-            # Return success unless write was disabled during movement (meaning a stop occurred)
-            if not self._can_write:
-                com.dprint(f"[ERROR]\t\t Manipulator {self._id} movement canceled")
-                return PositionalResponse(error="Manipulator movement canceled")
-
-            # Return error if movement did not reach target.
-            if not all(
-                abs(axis) < self._movement_tolerance for axis in vector4_to_array(final_position - request.position)[:3]
-            ):
-                com.dprint(f"[ERROR]\t\t Manipulator {self._id} did not reach target position.")
-                com.dprint(f"\t\t\t Expected: {request.position}, Got: {final_position}")
-                return PositionalResponse(error="Manipulator did not reach target position")
-
-            # Made it to the target.
-            com.dprint(f"[SUCCESS]\t Moved manipulator {self._id} to position" f" {final_position}\n")
-            return PositionalResponse(position=final_position)
-        except Exception as e:
-            print(f"[ERROR]\t\t Moving manipulator {self._id} to position {request.position}")
-            print(f"{e}\n")
-            return PositionalResponse(error="Error moving manipulator")
-
-    async def drive_to_depth(self, request: DriveToDepthRequest) -> DriveToDepthResponse:
-        """Drive the manipulator to a certain depth.
-
-        :param request: The drive to depth request parsed from the server.
-        :type request: :class:`vbl_aquarium.models.ephys_link.DriveToDepthRequest`
-        :return: Resulting depth of manipulator in mm (or 0 on error) and error message (if any).
-        :rtype: :class:`ephys_link.common.DriveToDepthOutputData`
-        """
-        # Check if able to write
-        if not self._can_write:
-            print(f"[ERROR]\t\t Manipulator {self._id} movement canceled")
-            return DriveToDepthResponse(error="Manipulator movement canceled")
-
-        # Stop current movement
-        if self._is_moving:
-            for axis in self._axes:
-                axis.Stop()
-            self._is_moving = False
-
-        try:
-            target_depth_um = request.depth * MM_TO_UM
-
-            # Mark movement as started
-            self._is_moving = True
-
-            # Send move command to just z axis
-            speed_um = request.speed * MM_TO_UM
-            self._z.SetCL_Speed(
-                speed_um,
-                speed_um * ACCELERATION_MULTIPLIER,
-                speed_um * CUTOFF_MULTIPLIER,
-            )
-            self._z.MoveAbsolute(target_depth_um)
-
-            # Check and wait for completion (while able to write)
-            self._z.QueryPosStatus()
-            while not (self._z.CurStatus & AT_TARGET_FLAG) and self._can_write:
-                await asyncio.sleep(0.1)
-                self._z.QueryPosStatus()
-
-            # Get position
-            final_depth = self.get_pos().position.w
-
-            # Mark movement as finished
-            self._is_moving = False
-
-            # Return success unless write was disabled during movement (meaning a stop occurred)
-            if not self._can_write:
-                com.dprint(f"[ERROR]\t\t Manipulator {self._id} movement canceled")
-                return DriveToDepthResponse(error="Manipulator movement canceled")
-
-            # Return error if movement did not reach target.
-            if not abs(final_depth - request.depth) < self._movement_tolerance:
-                com.dprint(f"[ERROR]\t\t Manipulator {self._id} did not reach target depth")
-                com.dprint(f"\t\t\t Expected: {request.depth}, Got: {final_depth}")
-                return DriveToDepthResponse(error="Manipulator did not reach target depth")
-
-            # Made it to the target.
-            com.dprint(f"[SUCCESS]\t Moved manipulator {self._id} to position" f" {final_depth}\n")
-            return DriveToDepthResponse(depth=final_depth)
-        except Exception as e:
-            print(f"[ERROR]\t\t Moving manipulator {self._id} to depth {request.depth}")
-            print(f"{e}\n")
-            # Return 0 and error message on failure
-            return DriveToDepthResponse(error="Error driving manipulator")
-
-    def calibrate(self) -> bool:
-        """Calibrate the manipulator.
-
-        :return: None
-        """
-        return self._x.CalibrateFrequency() and self._y.CalibrateFrequency() and self._z.CalibrateFrequency()
-
-    def get_calibrated(self) -> bool:
-        """Return the calibration state of the manipulator.
-
-        :return: True if the manipulator is calibrated, False otherwise.
-        :rtype: bool
-        """
-        return self._calibrated
-
-    def set_calibrated(self) -> None:
-        """Set the manipulator to calibrated
-
-        :return: None
-        """
-        self._calibrated = True
-
-    def set_can_write(self, request: CanWriteRequest) -> None:
-        """Set if the manipulator can move.
-
-        :param request: The can write request parsed from the server.
-        :type request: :class:`vbl_aquarium.models.ephys_link.CanWriteRequest`
-        :return: None
-        """
-        self._can_write = request.can_write
-
-        if request.can_write and request.hours > 0:
-            if self._reset_timer:
-                self._reset_timer.cancel()
-            self._reset_timer = threading.Timer(request.hours * HOURS_TO_SECONDS, self.reset_can_write)
-            self._reset_timer.start()
-
-    def reset_can_write(self) -> None:
-        """Reset the :attr:`can_write` flag."""
-        self._can_write = False
-
-    def get_can_write(self) -> bool:
-        """Return if the manipulator can move.
-
-        :return: True if the manipulator can move, False otherwise.
-        :rtype: bool
-        """
-        return self._can_write
-
-    def set_inside_brain(self, inside: bool) -> None:
-        """Set if the manipulator is inside the brain.
-
-        :param inside: True if the manipulator is inside the brain, False otherwise.
-        :type inside: bool
-        :return: None
-        """
-        self._inside_brain = inside
-
-    def stop(self) -> None:
-        """Stop all axes on manipulator.
-
-        :returns None
-        """
-        for axis in self._axes:
-            axis.Stop()
-        self._can_write = False
-        com.dprint(f"[SUCCESS]\t Stopped manipulator {self._id}\n")

ephys_link/platforms/new_scale_pathfinder_handler.py

@@ -1,235 +0,0 @@
-"""Handle communications with New Scale's HTTP server
-
-Implements New Scale specific API calls.
-
-This is a subclass of :class:`ephys_link.platform_handler.PlatformHandler`.
-"""
-
-from __future__ import annotations
-
-import json
-from sys import exit
-from typing import TYPE_CHECKING
-from urllib import request
-from urllib.error import URLError
-
-from vbl_aquarium.models.ephys_link import (
-    AngularResponse,
-    BooleanStateResponse,
-    CanWriteRequest,
-    DriveToDepthRequest,
-    DriveToDepthResponse,
-    GotoPositionRequest,
-    InsideBrainRequest,
-    PositionalResponse,
-    ShankCountResponse,
-)
-from vbl_aquarium.models.unity import Vector3, Vector4
-
-from ephys_link.platform_handler import PlatformHandler
-
-if TYPE_CHECKING:
-    import socketio
-
-
-class NewScalePathfinderHandler(PlatformHandler):
-    """Handler for New Scale HTTP server"""
-
-    # 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",
-    )
-
-    def __init__(self, port: int = 8080) -> None:
-        """
-        Initialize New Scale via Pathfinder handler
-
-        :param port: Port of New Scale Pathfinder HTTP server
-        :type port: int
-        """
-        super().__init__()
-
-        self.num_axes = -1
-        self.dimensions = Vector4(x=15, y=15, z=15, w=0)
-
-        self.port = port
-
-        # Test connection to New Scale HTTP server
-        try:
-            request.urlopen(f"http://localhost:{self.port}")
-        except URLError:
-            print(f"New Scale Pathfinder HTTP server not online on port {self.port}")
-            print("Please start the HTTP server and try again.")
-            input("Press Enter to exit...")
-            exit(1)
-
-    def query_data(self) -> dict:
-        """Query New Scale HTTP server for data and return as dict.
-
-        :return: Parsed JSON data from New Scale HTTP server.
-        :rtype: dict
-        """
-        try:
-            return json.loads(request.urlopen(f"http://localhost:{self.port}").read())
-        except Exception as e:
-            print(f"[ERROR]\t\t Unable to query for New Scale data: {type(e)} {e}\n")
-
-    def query_manipulator_data(self, manipulator_id: str) -> dict:
-        """Query New Scale HTTP server for data on a specific manipulator.
-
-        :param manipulator_id: manipulator ID.
-        :return: Parsed JSON data for a particular manipulator.
-        :rtype: dict
-        :raises ValueError: if manipulator ID is not found in query.
-        """
-        data_query = self.query_data()["ProbeArray"]
-        manipulator_data = data_query[self.manipulators[manipulator_id]]
-
-        # If the order of the manipulators switched (somehow)
-        if manipulator_data["Id"] != manipulator_id:
-            # Recalculate index and get data
-            (manipulator_index, manipulator_data) = next(
-                (
-                    (index, data)
-                    for index, data in enumerate(self.query_data()["ProbeArray"])
-                    if data["Id"] == manipulator_id
-                ),
-                (None, None),
-            )
-            # Update index in manipulators dict
-            if manipulator_index:
-                self.manipulators[manipulator_id] = manipulator_index
-
-        # If data query was unsuccessful
-        if not manipulator_data:
-            msg = f"Unable to find manipulator {manipulator_id}"
-            raise ValueError(msg)
-
-        # Return data
-        return manipulator_data
-
-    def _get_manipulators(self) -> list:
-        return [probe["Id"] for probe in self.query_data()["ProbeArray"]]
-
-    def _register_manipulator(self, manipulator_id: str) -> None:
-        # Check if ID is a valid New Scale manipulator ID
-        if manipulator_id not in self.VALID_MANIPULATOR_IDS:
-            msg = f"Invalid manipulator ID {manipulator_id}"
-            raise ValueError(msg)
-
-        # Check if ID is connected
-        if manipulator_id not in self._get_manipulators():
-            msg = f"Manipulator {manipulator_id} not connected"
-            raise ValueError(msg)
-
-        # Get index of the manipulator
-        manipulator_index = next(
-            (index for index, data in enumerate(self.query_data()["ProbeArray"]) if data["Id"] == manipulator_id),
-            None,
-        )
-        if manipulator_index is None:
-            msg = f"Unable to find manipulator {manipulator_id}"
-            raise ValueError(msg)
-        self.manipulators[manipulator_id] = manipulator_index
-
-    def _unregister_manipulator(self, manipulator_id: str) -> None:
-        del self.manipulators[manipulator_id]
-
-    def _get_pos(self, manipulator_id: str) -> PositionalResponse:
-        """Get the current position of the manipulator in mm
-
-        :param manipulator_id: manipulator ID
-        :return: Callback parameters (position in (x, y, z, w) (or an empty array on
-            error) in mm, error message)
-        """
-        manipulator_data = self.query_manipulator_data(manipulator_id)
-
-        return PositionalResponse(
-            position=Vector4(
-                x=manipulator_data["Tip_X_ML"], y=manipulator_data["Tip_Y_AP"], z=manipulator_data["Tip_Z_DV"], w=0
-            )
-        )
-
-    def _get_angles(self, manipulator_id: str) -> AngularResponse:
-        manipulator_data = self.query_manipulator_data(manipulator_id)
-
-        # Apply PosteriorAngle to Polar to get the correct angle.
-        adjusted_polar = manipulator_data["Polar"] - self.query_data()["PosteriorAngle"]
-
-        return AngularResponse(
-            angles=Vector3(
-                x=adjusted_polar if adjusted_polar > 0 else 360 + adjusted_polar,
-                y=manipulator_data["Pitch"],
-                z=manipulator_data.get("ShankOrientation", 0),
-            )
-        )
-
-    def _get_shank_count(self, manipulator_id: str) -> ShankCountResponse:
-        for probe in self.query_data()["ProbeArray"]:
-            if probe["Id"] == manipulator_id:
-                return ShankCountResponse(shank_count=probe.get("ShankCount", 1))
-
-        return ShankCountResponse(error="Unable to find manipulator")
-
-    async def _goto_pos(self, _: GotoPositionRequest) -> PositionalResponse:
-        raise NotImplementedError
-
-    async def _drive_to_depth(self, _: DriveToDepthRequest) -> DriveToDepthResponse:
-        raise NotImplementedError
-
-    def _set_inside_brain(self, _: InsideBrainRequest) -> BooleanStateResponse:
-        raise NotImplementedError
-
-    async def _calibrate(self, manipulator_id: str, sio: socketio.AsyncServer) -> str:
-        raise NotImplementedError
-
-    def _bypass_calibration(self, manipulator_id: str) -> str:
-        return ""
-
-    def _set_can_write(self, _: CanWriteRequest) -> BooleanStateResponse:
-        raise NotImplementedError
-
-    def _unified_space_to_platform_space(self, unified_position: list[float]) -> list[float]:
-        raise NotImplementedError
-
-    def _platform_space_to_unified_space(self, platform_position: list[float]) -> list[float]:
-        raise NotImplementedError

ephys_link/platforms/sensapex_handler.py

@@ -1,151 +0,0 @@
-"""Handle communications with Sensapex uMp API
-
-This supports the uMp-4 manipulator. Any Sensapex variants should extend this class.
-
-Implements Sensapex uMp specific API calls including coordinating the usage of the
-:class:`ephys_link.platforms.sensapex_manipulator.SensapexManipulator` class.
-
-This is a subclass of :class:`ephys_link.platform_handler.PlatformHandler`.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-from sensapex import UMP, UMError
-from vbl_aquarium.models.ephys_link import (
-    AngularResponse,
-    BooleanStateResponse,
-    CanWriteRequest,
-    DriveToDepthRequest,
-    DriveToDepthResponse,
-    GotoPositionRequest,
-    InsideBrainRequest,
-    PositionalResponse,
-    ShankCountResponse,
-)
-from vbl_aquarium.models.unity import Vector4
-
-import ephys_link.common as com
-from ephys_link.platform_handler import PlatformHandler
-from ephys_link.platforms.sensapex_manipulator import SensapexManipulator
-
-if TYPE_CHECKING:
-    import socketio
-
-
-class SensapexHandler(PlatformHandler):
-    """Handler for Sensapex platform."""
-
-    def __init__(self) -> None:
-        super().__init__()
-
-        # Establish connection to Sensapex API (exit if connection fails)
-        UMP.set_library_path(str(Path(__file__).parent.parent.absolute()) + "/resources/")
-        self.ump = UMP.get_ump()
-        if self.ump is None:
-            msg = "Unable to connect to uMp"
-            raise ValueError(msg)
-
-    def _get_manipulators(self) -> list:
-        return list(map(str, self.ump.list_devices()))
-
-    def _register_manipulator(self, manipulator_id: str) -> None:
-        if not manipulator_id.isnumeric():
-            msg = "Manipulator ID must be numeric"
-            raise ValueError(msg)
-
-        self.manipulators[manipulator_id] = SensapexManipulator(self.ump.get_device(int(manipulator_id)))
-
-    def _unregister_manipulator(self, manipulator_id: str) -> None:
-        del self.manipulators[manipulator_id]
-
-    def _get_pos(self, manipulator_id: str) -> PositionalResponse:
-        return self.manipulators[manipulator_id].get_pos()
-
-    def _get_angles(self, manipulator_id: str) -> AngularResponse:
-        raise NotImplementedError
-
-    def _get_shank_count(self, manipulator_id: str) -> ShankCountResponse:
-        raise NotImplementedError
-
-    async def _goto_pos(self, request: GotoPositionRequest) -> PositionalResponse:
-        return await self.manipulators[request.manipulator_id].goto_pos(request)
-
-    async def _drive_to_depth(self, request: DriveToDepthRequest) -> DriveToDepthResponse:
-        return await self.manipulators[request.manipulator_id].drive_to_depth(request)
-
-    def _set_inside_brain(self, request: InsideBrainRequest) -> BooleanStateResponse:
-        self.manipulators[request.manipulator_id].set_inside_brain(request.inside)
-        com.dprint(f"[SUCCESS]\t Set inside brain state for manipulator: {request.manipulator_id}\n")
-        return BooleanStateResponse(state=request.inside)
-
-    async def _calibrate(self, manipulator_id: str, sio: socketio.AsyncServer) -> str:
-        try:
-            # Move manipulator to max position
-            await self.manipulators[manipulator_id].goto_pos([20000, 20000, 20000, 20000], 2000)
-
-            # Call calibrate
-            self.manipulators[manipulator_id].call_calibrate()
-
-            # Wait for calibration to complete
-            still_working = True
-            while still_working:
-                cur_pos = self.manipulators[manipulator_id].get_pos()["position"]
-
-                # Check difference between current and target position
-                for prev, cur in zip([10000, 10000, 10000, 10000], cur_pos):
-                    if abs(prev - cur) > 1:
-                        still_working = True
-                        break
-                    still_working = False
-
-                # Sleep for a bit
-                await sio.sleep(0.5)
-
-            # Calibration complete
-            self.manipulators[manipulator_id].set_calibrated()
-            com.dprint(f"[SUCCESS]\t Calibrated manipulator {manipulator_id}\n")
-        except UMError as e:
-            # SDK call error
-            print(f"[ERROR]\t\t Calling calibrate manipulator {manipulator_id}")
-            print(f"{e}\n")
-            return "Error calling calibrate"
-        else:
-            return ""
-
-    def _bypass_calibration(self, manipulator_id: str) -> str:
-        self.manipulators[manipulator_id].set_calibrated()
-        com.dprint(f"[SUCCESS]\t Bypassed calibration for manipulator" f" {manipulator_id}\n")
-        return ""
-
-    def _set_can_write(self, request: CanWriteRequest) -> BooleanStateResponse:
-        self.manipulators[request.manipulator_id].set_can_write(request)
-        com.dprint(f"[SUCCESS]\t Set can_write state for manipulator {request.manipulator_id}\n")
-        return BooleanStateResponse(state=request.can_write)
-
-    def _platform_space_to_unified_space(self, platform_position: Vector4) -> Vector4:
-        # unified   <-  platform
-        # +x        <-  +y
-        # +y        <-  -z
-        # +z        <-  +x
-        # +d        <-  +d
-
-        return Vector4(
-            x=platform_position.y,
-            y=self.dimensions.z - platform_position.z,
-            z=platform_position.x,
-            w=platform_position.w,
-        )
-
-    def _unified_space_to_platform_space(self, unified_position: Vector4) -> Vector4:
-        # platform  <-  unified
-        # +x        <-  +z
-        # +y        <-  +x
-        # +z        <-  -y
-        # +d        <-  +d
-
-        return Vector4(
-            x=unified_position.z, y=unified_position.x, z=self.dimensions.z - unified_position.y, w=unified_position.w
-        )