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

ephys_link/__about__.py

@@ -1 +1 @@
-__version__ = "2.0.0b1"
+__version__ = "2.0.0b5"

ephys_link/__main__.py

@@ -31,7 +31,7 @@ def main() -> None:
     console = Console(enable_debug=options.debug)
 
     # 3. Instantiate the Platform Handler with the appropriate platform bindings.
-    platform_handler = PlatformHandler(options.type, console)
+    platform_handler = PlatformHandler(options, console)
 
     # 4. Instantiate the Emergency Stop service.
 

ephys_link/back_end/platform_handler.py

@@ -12,6 +12,7 @@ from uuid import uuid4
 from vbl_aquarium.models.ephys_link import (
     AngularResponse,
     BooleanStateResponse,
+    EphysLinkOptions,
     GetManipulatorsResponse,
     PositionalResponse,
     SetDepthRequest,
@@ -25,6 +26,7 @@ from vbl_aquarium.models.unity import Vector4
 
 from ephys_link.__about__ import __version__
 from ephys_link.bindings.fake_bindings import FakeBindings
+from ephys_link.bindings.mpm_bindings import MPMBinding
 from ephys_link.bindings.ump_4_bindings import Ump4Bindings
 from ephys_link.util.base_bindings import BaseBindings
 from ephys_link.util.common import vector4_to_array
@@ -34,21 +36,21 @@ from ephys_link.util.console import Console
 class PlatformHandler:
     """Handler for platform commands."""
 
-    def __init__(self, platform_type: str, console: Console) -> None:
+    def __init__(self, options: EphysLinkOptions, console: Console) -> None:
         """Initialize platform handler.
 
-        :param platform_type: Platform type to initialize bindings from.
-        :type platform_type: str
+        :param options: CLI options.
+        :type options: EphysLinkOptions
         """
 
-        # Store the platform type.
-        self._platform_type = platform_type
+        # Store the CLI options.
+        self._options = options
 
         # Store the console.
         self._console = console
 
         # Define bindings based on platform type.
-        self._bindings = self._match_platform_type(platform_type)
+        self._bindings = self._match_platform_type(options)
 
         # Record which IDs are inside the brain.
         self._inside_brain: set[str] = set()
@@ -56,22 +58,24 @@ class PlatformHandler:
         # Generate a Pinpoint ID for proxy usage.
         self._pinpoint_id = str(uuid4())[:8]
 
-    def _match_platform_type(self, platform_type: str) -> BaseBindings:
+    def _match_platform_type(self, options: EphysLinkOptions) -> BaseBindings:
         """Match the platform type to the appropriate bindings.
 
-        :param platform_type: Platform type.
-        :type platform_type: str
+        :param options: CLI options.
+        :type options: EphysLinkOptions
         :returns: Bindings for the specified platform type.
         :rtype: :class:`ephys_link.util.base_bindings.BaseBindings`
         """
-        match platform_type:
+        match options.type:
             case "ump-4":
                 return Ump4Bindings()
+            case "pathfinder-mpm":
+                return MPMBinding(options.mpm_port)
             case "fake":
                 return FakeBindings()
             case _:
-                error_message = f'Platform type "{platform_type}" not recognized.'
-                self._console.labeled_error_print("PLATFORM", error_message)
+                error_message = f'Platform type "{options.type}" not recognized.'
+                self._console.critical_print(error_message)
                 raise ValueError(error_message)
 
     # Ephys Link metadata.
@@ -99,7 +103,7 @@ class PlatformHandler:
         :returns: Platform type config identifier (see CLI options for examples).
         :rtype: str
         """
-        return self._platform_type
+        return str(self._options.type)
 
     # Manipulator commands.
 
@@ -111,7 +115,7 @@ class PlatformHandler:
         """
         try:
             manipulators = await self._bindings.get_manipulators()
-            num_axes = await self._bindings.get_num_axes()
+            num_axes = await self._bindings.get_axes_count()
             dimensions = self._bindings.get_dimensions()
         except Exception as e:
             self._console.exception_error_print("Get Manipulators", e)
@@ -185,7 +189,7 @@ class PlatformHandler:
             # Disallow setting manipulator position while inside the brain.
             if request.manipulator_id in self._inside_brain:
                 error_message = 'Can not move manipulator while inside the brain. Set the depth ("set_depth") instead.'
-                self._console.error_print(error_message)
+                self._console.error_print("Set Position", error_message)
                 return PositionalResponse(error=error_message)
 
             # Move to the new position.
@@ -198,18 +202,18 @@ class PlatformHandler:
 
             # Return error if movement did not reach target within tolerance.
             for index, axis in enumerate(vector4_to_array(final_unified_position - request.position)):
-                # End once index is greater than the number of axes.
-                if index >= await self._bindings.get_num_axes():
+                # End once index is the number of axes.
+                if index == await self._bindings.get_axes_count():
                     break
 
                 # Check if the axis is within the movement tolerance.
-                if abs(axis) > await self._bindings.get_movement_tolerance():
+                if abs(axis) > self._bindings.get_movement_tolerance():
                     error_message = (
                         f"Manipulator {request.manipulator_id} did not reach target"
                         f" position on axis {list(Vector4.model_fields.keys())[index]}."
-                        f"Requested: {request.position}, got: {final_unified_position}."
+                        f" Requested: {request.position}, got: {final_unified_position}."
                     )
-                    self._console.error_print(error_message)
+                    self._console.error_print("Set Position", error_message)
                     return PositionalResponse(error=error_message)
         except Exception as e:
             self._console.exception_error_print("Set Position", e)
@@ -226,24 +230,27 @@ class PlatformHandler:
         :rtype: :class:`vbl_aquarium.models.ephys_link.DriveToDepthResponse`
         """
         try:
-            # Create a position based on the new depth.
-            current_platform_position = await self._bindings.get_position(request.manipulator_id)
-            current_unified_position = self._bindings.platform_space_to_unified_space(current_platform_position)
-            target_unified_position = current_unified_position.model_copy(update={"w": request.depth})
-            target_platform_position = self._bindings.unified_space_to_platform_space(target_unified_position)
-
             # Move to the new depth.
-            final_platform_position = await self._bindings.set_position(
+            final_platform_depth = await self._bindings.set_depth(
                 manipulator_id=request.manipulator_id,
-                position=target_platform_position,
+                depth=self._bindings.unified_space_to_platform_space(Vector4(w=request.depth)).w,
                 speed=request.speed,
             )
-            final_unified_position = self._bindings.platform_space_to_unified_space(final_platform_position)
+            final_unified_depth = self._bindings.platform_space_to_unified_space(Vector4(w=final_platform_depth)).w
+
+            # Return error if movement did not reach target within tolerance.
+            if abs(final_unified_depth - request.depth) > self._bindings.get_movement_tolerance():
+                error_message = (
+                    f"Manipulator {request.manipulator_id} did not reach target depth."
+                    f" Requested: {request.depth}, got: {final_unified_depth}."
+                )
+                self._console.error_print("Set Depth", error_message)
+                return SetDepthResponse(error=error_message)
         except Exception as e:
             self._console.exception_error_print("Set Depth", e)
             return SetDepthResponse(error=self._console.pretty_exception(e))
         else:
-            return SetDepthResponse(depth=final_unified_position.w)
+            return SetDepthResponse(depth=final_unified_depth)
 
     async def set_inside_brain(self, request: SetInsideBrainRequest) -> BooleanStateResponse:
         """Mark a manipulator as inside the brain or not.

ephys_link/back_end/server.py

@@ -12,7 +12,7 @@ from vbl_aquarium.models.ephys_link import (
     SetInsideBrainRequest,
     SetPositionRequest,
 )
-from vbl_aquarium.models.generic import VBLBaseModel
+from vbl_aquarium.utils.vbl_base_model import VBLBaseModel
 
 from ephys_link.back_end.platform_handler import PlatformHandler
 from ephys_link.util.common import PORT, check_for_updates, server_preamble
@@ -75,7 +75,7 @@ class Server:
     # Helper functions.
     def _malformed_request_response(self, request: str, data: tuple[tuple[Any], ...]) -> str:
         """Return a response for a malformed request."""
-        self._console.labeled_error_print("MALFORMED REQUEST", f"{request}: {data}")
+        self._console.error_print("MALFORMED REQUEST", f"{request}: {data}")
         return dumps({"error": "Malformed request."})
 
     async def _run_if_data_available(
@@ -127,7 +127,9 @@ class Server:
             self._console.info_print("CONNECTION GRANTED", sid)
             return True
 
-        self._console.error_print(f"CONNECTION REFUSED to {sid}. Client {self._client_sid} already connected.")
+        self._console.error_print(
+            "CONNECTION REFUSED", f"Cannot connect {sid} as {self._client_sid} is already connected."
+        )
         return False
 
     async def disconnect(self, sid: str) -> None:
@@ -142,7 +144,7 @@ class Server:
         if self._client_sid == sid:
             self._client_sid = ""
         else:
-            self._console.error_print(f"Client {sid} disconnected without being connected.")
+            self._console.error_print("DISCONNECTION", f"Client {sid} disconnected without being connected.")
 
     # noinspection PyTypeChecker
     async def platform_event_handler(self, event: str, *args: tuple[Any]) -> str:
@@ -196,5 +198,5 @@ class Server:
             case "stop_all":
                 return await self._platform_handler.stop_all()
             case _:
-                self._console.error_print(f"Unknown event: {event}.")
+                self._console.error_print("EVENT", f"Unknown event: {event}.")
                 return dumps({"error": "Unknown event."})

ephys_link/bindings/fake_bindings.py

@@ -1,6 +1,7 @@
 from vbl_aquarium.models.unity import Vector3, Vector4
 
 from ephys_link.util.base_bindings import BaseBindings
+from ephys_link.util.common import array_to_vector4
 
 
 class FakeBindings(BaseBindings):
@@ -22,11 +23,11 @@ class FakeBindings(BaseBindings):
     async def get_manipulators(self) -> list[str]:
         return list(map(str, range(8)))
 
-    async def get_num_axes(self) -> int:
+    async def get_axes_count(self) -> int:
         return 4
 
     def get_dimensions(self) -> Vector4:
-        return Vector4(x=20, y=20, z=20, w=20)
+        return array_to_vector4([20] * 4)
 
     async def get_position(self, manipulator_id: str) -> Vector4:
         return self._positions[int(manipulator_id)]
@@ -37,13 +38,17 @@ class FakeBindings(BaseBindings):
     async def get_shank_count(self, _: str) -> int:
         return 1
 
-    async def get_movement_tolerance(self) -> float:
+    def get_movement_tolerance(self) -> float:
         return 0.001
 
     async def set_position(self, manipulator_id: str, position: Vector4, _: float) -> Vector4:
         self._positions[int(manipulator_id)] = position
         return position
 
+    async def set_depth(self, manipulator_id: str, depth: float, _: float) -> float:
+        self._positions[int(manipulator_id)].w = depth
+        return depth
+
     async def stop(self, _: str) -> None:
         pass
 

ephys_link/bindings/mpm_bindings.py

@@ -0,0 +1,278 @@
+"""Bindings for New Scale Pathfinder MPM HTTP server platform.
+
+MPM works slightly differently than the other platforms since it operates in stereotactic coordinates.
+This means exceptions need to be made for its API.
+
+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
+
+from requests import JSONDecodeError, get, put
+from vbl_aquarium.models.unity import Vector3, Vector4
+
+from ephys_link.util.base_bindings import BaseBindings
+from ephys_link.util.common import scalar_mm_to_um, vector4_to_array
+
+
+class MPMBinding(BaseBindings):
+    """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",
+    )
+
+    # 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) -> None:
+        """Initialize connection to MPM HTTP server.
+
+        :param port: Port number for MPM HTTP server.
+        :type port: int
+        """
+        self._url = f"http://localhost:{port}"
+        self._movement_stopped = False
+
+    async def get_manipulators(self) -> list[str]:
+        return [manipulator["Id"] for manipulator in (await self._query_data())["ProbeArray"]]
+
+    async def get_axes_count(self) -> int:
+        return 3
+
+    def get_dimensions(self) -> Vector4:
+        return Vector4(x=15, y=15, z=15, w=15)
+
+    async def get_position(self, manipulator_id: str) -> Vector4:
+        manipulator_data = await self._manipulator_data(manipulator_id)
+        stage_z = 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,
+        )
+
+    async def get_angles(self, manipulator_id: str) -> Vector3:
+        manipulator_data = await self._manipulator_data(manipulator_id)
+
+        # Apply PosteriorAngle to Polar to get the correct angle.
+        adjusted_polar = 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"],
+        )
+
+    async def get_shank_count(self, manipulator_id: str) -> int:
+        return int((await self._manipulator_data(manipulator_id))["ShankCount"])
+
+    def get_movement_tolerance(self) -> float:
+        return 0.01
+
+    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)
+
+    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)
+
+    async def stop(self, manipulator_id: str) -> None:
+        request = {"PutId": "ProbeStop", "Probe": self.VALID_MANIPULATOR_IDS.index(manipulator_id)}
+        await self._put_request(request)
+        self._movement_stopped = True
+
+    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,
+        )
+
+    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) -> Any:
+        try:
+            return (await get_running_loop().run_in_executor(None, get, self._url)).json()
+        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
+
+    async def _manipulator_data(self, manipulator_id: str) -> Any:
+        probe_data = (await self._query_data())["ProbeArray"]
+        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:
+        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_bindings.py

@@ -9,8 +9,14 @@ from sensapex import UMP, SensapexDevice
 from vbl_aquarium.models.unity import Vector3, Vector4
 
 from ephys_link.util.base_bindings import BaseBindings
-from ephys_link.util.common import RESOURCES_PATH, array_to_vector4, mm_to_um, mmps_to_umps, um_to_mm, vector4_to_array
-from ephys_link.util.console import Console
+from ephys_link.util.common import (
+    RESOURCES_PATH,
+    array_to_vector4,
+    scalar_mm_to_um,
+    um_to_mm,
+    vector4_to_array,
+    vector_mm_to_um,
+)
 
 
 class Ump4Bindings(BaseBindings):
@@ -24,13 +30,12 @@ class Ump4Bindings(BaseBindings):
         self._ump = UMP.get_ump()
         if self._ump is None:
             error_message = "Unable to connect to uMp"
-            Console.error_print(error_message)
             raise ValueError(error_message)
 
     async def get_manipulators(self) -> list[str]:
         return list(map(str, self._ump.list_devices()))
 
-    async def get_num_axes(self) -> int:
+    async def get_axes_count(self) -> int:
         return 4
 
     def get_dimensions(self) -> Vector4:
@@ -57,29 +62,17 @@ class Ump4Bindings(BaseBindings):
         error_message = "UMP-4 does not support getting shank count"
         raise AttributeError(error_message)
 
-    async def get_movement_tolerance(self) -> float:
+    def get_movement_tolerance(self) -> float:
         return 0.001
 
     async def set_position(self, manipulator_id: str, position: Vector4, speed: float) -> Vector4:
-        """Set the position of the manipulator.
-
-        Waits using Asyncio until the movement is finished. This assumes the application is running in an event loop.
-
-        :param manipulator_id: Manipulator ID.
-        :type manipulator_id: str
-        :param position: Platform space position to set the manipulator to (mm).
-        :type position: Vector4
-        :param speed: Speed to move the manipulator to the position (mm/s).
-        :type speed: float
-        :returns: Final position of the manipulator in platform space (mm).
-        :rtype: Vector4
-        :raises RuntimeError: If the movement is interrupted.
-        """
         # Convert position to micrometers.
-        target_position_um = mm_to_um(position)
+        target_position_um = vector_mm_to_um(position)
 
         # Request movement.
-        movement = self._get_device(manipulator_id).goto_pos(vector4_to_array(target_position_um), mmps_to_umps(speed))
+        movement = self._get_device(manipulator_id).goto_pos(
+            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)
@@ -91,6 +84,17 @@ class Ump4Bindings(BaseBindings):
 
         return um_to_mm(array_to_vector4(movement.last_pos))
 
+    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)
+
     async def stop(self, manipulator_id: str) -> None:
         self._get_device(manipulator_id).stop()
 

ephys_link/util/base_bindings.py

@@ -25,7 +25,7 @@ class BaseBindings(ABC):
         """
 
     @abstractmethod
-    async def get_num_axes(self) -> int:
+    async def get_axes_count(self) -> int:
         """Get the number of axes for the current platform.
 
         :returns: Number of axes.
@@ -76,7 +76,7 @@ class BaseBindings(ABC):
         """
 
     @abstractmethod
-    async def get_movement_tolerance(self) -> float:
+    def get_movement_tolerance(self) -> float:
         """Get the tolerance for how close the final position must be to the target position in a movement (mm).
 
         :returns: Movement tolerance (mm).
@@ -88,7 +88,6 @@ class BaseBindings(ABC):
         """Set the position of a manipulator.
 
         This will directly set the position in the original platform space.
-        Unified space coordinates will need to be converted to platform space.
         For 3-axis manipulators, the first 3 values of the position will be used.
 
         :param manipulator_id: Manipulator ID.
@@ -101,6 +100,22 @@ class BaseBindings(ABC):
         :rtype: Vector4
         """
 
+    @abstractmethod
+    async def set_depth(self, manipulator_id: str, depth: float, speed: float) -> float:
+        """Set the depth of a manipulator.
+
+        This will directly set the depth stage in the original platform space.
+
+        :param manipulator_id: Manipulator ID.
+        :type manipulator_id: str
+        :param depth: Depth to set the manipulator to (mm).
+        :type depth: float
+        :param speed: Speed to move the manipulator to the depth (mm/s).
+        :type speed: float
+        :returns: Final depth of the manipulator in platform space (mm).
+        :rtype: float
+        """
+
     @abstractmethod
     async def stop(self, manipulator_id: str) -> None:
         """Stop a manipulator."""

ephys_link/util/common.py

@@ -9,7 +9,6 @@ from requests import get
 from vbl_aquarium.models.unity import Vector4
 
 from ephys_link.__about__ import __version__
-from ephys_link.util.console import Console
 
 # Ephys Link ASCII.
 ASCII = r"""
@@ -47,30 +46,30 @@ def check_for_updates() -> None:
     response = get("https://api.github.com/repos/VirtualBrainLab/ephys-link/tags", timeout=10)
     latest_version = response.json()[0]["name"]
     if parse(latest_version) > parse(__version__):
-        Console.info_print("Update available", latest_version)
-        Console.info_print("", "Download at: https://github.com/VirtualBrainLab/ephys-link/releases/latest")
+        print(f"Update available: {latest_version} !")
+        print("Download at: https://github.com/VirtualBrainLab/ephys-link/releases/latest")
 
 
 # Unit conversions
 
 
-def mmps_to_umps(mmps: float) -> float:
-    """Convert millimeters per second to micrometers per second.
+def scalar_mm_to_um(mm: float) -> float:
+    """Convert scalar values of millimeters to micrometers.
 
-    :param mmps: Speed in millimeters per second.
-    :type mmps: float
-    :returns: Speed in micrometers per second.
+    :param mm: Scalar value in millimeters.
+    :type mm: float
+    :returns: Scalar value in micrometers.
     :rtype: float
     """
-    return mmps * 1_000
+    return mm * 1_000
 
 
-def mm_to_um(mm: Vector4) -> Vector4:
-    """Convert millimeters to micrometers.
+def vector_mm_to_um(mm: Vector4) -> Vector4:
+    """Convert vector values of millimeters to micrometers.
 
-    :param mm: Length in millimeters.
+    :param mm: Vector in millimeters.
     :type mm: Vector4
-    :returns: Length in micrometers.
+    :returns: Vector in micrometers.
     :rtype: Vector4
     """
     return mm * 1_000

ephys_link/util/console.py

@@ -6,12 +6,10 @@ Configure the console to print error and debug messages.
 Usage: Create a Console object and call the appropriate method to print messages.
 """
 
-from traceback import print_exc
+from logging import DEBUG, ERROR, INFO, basicConfig, getLogger
 
-from colorama import Back, Fore, Style, init
-
-# Constants.
-TAB_BLOCK = "\t\t"
+from rich.logging import RichHandler
+from rich.traceback import install
 
 
 class Console:
@@ -21,34 +19,59 @@ class Console:
         :param enable_debug: Enable debug mode.
         :type enable_debug: bool
         """
-        self._enable_debug = enable_debug
-
         # Repeat message fields.
-        self._last_message = ""
-        self._repeat_counter = 1
+        self._last_message = (0, "", "")
+        self._repeat_counter = 0
 
-        # Initialize colorama.
-        init(autoreset=True)
+        # 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)
 
-    @staticmethod
-    def error_print(msg: str) -> None:
-        """Print an error message to the console.
+        # Install Rich traceback.
+        install()
 
-        :param msg: Error message to print.
+    def debug_print(self, label: str, msg: str) -> None:
+        """Print a debug message to the console.
+
+        :param label: Label for the debug message.
+        :type label: str
+        :param msg: Debug message to print.
         :type msg: str
         """
-        print(f"\n{Back.RED}{Style.BRIGHT} ERROR {Style.RESET_ALL}{TAB_BLOCK}{Fore.RED}{msg}")
+        self._repeatable_log(DEBUG, f"[b green]{label}", f"[green]{msg}")
 
-    @staticmethod
-    def labeled_error_print(label: str, msg: str) -> None:
-        """Print an error message with a label to the console.
+    def info_print(self, label: str, msg: str) -> None:
+        """Print info to console.
+
+        :param label: Label for the message.
+        :type label: str
+        :param msg: Message to print.
+        :type msg: str
+        """
+        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.
 
         :param label: Label for the error message.
         :type label: str
         :param msg: Error message to print.
         :type msg: str
         """
-        print(f"\n{Back.RED}{Style.BRIGHT} ERROR {label} {Style.RESET_ALL}{TAB_BLOCK}{Fore.RED}{msg}")
+        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.
+
+        :param msg: Critical message to print.
+        :type msg: str
+        """
+        self._log.critical(f"[b i red]{msg}")
 
     @staticmethod
     def pretty_exception(exception: Exception) -> str:
@@ -61,8 +84,7 @@ class Console:
         """
         return f"{type(exception).__name__}: {exception}"
 
-    @staticmethod
-    def exception_error_print(label: str, exception: Exception) -> None:
+    def exception_error_print(self, label: str, exception: Exception) -> None:
         """Print an error message with exception details to the console.
 
         :param label: Label for the error message.
@@ -70,43 +92,39 @@ class Console:
         :param exception: Exception to print.
         :type exception: Exception
         """
-        Console.labeled_error_print(label, Console.pretty_exception(exception))
-        print_exc()
-
-    def debug_print(self, label: str, msg: str) -> None:
-        """Print a debug message to the console.
-
-        :param label: Label for the debug message.
-        :type label: str
-        :param msg: Debug message to print.
-        :type msg: str
-        """
-        if self._enable_debug:
-            self._repeat_print(f"{Back.BLUE}{Style.BRIGHT} DEBUG {label} {Style.RESET_ALL}{TAB_BLOCK}{Fore.BLUE}{msg}")
+        self._log.exception(f"[b magenta]{label}:[/] [magenta]{Console.pretty_exception(exception)}")
 
-    @staticmethod
-    def info_print(label: str, msg: str) -> None:
-        """Print info to console.
+    # Helper methods.
+    def _repeatable_log(self, log_type: int, label: str, message: str) -> None:
+        """Add a row to the output table.
 
+        :param log_type: Type of log.
+        :type log_type: int
         :param label: Label for the message.
         :type label: str
-        :param msg: Message to print.
-        :type msg: str
+        :param message: Message.
+        :type message: str
         """
-        print(f"\n{Back.GREEN}{Style.BRIGHT} {label} {Style.RESET_ALL}{TAB_BLOCK}{Fore.GREEN}{msg}")
-
-    # Helper methods.
-    def _repeat_print(self, msg: str) -> None:
-        """Print a message to the console with repeat counter.
 
-        :param msg: Message to print.
-        :type msg: str
-        """
-        if msg == self._last_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
-        else:
-            self._repeat_counter = 1
-            self._last_message = msg
-            print()
 
-        print(f"\r{msg}{f" (x{self._repeat_counter})" if self._repeat_counter > 1 else ""}", end="")
+            # 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-2.0.0b1.dist-info → ephys_link-2.0.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ephys-link
-Version: 2.0.0b1
+Version: 2.0.0b5
 Summary: A Python Socket.IO server that allows any Socket.IO-compliant application to communicate with manipulators used in electrophysiology experiments.
 Project-URL: Documentation, https://virtualbrainlab.org/ephys_link/installation_and_use.html
 Project-URL: Issues, https://github.com/VirtualBrainLab/ephys-link/issues
@@ -33,8 +33,9 @@ Requires-Dist: pyserial==3.5
 Requires-Dist: python-socketio[asyncio-client]==5.11.3
 Requires-Dist: pythonnet==3.0.3
 Requires-Dist: requests==2.32.3
+Requires-Dist: rich==13.7.1
 Requires-Dist: sensapex==1.400.1
-Requires-Dist: vbl-aquarium==0.0.19
+Requires-Dist: vbl-aquarium==0.0.22
 Description-Content-Type: text/markdown
 
 # Electrophysiology Manipulator Link
@@ -119,13 +120,12 @@ window instead of `localhost`.
 pip install ephys-link
 ```
 
-Import the modules you need and launch the server.
+Import main and run (this will launch the setup GUI).
 
 ```python
-from ephys_link.server import Server
+from ephys_link.__main__ import main
 
-server = Server()
-server.launch("sensapex", args.proxy_address, 8081)
+main()
 ```
 
 ## Install for Development

ephys_link-2.0.0b5.dist-info/RECORD

@@ -0,0 +1,26 @@
+ephys_link/__about__.py,sha256=W8_pwZswCUyYGNDMBbTV2lPT7qpoSD2adR4yUwvZfkU,25
+ephys_link/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephys_link/__main__.py,sha256=KSwJO4gPQAZitNSNChD1NjkO2j3pc8RA2dkRbiaq32w,1368
+ephys_link/back_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephys_link/back_end/platform_handler.py,sha256=cAHZ3gqA-Y33vb0sfsH085BPVtIfSUGaFVqvTzpA2MA,13168
+ephys_link/back_end/server.py,sha256=QZu8deE57BxULfUutPQ41q3HTmr94nPyzaIT-JoOK2I,8026
+ephys_link/bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephys_link/bindings/fake_bindings.py,sha256=Dk9Bpv4XTYa6ooh5Ge_5-o3IRzdazj5pYMcp3O41UJI,1936
+ephys_link/bindings/mpm_bindings.py,sha256=e4whLU7mJm-Mbw6O2ua6fPHBZNnCiyyGiePEVBr3zzY,9818
+ephys_link/bindings/ump_4_bindings.py,sha256=rmkniiH5KyWjyXGpmUW3RCR_rar40b3vxHwYakrwbqg,4494
+ephys_link/front_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephys_link/front_end/cli.py,sha256=KJBSWqdz4T5z0Zor1tJSHTJKZeMcHAJf5gXXu38wQPU,3105
+ephys_link/front_end/gui.py,sha256=_gE6zFhFnzHPSyYd9MBvfK5xmDZHsUXcETDHzH66QzU,7518
+ephys_link/resources/CP210xManufacturing.dll,sha256=aM9k_XABjkq0TOMiIw8HeteB40zqEkUDNO8wo91EdYI,810232
+ephys_link/resources/NstMotorCtrl.dll,sha256=Xtpr3vBcxhcsOUGvgVEwYtGPvKEqDctIUGCK36GfU2Q,155136
+ephys_link/resources/SiUSBXp.dll,sha256=187zlclZNNezCkU1o1CbICRAmKWJxbh8ahP6L6wo-_Y,469752
+ephys_link/resources/libum.dll,sha256=YaD4dwiSNohx-XxHjx2eQWPOBEVvUIXARvx37e_yqNw,316316
+ephys_link/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ephys_link/util/base_bindings.py,sha256=ukomZftpwa8s_SV-jcwPSXmox0neXf8-uyie_NmiRro,5349
+ephys_link/util/common.py,sha256=Pk7uVqEMFMPKNpeucWda_GfnHogRszej5G5qYkt43d8,3455
+ephys_link/util/console.py,sha256=NvUH-Fp4nzkgrqQOcylctf46x4AW-qAphrtisepk1xY,4325
+ephys_link-2.0.0b5.dist-info/METADATA,sha256=PvHqwUICg5mNPrvMvmGjpwcDQqQEtDzDacv4AuIsj88,7943
+ephys_link-2.0.0b5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ephys_link-2.0.0b5.dist-info/entry_points.txt,sha256=o8wV3AdnJ9o47vg9ymKxPNVq9pMdPq8UZHE_iyAJx-k,124
+ephys_link-2.0.0b5.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+ephys_link-2.0.0b5.dist-info/RECORD,,

ephys_link-2.0.0b1.dist-info/RECORD

@@ -1,25 +0,0 @@
-ephys_link/__about__.py,sha256=QUUi7DnZ0lfA8ZZUdMrPNiqXewCSfYtIqTvB6q6NnGQ,25
-ephys_link/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/__main__.py,sha256=pu7QLmS_30qWpgzeibMVD5FsVhICiK0wi7QkzX6F0qU,1373
-ephys_link/back_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/back_end/platform_handler.py,sha256=5GfyLz8rX8VYypuT9JJokV12mnyUksriFOzRgp6H4W8,12939
-ephys_link/back_end/server.py,sha256=WP5NLJnIKtkVImdRgtZKxWEghd17FjsmpuczYpoFs3Q,7965
-ephys_link/bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/bindings/fake_bindings.py,sha256=_ZpXx4whztbO5jNGNqwoJFdqhIIbZ0VMx4mHkMge1r0,1726
-ephys_link/bindings/ump_4_bindings.py,sha256=1V_bQzq7xVX1qGxbK11nxX7X3L3cfh9RTdhbVJwBKg8,4651
-ephys_link/front_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/front_end/cli.py,sha256=KJBSWqdz4T5z0Zor1tJSHTJKZeMcHAJf5gXXu38wQPU,3105
-ephys_link/front_end/gui.py,sha256=_gE6zFhFnzHPSyYd9MBvfK5xmDZHsUXcETDHzH66QzU,7518
-ephys_link/resources/CP210xManufacturing.dll,sha256=aM9k_XABjkq0TOMiIw8HeteB40zqEkUDNO8wo91EdYI,810232
-ephys_link/resources/NstMotorCtrl.dll,sha256=Xtpr3vBcxhcsOUGvgVEwYtGPvKEqDctIUGCK36GfU2Q,155136
-ephys_link/resources/SiUSBXp.dll,sha256=187zlclZNNezCkU1o1CbICRAmKWJxbh8ahP6L6wo-_Y,469752
-ephys_link/resources/libum.dll,sha256=YaD4dwiSNohx-XxHjx2eQWPOBEVvUIXARvx37e_yqNw,316316
-ephys_link/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/util/base_bindings.py,sha256=FNqhB7kJf2n9g4wYHEBbQ2wEiZscR5sKCnIEZ6yujgE,4808
-ephys_link/util/common.py,sha256=IgmTpXRU2z7jfYV2zB4RGgjV34IaYa2s3TYpzKZkpao,3519
-ephys_link/util/console.py,sha256=kD4LLehdA1xLiGwdvjt5KxImDSyDkcoC2CQVOxTv8T4,3560
-ephys_link-2.0.0b1.dist-info/METADATA,sha256=j_XqMK_IK955IOE0ikj_JhqschZGCOKpgMiWdGzTrQQ,7975
-ephys_link-2.0.0b1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ephys_link-2.0.0b1.dist-info/entry_points.txt,sha256=o8wV3AdnJ9o47vg9ymKxPNVq9pMdPq8UZHE_iyAJx-k,124
-ephys_link-2.0.0b1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-ephys_link-2.0.0b1.dist-info/RECORD,,