ephys-link 2.0.0b1__tar.gz → 2.0.0b5__tar.gz

{ephys_link-2.0.0b1 → ephys_link-2.0.0b5}/PKG-INFO

@@ -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.0b1 → ephys_link-2.0.0b5}/README.md

@@ -80,13 +80,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.0b1 → ephys_link-2.0.0b5}/pyproject.toml

@@ -38,7 +38,8 @@ dependencies = [
     "pythonnet==3.0.3",
     "requests==2.32.3",
     "sensapex==1.400.1",
-    "vbl-aquarium==0.0.19"
+    "rich==13.7.1",
+    "vbl-aquarium==0.0.22"
 ]
 
 [project.urls]
@@ -60,6 +61,7 @@ exclude = ["/.github", "/.idea"]
 [tool.hatch.envs.default]
 python = "3.12"
 dependencies = [
+    "mypy",
     "coverage[toml]>=6.5",
     "pytest",
 ]
@@ -114,4 +116,7 @@ exclude_lines = [
     "no cov",
     "if __name__ == .__main__.:",
     "if TYPE_CHECKING:",
-]
+]
+
+[tool.ruff.lint]
+extend-ignore = ["DTZ005"]

ephys_link-2.0.0b5/qodana.yaml

@@ -0,0 +1,29 @@
+#-------------------------------------------------------------------------------#
+#               Qodana analysis is configured by qodana.yaml file               #
+#             https://www.jetbrains.com/help/qodana/qodana-yaml.html            #
+#-------------------------------------------------------------------------------#
+version: "1.0"
+
+#Specify inspection profile for code analysis
+profile:
+  name: qodana.starter
+
+#Enable inspections
+#include:
+#  - name: <SomeEnabledInspectionId>
+
+#Disable inspections
+#exclude:
+#  - name: <SomeDisabledInspectionId>
+#    paths:
+#      - <path/where/not/run/inspection>
+
+#Execute shell command before Qodana execution (Applied in CI/CD pipeline)
+#bootstrap: sh ./prepare-qodana.sh
+
+#Install IDE plugins before Qodana execution (Applied in CI/CD pipeline)
+#plugins:
+#  - id: <plugin.id> #(plugin id can be found at https://plugins.jetbrains.com)
+
+#Specify Qodana linter for analysis (Applied in CI/CD pipeline)
+linter: jetbrains/qodana-python:latest

ephys_link-2.0.0b5/scripts/logger_test.py

@@ -0,0 +1,17 @@
+import logging
+
+from rich.logging import RichHandler
+
+logging.basicConfig(level="NOTSET", format="%(message)s", datefmt="[%X]", handlers=[RichHandler(rich_tracebacks=True)])
+
+log = logging.getLogger("rich")
+log.debug("This message should go to the log file")
+log.info("So should this")
+log.warning("And this, too")
+log.error("And non-ASCII stuff, too, like Øresund and Malmö")
+log.error("[bold red blink]Server is shutting down!", extra={"markup": True})
+log.critical("Critical error! [b red]Server is shutting down!", extra={"markup": True})
+try:
+    print(1 / 0)
+except Exception:
+    log.exception("[b magenta]unable print![/] [i magenta]asdf", extra={"markup": True})

ephys_link-2.0.0b5/scripts/move_tester.py

@@ -0,0 +1,16 @@
+from asyncio import run
+
+from vbl_aquarium.models.ephys_link import EphysLinkOptions, SetDepthRequest
+from vbl_aquarium.models.unity import Vector4
+
+from ephys_link.back_end.platform_handler import PlatformHandler
+from ephys_link.util.console import Console
+
+c = Console(enable_debug=True)
+p = PlatformHandler(EphysLinkOptions(type="pathfinder-mpm"), c)
+# target = Vector4()
+target = Vector4(x=7.5, y=7.5, z=7.5, w=7.5)
+
+# print(run(p.set_position(SetPositionRequest(manipulator_id="A", position=target, speed=5))).to_json_string())
+print(run(p.set_depth(SetDepthRequest(manipulator_id="A", depth=7.5, speed=0.15))).to_json_string())
+print("Done!")

ephys_link-2.0.0b5/src/ephys_link/__about__.py

@@ -0,0 +1 @@
+__version__ = "2.0.0b5"

{ephys_link-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b5/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b1 → ephys_link-2.0.0b5}/src/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-2.0.0b5/src/ephys_link/util/console.py

@@ -0,0 +1,130 @@
+# ruff: noqa: T201
+"""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 rich.logging import RichHandler
+from rich.traceback import install
+
+
+class Console:
+    def __init__(self, *, enable_debug: bool) -> None:
+        """Initialize console properties.
+
+        :param enable_debug: Enable debug mode.
+        :type enable_debug: bool
+        """
+        # 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.
+
+        :param label: Label for the debug message.
+        :type label: str
+        :param msg: Debug message to print.
+        :type msg: str
+        """
+        self._repeatable_log(DEBUG, f"[b green]{label}", f"[green]{msg}")
+
+    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
+        """
+        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:
+        """Pretty print an exception.
+
+        :param exception: Exception to pretty print.
+        :type exception: Exception
+        :return: Pretty printed exception.
+        :rtype: str
+        """
+        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.
+
+        :param label: Label for the error message.
+        :type label: str
+        :param exception: Exception to print.
+        :type exception: Exception
+        """
+        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.
+
+        :param log_type: Type of log.
+        :type log_type: int
+        :param label: Label for the message.
+        :type label: str
+        :param message: Message.
+        :type message: str
+        """
+
+        # 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-2.0.0b1/scripts/move_tester.py

@@ -1,15 +0,0 @@
-from asyncio import run
-
-from vbl_aquarium.models.ephys_link import SetPositionRequest
-from vbl_aquarium.models.unity import Vector4
-
-from ephys_link.back_end.platform_handler import PlatformHandler
-from ephys_link.util.console import Console
-
-c = Console(enable_debug=True)
-p = PlatformHandler("ump-4", c)
-target = Vector4()
-# target = Vector4(x=10, y=10, z=10, w=10)
-
-print(run(p.set_position(SetPositionRequest(manipulator_id="6", position=target, speed=5))).to_json_string())
-print("Done!")

ephys_link-2.0.0b1/src/ephys_link/__about__.py

@@ -1 +0,0 @@
-__version__ = "2.0.0b1"

ephys_link-2.0.0b1/src/ephys_link/util/console.py

@@ -1,112 +0,0 @@
-# ruff: noqa: T201
-"""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 traceback import print_exc
-
-from colorama import Back, Fore, Style, init
-
-# Constants.
-TAB_BLOCK = "\t\t"
-
-
-class Console:
-    def __init__(self, *, enable_debug: bool) -> None:
-        """Initialize console properties.
-
-        :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
-
-        # Initialize colorama.
-        init(autoreset=True)
-
-    @staticmethod
-    def error_print(msg: str) -> None:
-        """Print an error message to the console.
-
-        :param msg: Error message to print.
-        :type msg: str
-        """
-        print(f"\n{Back.RED}{Style.BRIGHT} ERROR {Style.RESET_ALL}{TAB_BLOCK}{Fore.RED}{msg}")
-
-    @staticmethod
-    def labeled_error_print(label: str, msg: str) -> None:
-        """Print an error message with a label 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}")
-
-    @staticmethod
-    def pretty_exception(exception: Exception) -> str:
-        """Pretty print an exception.
-
-        :param exception: Exception to pretty print.
-        :type exception: Exception
-        :return: Pretty printed exception.
-        :rtype: str
-        """
-        return f"{type(exception).__name__}: {exception}"
-
-    @staticmethod
-    def exception_error_print(label: str, exception: Exception) -> None:
-        """Print an error message with exception details to the console.
-
-        :param label: Label for the error message.
-        :type label: str
-        :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}")
-
-    @staticmethod
-    def info_print(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
-        """
-        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:
-            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="")