ephys-link 2.1.3__py3-none-any.whl → 2.2.1__py3-none-any.whl

ephys_link/__about__.py

@@ -1 +1 @@
-__version__ = "2.1.3"
+__version__ = "2.2.1"

ephys_link/back_end/server.py

@@ -12,22 +12,20 @@ Usage:
     ```
 """
 
-from asyncio import get_event_loop, run
+from asyncio import new_event_loop
 from collections.abc import Callable, Coroutine
 from json import JSONDecodeError, dumps, loads
 from typing import Any, TypeVar, final
-from uuid import uuid4
 
 from aiohttp.web import Application, run_app
 from pydantic import ValidationError
-from socketio import AsyncClient, AsyncServer  # pyright: ignore [reportMissingTypeStubs]
+from socketio import AsyncServer  # pyright: ignore [reportMissingTypeStubs]
 from vbl_aquarium.models.ephys_link import (
     EphysLinkOptions,
     SetDepthRequest,
     SetInsideBrainRequest,
     SetPositionRequest,
 )
-from vbl_aquarium.models.proxy import PinpointIdResponse
 from vbl_aquarium.utils.vbl_base_model import VBLBaseModel
 
 from ephys_link.__about__ import __version__
@@ -36,8 +34,6 @@ from ephys_link.front_end.console import Console
 from ephys_link.utils.constants import (
     MALFORMED_REQUEST_ERROR,
     PORT,
-    PROXY_CLIENT_NOT_INITIALIZED_ERROR,
-    SERVER_NOT_INITIALIZED_ERROR,
     UNKNOWN_EVENT_ERROR,
     cannot_connect_as_client_is_already_connected_error,
     client_disconnected_without_being_connected_error,
@@ -64,60 +60,40 @@ class Server:
         self._platform_handler = platform_handler
         self._console = console
 
-        # Initialize based on proxy usage.
-        self._sio: AsyncServer | AsyncClient = AsyncClient() if self._options.use_proxy else AsyncServer()
-        if not self._options.use_proxy:
-            # Exit if _sio is not a Server.
-            if not isinstance(self._sio, AsyncServer):
-                self._console.critical_print(SERVER_NOT_INITIALIZED_ERROR)
-                raise TypeError(SERVER_NOT_INITIALIZED_ERROR)
+        # Initialize server.
+        self._sio: AsyncServer = AsyncServer()
 
-            self._app = Application()
-            self._sio.attach(self._app)  # pyright: ignore [reportUnknownMemberType]
+        self._app = Application()
+        self._sio.attach(self._app)  # pyright: ignore [reportUnknownMemberType]
 
-            # Bind connection events.
-            _ = self._sio.on("connect", self.connect)  # pyright: ignore [reportUnknownMemberType, reportUnknownVariableType]
-            _ = self._sio.on("disconnect", self.disconnect)  # pyright: ignore [reportUnknownMemberType, reportUnknownVariableType]
+        # Bind connection events.
+        _ = self._sio.on("connect", self.connect)  # pyright: ignore [reportUnknownMemberType, reportUnknownVariableType]
+        _ = self._sio.on("disconnect", self.disconnect)  # pyright: ignore [reportUnknownMemberType, reportUnknownVariableType]
 
         # Store connected client.
         self._client_sid: str = ""
 
-        # Generate Pinpoint ID for proxy usage.
-        self._pinpoint_id = str(uuid4())[:8]
-
         # Bind events.
         _ = self._sio.on("*", self.platform_event_handler)  # pyright: ignore [reportUnknownMemberType, reportUnknownVariableType]
 
     def launch(self) -> None:
-        """Launch the server.
-
-        Based on the options, either connect to a proxy or launch the server locally.
-        """
+        """Launch the server."""
 
         # List platform and available manipulators.
         self._console.info_print("PLATFORM", self._platform_handler.get_display_name())
-        self._console.info_print(
-            "MANIPULATORS",
-            str(get_event_loop().run_until_complete(self._platform_handler.get_manipulators()).manipulators),
-        )
 
-        # Launch server
-        if self._options.use_proxy:
-            self._console.info_print("PINPOINT ID", self._pinpoint_id)
+        # Create a temporary event loop for getting manipulators
+        loop = new_event_loop()
+        try:
+            self._console.info_print(
+                "MANIPULATORS",
+                str(loop.run_until_complete(self._platform_handler.get_manipulators()).manipulators),
+            )
+        finally:
+            loop.close()
 
-            async def connect_proxy() -> None:
-                # Exit if _sio is not a proxy client.
-                if not isinstance(self._sio, AsyncClient):
-                    self._console.critical_print(PROXY_CLIENT_NOT_INITIALIZED_ERROR)
-                    raise TypeError(PROXY_CLIENT_NOT_INITIALIZED_ERROR)
-
-                # noinspection HttpUrlsUsage
-                await self._sio.connect(f"http://{self._options.proxy_address}:{PORT}")  # pyright: ignore [reportUnknownMemberType]
-                await self._sio.wait()
-
-            run(connect_proxy())
-        else:
-            run_app(self._app, port=PORT)
+        # Launch server
+        run_app(self._app, port=PORT)
 
     # Helper functions.
     def _malformed_request_response(self, request: str, data: tuple[tuple[Any], ...]) -> str:  # pyright: ignore [reportExplicitAny]
@@ -244,8 +220,6 @@ class Server:
             # Server metadata.
             case "get_version":
                 return __version__
-            case "get_pinpoint_id":
-                return PinpointIdResponse(pinpoint_id=self._pinpoint_id, is_requester=False).to_json_string()
             case "get_platform_info":
                 return (await self._platform_handler.get_platform_info()).to_json_string()
 

ephys_link/bindings/parallax_binding.py

@@ -0,0 +1,274 @@
+"""Bindings for Parallax for New Scale platform.
+
+Usage: Instantiate ParallaxBinding to interact with the Parallax for New Scale Pathfinder platform.
+"""
+
+from asyncio import get_running_loop, sleep
+from json import dumps
+from typing import Any, final, override
+
+from requests import JSONDecodeError, get, put
+from vbl_aquarium.models.unity import Vector3, Vector4
+
+from ephys_link.utils.base_binding import BaseBinding
+from ephys_link.utils.converters import scalar_mm_to_um, vector4_to_array
+
+
+@final
+class ParallaxBinding(BaseBinding):
+    """Bindings for Parallax for New Scale platform."""
+
+    # Server data update rate (30 FPS).
+    SERVER_DATA_UPDATE_RATE = 1 / 30
+
+    # Movement polling preferences.
+    UNCHANGED_COUNTER_LIMIT = 10
+
+    # Speed preferences (mm/s to use coarse mode).
+    COARSE_SPEED_THRESHOLD = 0.1
+    INSERTION_SPEED_LIMIT = 9_000
+
+    def __init__(self, port: int = 8081) -> None:
+        """Initialize connection to MPM HTTP server.
+
+        Args:
+            port: Port number for MPM HTTP server.
+        """
+        self._url = f"http://localhost:{port}"
+        self._movement_stopped = False
+
+        # Data cache.
+        self.cache: dict[str, Any] = {}  # pyright: ignore [reportExplicitAny]
+        self.cache_time = 0
+
+    @staticmethod
+    @override
+    def get_display_name() -> str:
+        return "Parallax for New Scale"
+
+    @staticmethod
+    @override
+    def get_cli_name() -> str:
+        return "parallax"
+
+    @override
+    async def get_manipulators(self) -> list[str]:
+        data = await self._query_data()
+        return list(data.keys())
+
+    @override
+    async def get_axes_count(self) -> int:
+        return 3
+
+    @override
+    def get_dimensions(self) -> Vector4:
+        return Vector4(x=15, y=15, z=15, w=15)
+
+    @override
+    async def get_position(self, manipulator_id: str) -> Vector4:
+        manipulator_data: dict[str, Any] = await self._manipulator_data(manipulator_id)  # pyright: ignore [reportExplicitAny]
+        global_z = float(manipulator_data.get("global_Z", 0.0) or 0.0)
+
+        await sleep(self.SERVER_DATA_UPDATE_RATE)  # Wait for the stage to stabilize.
+
+        global_x = float(manipulator_data.get("global_X", 0.0) or 0.0)
+        global_y = float(manipulator_data.get("global_Y", 0.0) or 0.0)
+
+        return Vector4(x=global_x, y=global_y, z=global_z, w=global_z)
+
+    @override
+    async def get_angles(self, manipulator_id: str) -> Vector3:
+        manipulator_data: dict[str, Any] = await self._manipulator_data(manipulator_id)  # pyright: ignore [reportExplicitAny]
+
+        yaw = int(manipulator_data.get("yaw", 0) or 0)
+        pitch = int(manipulator_data.get("pitch", 90) or 90)
+        roll = int(manipulator_data.get("roll", 0) or 0)
+
+        return Vector3(x=yaw, y=pitch, z=roll)
+
+    @override
+    async def get_shank_count(self, manipulator_id: str) -> int:
+        manipulator_data: dict[str, Any] = await self._manipulator_data(manipulator_id)  # pyright: ignore [reportExplicitAny]
+        return int(manipulator_data.get("shank_cnt", 1) or 1)
+
+    @staticmethod
+    @override
+    def get_movement_tolerance() -> float:
+        return 0.01
+
+    @override
+    async def set_position(self, manipulator_id: str, position: Vector4, speed: float) -> Vector4:
+        # Keep track of the previous position to check if the manipulator stopped advancing.
+        current_position = await self.get_position(manipulator_id)
+        previous_position = current_position
+        unchanged_counter = 0
+
+        # Set step mode based on speed.
+        await self._put_request(
+            {
+                "move_type": "stepMode",
+                "stage_sn": manipulator_id,
+                "step_mode": 0 if speed > self.COARSE_SPEED_THRESHOLD else 1,
+            }
+        )
+
+        # Send move request.
+        await self._put_request(
+            {
+                "move_type": "moveXYZ",
+                "world": "global",  # Use global coordinates
+                "stage_sn": 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.SERVER_DATA_UPDATE_RATE)
+
+            # Update current position.
+            current_position = await self.get_position(manipulator_id)
+
+            # Check if manipulator is not moving.
+            if self._is_vector_close(previous_position, current_position):
+                # Position did not change.
+                unchanged_counter += 1
+            else:
+                # Position changed.
+                unchanged_counter = 0
+                previous_position = current_position
+
+        # Reset movement stopped flag.
+        self._movement_stopped = False
+
+        # Return the final position.
+        return await self.get_position(manipulator_id)
+
+    @override
+    async def set_depth(self, manipulator_id: str, depth: float, speed: float) -> float:
+        # Keep track of the previous depth to check if the manipulator stopped advancing unexpectedly.
+        current_depth = (await self.get_position(manipulator_id)).w
+        previous_depth = current_depth
+        unchanged_counter = 0
+
+        # Send move request.
+        # Convert mm/s to um/min and cap speed at the limit.
+        await self._put_request(
+            {
+                "move_type": "insertion",
+                "stage_sn": manipulator_id,
+                "world": "global",  # distance in global space
+                "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()
+            and unchanged_counter < self.UNCHANGED_COUNTER_LIMIT
+        ):
+            # Wait for a short time before checking again.
+            await sleep(self.SERVER_DATA_UPDATE_RATE)
+
+            # Get the current depth.
+            current_depth = (await self.get_position(manipulator_id)).w
+
+            # Check if manipulator is not moving.
+            if abs(previous_depth - current_depth) <= self.get_movement_tolerance():
+                # Depth did not change.
+                unchanged_counter += 1
+            else:
+                # Depth changed.
+                unchanged_counter = 0
+                previous_depth = current_depth
+
+        # Reset movement stopped flag.
+        self._movement_stopped = False
+
+        # Return the final depth.
+        return float((await self.get_position(manipulator_id)).w)
+
+    @override
+    async def stop(self, manipulator_id: str) -> None:
+        request: dict[str, str | int | float] = {
+            "PutId": "stop",
+            "Probe": manipulator_id,
+        }
+        await self._put_request(request)
+        self._movement_stopped = True
+
+    @override
+    def platform_space_to_unified_space(self, platform_space: Vector4) -> Vector4:
+        # unified   <-  platform
+        # +x        <-  +x
+        # +y        <-  +z
+        # +z        <-  +y
+        # +w        <-  +w
+
+        return Vector4(
+            x=platform_space.x,
+            y=platform_space.z,
+            z=platform_space.y,
+            w=self.get_dimensions().w - platform_space.w,
+        )
+
+    @override
+    def unified_space_to_platform_space(self, unified_space: Vector4) -> Vector4:
+        # platform  <-  unified
+        # +x        <-  +x
+        # +y        <-  +z
+        # +z        <-  +y
+        # +w        <-  -w
+
+        return Vector4(
+            x=unified_space.x,
+            y=unified_space.z,
+            z=unified_space.y,
+            w=self.get_dimensions().w - unified_space.w,
+        )
+
+    # Helper functions.
+    async def _query_data(self) -> dict[str, Any]:  # pyright: ignore [reportExplicitAny]
+        try:
+            # Update cache if it's expired.
+            if get_running_loop().time() - self.cache_time > self.SERVER_DATA_UPDATE_RATE:
+                # noinspection PyTypeChecker
+                self.cache = (await get_running_loop().run_in_executor(None, get, self._url)).json()
+                self.cache_time = get_running_loop().time()
+        except ConnectionError as connectionError:
+            error_message = f"Unable to connect to MPM HTTP server: {connectionError}"
+            raise RuntimeError(error_message) from connectionError
+        except JSONDecodeError as jsonDecodeError:
+            error_message = f"Unable to decode JSON response from MPM HTTP server: {jsonDecodeError}"
+            raise ValueError(error_message) from jsonDecodeError
+        else:
+            # Return cached data.
+            return self.cache
+
+    async def _manipulator_data(self, manipulator_id: str) -> dict[str, Any]:  # pyright: ignore [reportExplicitAny]
+        """Retrieve data for a specific manipulator (probe) using its serial number."""
+        data = await self._query_data()
+
+        if manipulator_id in data:
+            return data[manipulator_id]  # pyright: ignore [reportAny]
+
+        # If we get here, that means the manipulator doesn't exist.
+        error_message = f"Manipulator {manipulator_id} not found."
+        raise ValueError(error_message)
+
+    async def _put_request(self, request: dict[str, Any]) -> None:  # pyright: ignore [reportExplicitAny]
+        _ = await get_running_loop().run_in_executor(None, put, self._url, dumps(request))
+
+    def _is_vector_close(self, target: Vector4, current: Vector4) -> bool:
+        return all(abs(axis) <= self.get_movement_tolerance() for axis in vector4_to_array(target - current)[:3])

ephys_link/bindings/ump_binding.py

@@ -142,7 +142,7 @@ class UmpBinding(BaseBinding):
 
     @override
     async def stop(self, manipulator_id: str) -> None:
-        self._get_device(manipulator_id).stop()
+        self._get_device(manipulator_id).stop()  # pyright: ignore [reportUnknownMemberType]
 
     @override
     def platform_space_to_unified_space(self, platform_space: Vector4) -> Vector4:

ephys_link/front_end/cli.py

@@ -47,7 +47,7 @@ class CLI:
             type=str,
             dest="type",
             default="ump",
-            help='Manipulator type (i.e. "ump", "pathfinder-mpm", "fake"). Default: "ump".',
+            help='Manipulator type ("ump", "pathfinder-mpm", "parallax", "fake"). Default: "ump".',
         )
         _ = self._parser.add_argument(
             "-d",
@@ -56,27 +56,19 @@ class CLI:
             action="store_true",
             help="Enable debug mode.",
         )
-        _ = self._parser.add_argument(
-            "-p",
-            "--use-proxy",
-            dest="use_proxy",
-            action="store_true",
-            help="Enable proxy mode.",
-        )
-        _ = self._parser.add_argument(
-            "-a",
-            "--proxy-address",
-            type=str,
-            default="proxy2.virtualbrainlab.org",
-            dest="proxy_address",
-            help="Proxy IP address.",
-        )
         _ = self._parser.add_argument(
             "--mpm-port",
             type=int,
             default=8080,
             dest="mpm_port",
-            help="Port New Scale Pathfinder MPM's server is on. Default: 8080.",
+            help="HTTP port New Scale Pathfinder MPM's server is on. Default: 8080.",
+        )
+        _ = self._parser.add_argument(
+            "--parallax-port",
+            type=int,
+            default=8081,
+            dest="parallax_port",
+            help="HTTP port Parallax's server is on. Default: 8081.",
         )
         _ = self._parser.add_argument(
             "-s",

ephys_link/front_end/gui.py

@@ -12,7 +12,7 @@ from json import load
 from os import makedirs
 from os.path import exists, join
 from socket import gethostbyname, gethostname
-from sys import exit
+from sys import exit as sys_exit
 from tkinter import CENTER, RIGHT, BooleanVar, E, IntVar, StringVar, Tk, ttk
 from typing import final
 
@@ -52,8 +52,6 @@ class GUI:
         self._ignore_updates = BooleanVar(value=options.ignore_updates)
         self._type = StringVar(value=options.type)
         self._debug = BooleanVar(value=options.debug)
-        self._use_proxy = BooleanVar(value=options.use_proxy)
-        self._proxy_address = StringVar(value=options.proxy_address)
         self._mpm_port = IntVar(value=options.mpm_port)
         self._serial = StringVar(value=options.serial)
 
@@ -73,15 +71,13 @@ class GUI:
 
         # Exit if the user did not submit options.
         if not self._submit:
-            exit(1)
+            sys_exit(1)
 
         # Extract options from GUI.
         options = EphysLinkOptions(
             ignore_updates=self._ignore_updates.get(),
             type=self._type.get(),
             debug=self._debug.get(),
-            use_proxy=self._use_proxy.get(),
-            proxy_address=self._proxy_address.get(),
             mpm_port=self._mpm_port.get(),
             serial=self._serial.get(),
         )
@@ -115,40 +111,23 @@ class GUI:
         ttk.Label(server_serving_settings, text="Local IP:", anchor=E, justify=RIGHT).grid(column=0, row=0, sticky="we")
         ttk.Label(server_serving_settings, text=gethostbyname(gethostname())).grid(column=1, row=0, sticky="we")
 
-        # Proxy.
-        ttk.Label(server_serving_settings, text="Use Proxy:", anchor=E, justify=RIGHT).grid(
-            column=0, row=1, sticky="we"
-        )
-        ttk.Checkbutton(
-            server_serving_settings,
-            variable=self._use_proxy,
-        ).grid(column=1, row=1, sticky="we")
-
-        # Proxy address.
-        ttk.Label(server_serving_settings, text="Proxy Address:", anchor=E, justify=RIGHT).grid(
-            column=0, row=2, sticky="we"
-        )
-        ttk.Entry(server_serving_settings, textvariable=self._proxy_address, justify=CENTER).grid(
-            column=1, row=2, sticky="we"
-        )
-
         # Ignore updates.
         ttk.Label(server_serving_settings, text="Ignore Updates:", anchor=E, justify=RIGHT).grid(
-            column=0, row=4, sticky="we"
+            column=0, row=1, sticky="we"
         )
         ttk.Checkbutton(
             server_serving_settings,
             variable=self._ignore_updates,
-        ).grid(column=1, row=4, sticky="we")
+        ).grid(column=1, row=1, sticky="we")
 
         # Debug mode.
         ttk.Label(server_serving_settings, text="Debug mode:", anchor=E, justify=RIGHT).grid(
-            column=0, row=5, sticky="we"
+            column=0, row=2, sticky="we"
         )
         ttk.Checkbutton(
             server_serving_settings,
             variable=self._debug,
-        ).grid(column=1, row=5, sticky="we")
+        ).grid(column=1, row=2, sticky="we")
 
         # ---
 

ephys_link/utils/constants.py

@@ -58,9 +58,6 @@ def did_not_reach_target_depth_error(request: SetDepthRequest, final_unified_dep
 
 EMERGENCY_STOP_MESSAGE = "Emergency Stopping All Manipulators..."
 
-SERVER_NOT_INITIALIZED_ERROR = "Server not initialized."
-PROXY_CLIENT_NOT_INITIALIZED_ERROR = "Proxy client not initialized."
-
 
 def cannot_connect_as_client_is_already_connected_error(new_client_sid: str, current_client_sid: str) -> str:
     """Generate an error message for when the client is already connected.

ephys_link/utils/startup.py

@@ -5,11 +5,14 @@ from inspect import getmembers, isclass
 from pkgutil import iter_modules
 
 from packaging.version import parse
-from requests import ConnectionError, ConnectTimeout, get
+from requests import ConnectionError as RequestsConnectionError
+from requests import ConnectTimeout as RequestsConnectTimeout
+from requests import get
 from vbl_aquarium.models.ephys_link import EphysLinkOptions
 
 from ephys_link.__about__ import __version__
 from ephys_link.bindings.mpm_binding import MPMBinding
+from ephys_link.bindings.parallax_binding import ParallaxBinding
 from ephys_link.front_end.console import Console
 from ephys_link.utils.base_binding import BaseBinding
 from ephys_link.utils.constants import (
@@ -44,7 +47,7 @@ def check_for_updates(console: Console) -> None:
         if parse(latest_version) > parse(__version__):
             console.critical_print(f"Update available: {latest_version} (current: {__version__})")
             console.critical_print("Download at: https://github.com/VirtualBrainLab/ephys-link/releases/latest")
-    except (ConnectionError, ConnectTimeout):
+    except (RequestsConnectionError, RequestsConnectTimeout):
         console.error_print("UPDATE", UNABLE_TO_CHECK_FOR_UPDATES_ERROR)
 
 
@@ -89,12 +92,15 @@ def get_binding_instance(options: EphysLinkOptions, console: Console) -> BaseBin
             selected_type = "ump"
 
         if binding_cli_name == selected_type:
-            # Pass in HTTP port for Pathfinder MPM.
-            if binding_cli_name == "pathfinder-mpm":
-                return MPMBinding(options.mpm_port)
-
-            # Otherwise just return the binding.
-            return binding_type()
+            # Pass in HTTP port for Pathfinder MPM and Parallax.
+            match binding_cli_name:
+                case "pathfinder-mpm":
+                    return MPMBinding(options.mpm_port)
+                case "parallax":
+                    return ParallaxBinding(options.parallax_port)
+                case _:
+                    # Otherwise just return the binding.
+                    return binding_type()
 
     # Raise an error if the platform type is not recognized.
     error_message = unrecognized_platform_type_error(selected_type)

{ephys_link-2.1.3.dist-info → ephys_link-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ephys-link
-Version: 2.1.3
+Version: 2.2.1
 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
@@ -17,22 +17,21 @@ Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
-Requires-Python: >=3.13
-Requires-Dist: aiohttp==3.12.15
+Requires-Python: >=3.10
+Requires-Dist: aiohttp==3.13.2
 Requires-Dist: colorama==0.4.6
 Requires-Dist: keyboard==0.13.5
 Requires-Dist: packaging==25.0
-Requires-Dist: platformdirs==4.4.0
+Requires-Dist: platformdirs==4.5.1
 Requires-Dist: pyserial==3.5
-Requires-Dist: python-socketio[asyncio-client]==5.13.0
+Requires-Dist: python-socketio==5.15.1
 Requires-Dist: requests==2.32.5
-Requires-Dist: rich==14.1.0
-Requires-Dist: sensapex==1.400.4
-Requires-Dist: vbl-aquarium==1.0.0
+Requires-Dist: rich==14.2.0
+Requires-Dist: sensapex==1.504.1
+Requires-Dist: vbl-aquarium==1.2.0
 Description-Content-Type: text/markdown
 
 # Electrophysiology Manipulator Link

{ephys_link-2.1.3.dist-info → ephys_link-2.2.1.dist-info}/RECORD

@@ -1,24 +1,25 @@
-ephys_link/__about__.py,sha256=-5z5R8xV0UToQjp9-3ipF_dBiBdRXtdotx4_h9ZJZT8,22
+ephys_link/__about__.py,sha256=4dqvKTDgbqeyzbWj6hYiNdzxsI8j1YOKSLM8vF6a0j4,22
 ephys_link/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ephys_link/__main__.py,sha256=54zxQ-fyxC2-LGsTUdtlvib36ZZQwNyOa6IuffYLhhs,1582
 ephys_link/back_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ephys_link/back_end/platform_handler.py,sha256=6Lt_jaIcO9jTmWYOoWYkuhwSlCTT1Qfd53ru31X0fmc,10130
-ephys_link/back_end/server.py,sha256=uZOK9UQq4gp7yx6_4dZrfRTjsio2WXT8TwjO4E5kECA,10712
+ephys_link/back_end/server.py,sha256=ILrYbd4r_4GiRmdUEmGcbT1AEIo_TF3i-BZpdhYm8g8,9296
 ephys_link/bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ephys_link/bindings/fake_binding.py,sha256=PI7zYv-SjWsGFEs_FVu5Z5l9gykIqG3C7pQISdbwdoY,2357
 ephys_link/bindings/mpm_binding.py,sha256=vn7IKqdiZ6_MX91zomqDXX08ONHwVVgWncRuJTxJpOM,10872
-ephys_link/bindings/ump_binding.py,sha256=wbJe6Ro4E-TPejBBDkNsKUluF2Gr0rZBuyp3LJ2TipM,7865
+ephys_link/bindings/parallax_binding.py,sha256=QzZ4MVUc4YGlIxr9__j8I3t3MyGuoQdsZWgHaSedZ3A,10129
+ephys_link/bindings/ump_binding.py,sha256=X71n5P3IPlWmQ2BaHUI-UHu-RP__ZOgA3w32iT3169U,7910
 ephys_link/front_end/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ephys_link/front_end/cli.py,sha256=jWUEWhIHvWF8ZN6xPIbfoQblDWxMLsjwhtFB_jfOO_s,3093
+ephys_link/front_end/cli.py,sha256=vbJYFoaOwPwQq3ShR60HgPQnE-hK6kp1_9FEFkyZ6AU,2899
 ephys_link/front_end/console.py,sha256=zq67dn7T4xKMg3jjbNra_1s0N9ItvsTRXVIhClWbjP8,3912
-ephys_link/front_end/gui.py,sha256=x5mNekxe1yhPKcCFNnDL3AarhNmUoBJooykFS_6pWt4,7227
+ephys_link/front_end/gui.py,sha256=MagojumetQGp7e8sK53cI_TgcqKSx54jLNeZagBjNJY,6383
 ephys_link/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ephys_link/utils/base_binding.py,sha256=rq0FtvkjAN287nX8rZwR-j6YPzV3Pkp8PqJfZlhIzqo,5413
-ephys_link/utils/constants.py,sha256=afD-FFrfCD3cZc500jzWw4I-dGibLPluxteX8BxlgK4,3883
+ephys_link/utils/constants.py,sha256=l1-KmGFzAgaBzEIgtmFLfpijum75_1JMdSq5GyR3TJk,3756
 ephys_link/utils/converters.py,sha256=ZdVmIX-LHCwM__F0SpjN_mfNGGetr1U97xvHd0hf8T0,2038
-ephys_link/utils/startup.py,sha256=Yx9LSedaLmTpzkb1E0NOqxaDMhRXLShkI2PJj80_95U,3620
-ephys_link-2.1.3.dist-info/METADATA,sha256=n5GnLJF6kEThTRiROqyyQNhmByH6Fx7a1pyxH1osDJQ,4775
-ephys_link-2.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ephys_link-2.1.3.dist-info/entry_points.txt,sha256=o8wV3AdnJ9o47vg9ymKxPNVq9pMdPq8UZHE_iyAJx-k,124
-ephys_link-2.1.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ephys_link-2.1.3.dist-info/RECORD,,
+ephys_link/utils/startup.py,sha256=lK04UffvdcASpmp8Arecfmm1dDhzZnZy2rgzQ8sqWag,3971
+ephys_link-2.2.1.dist-info/METADATA,sha256=nHO5FaFAmKoqwYbH2gHOvPh-e8-AgyA7TqFoN9zLokM,4707
+ephys_link-2.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ephys_link-2.2.1.dist-info/entry_points.txt,sha256=o8wV3AdnJ9o47vg9ymKxPNVq9pMdPq8UZHE_iyAJx-k,124
+ephys_link-2.2.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ephys_link-2.2.1.dist-info/RECORD,,

{ephys_link-2.1.3.dist-info → ephys_link-2.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any