ephys-link 2.1.3__tar.gz → 2.2.0__tar.gz

{ephys_link-2.1.3 → ephys_link-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ephys-link
-Version: 2.1.3
+Version: 2.2.0
 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 → ephys_link-2.2.0}/mkdocs.yml

@@ -107,5 +107,6 @@ nav:
       - development/index.md
       - development/socketio_api.md
       - development/adding_a_manipulator.md
+      - development/jackhammer_mode.md
       - development/code_organization.md
       - Source Code Reference: reference/

{ephys_link-2.1.3 → ephys_link-2.2.0}/pyproject.toml

@@ -7,14 +7,13 @@ name = "ephys-link"
 dynamic = ["version"]
 description = "A Python Socket.IO server that allows any Socket.IO-compliant application to communicate with manipulators used in electrophysiology experiments."
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.10"
 license = "GPL-3.0-only"
 keywords = ["socket-io", "manipulator", "electrophysiology", "ephys", "sensapex", "neuroscience", "neurotech", "virtualbrainlab", "new-scale"]
 authors = [{ name = "Kenneth Yang", email = "kjy5@uw.edu" }]
 maintainers = [{ name = "Kenneth Yang", email = "kjy5@uw.edu" }]
 classifiers = [
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Programming Language :: Python :: 3",
@@ -26,17 +25,17 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Medical Science Apps.",
 ]
 dependencies = [
-    "aiohttp==3.12.15",
+    "aiohttp==3.13.2",
     "colorama==0.4.6",
     "keyboard==0.13.5",
     "packaging==25.0",
-    "platformdirs==4.4.0",
+    "platformdirs==4.5.1",
     "pyserial==3.5",
-    "python-socketio[asyncio_client]==5.13.0",
+    "python-socketio==5.15.1",
     "requests==2.32.5",
-    "sensapex==1.400.4",
-    "rich==14.1.0",
-    "vbl-aquarium==1.0.0"
+    "sensapex==1.504.1",
+    "rich==14.2.0",
+    "vbl-aquarium==1.2.0"
 ]
 
 [project.urls]
@@ -57,14 +56,14 @@ exclude = ["/.github", "/.idea", "/docs"]
 
 [tool.hatch.envs.default]
 installer = "uv"
-python = "3.13"
+python = "3.14"
 dependencies = [
-    "pyinstaller==6.15.0",
-    "basedpyright==1.31.4",
+    "pyinstaller==6.16.0",
+    "basedpyright==1.32.1",
     "pytest==8.4.2",
-    "pytest-cov==6.3.0",
-    "pytest-mock==3.15.0",
-    "pytest-asyncio==1.1.0"
+    "pytest-cov==7.0.0",
+    "pytest-mock==3.15.1",
+    "pytest-asyncio==1.2.0"
 ]
 [tool.hatch.envs.default.scripts]
 exe = "pyinstaller.exe ephys_link.spec -y -- -d && pyinstaller.exe ephys_link.spec -y"
@@ -76,7 +75,7 @@ cov = "pytest --cov=ephys_link --cov-report=html --cov-report=term-missing"
 
 [tool.hatch.envs.docs]
 installer = "uv"
-python = "3.13"
+python = "3.14"
 skip-install = true
 dependencies = [
     "mkdocs-material==9.6.19",

ephys_link-2.2.0/src/ephys_link/__about__.py

@@ -0,0 +1 @@
+__version__ = "2.2.0"

{ephys_link-2.1.3 → ephys_link-2.2.0}/src/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-2.2.0/src/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-2.1.3 → ephys_link-2.2.0}/src/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-2.1.3 → ephys_link-2.2.0}/src/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-2.1.3 → ephys_link-2.2.0}/src/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-2.1.3 → ephys_link-2.2.0}/src/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-2.1.3 → ephys_link-2.2.0}/src/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 → ephys_link-2.2.0}/tests/back_end/test_server.py

@@ -1,10 +1,7 @@
-import asyncio
-from collections.abc import Awaitable
 from json import dumps, loads
 
 import pytest
 from pytest_mock import MockerFixture
-from socketio import AsyncClient, AsyncServer  # pyright: ignore[reportMissingTypeStubs]
 from vbl_aquarium.models.ephys_link import (
     AngularResponse,
     BooleanStateResponse,
@@ -18,7 +15,6 @@ from vbl_aquarium.models.ephys_link import (
     SetPositionRequest,
     ShankCountResponse,
 )
-from vbl_aquarium.models.proxy import PinpointIdResponse
 
 import ephys_link.back_end.server
 from ephys_link.__about__ import __version__
@@ -27,8 +23,6 @@ from ephys_link.back_end.server import Server
 from ephys_link.front_end.console import Console
 from ephys_link.utils.constants import (
     MALFORMED_REQUEST_ERROR,
-    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,
@@ -50,27 +44,7 @@ class TestServer:
     @pytest.fixture
     def server(self, platform_handler: PlatformHandler, console: Console) -> Server:
         """Fixture for server."""
-        return Server(EphysLinkOptions(use_proxy=False), platform_handler, console)
-
-    @pytest.fixture
-    def proxy_client(self, platform_handler: PlatformHandler, console: Console) -> Server:
-        """Fixture for server as proxy client."""
-        return Server(EphysLinkOptions(use_proxy=True), platform_handler, console)
-
-    def test_failed_server_init(
-        self, platform_handler: PlatformHandler, console: Console, mocker: MockerFixture
-    ) -> None:
-        """Server should raise error if sio is not an AsyncServer."""
-        # Mock out the AsyncServer init.
-        patched_async_server = mocker.patch.object(AsyncServer, "__new__")
-
-        # Act
-        with pytest.raises(TypeError) as init_error:
-            _ = Server(EphysLinkOptions(use_proxy=False), platform_handler, console)
-
-        # Assert
-        patched_async_server.assert_called_once()
-        assert init_error.value.args[0] == SERVER_NOT_INITIALIZED_ERROR
+        return Server(EphysLinkOptions(), platform_handler, console)
 
     def test_launch_server(
         self, server: Server, platform_handler: PlatformHandler, console: Console, mocker: MockerFixture
@@ -88,8 +62,8 @@ class TestServer:
         patched_run_until_complete = mocker.patch.object(
             asyncio_loop, "run_until_complete", return_value=GetManipulatorsResponse(manipulators=DUMMY_STRING_LIST)
         )
-        patched_get_event_loop = mocker.patch.object(
-            ephys_link.back_end.server, "get_event_loop", return_value=asyncio_loop
+        patched_new_event_loop = mocker.patch.object(
+            ephys_link.back_end.server, "new_event_loop", return_value=asyncio_loop
         )
 
         # Mock out run_app.
@@ -102,103 +76,11 @@ class TestServer:
         patched_get_display_name.assert_called_once()
         patched_get_manipulators.assert_called_once()
         patched_run_until_complete.assert_called_once()
-        patched_get_event_loop.assert_called_once()
+        patched_new_event_loop.assert_called_once()
         spied_info_print.assert_any_call("PLATFORM", platform_handler.get_display_name())
         spied_info_print.assert_any_call("MANIPULATORS", str(DUMMY_STRING_LIST))
         mocked_run_app.assert_called_once()
 
-    def test_launch_proxy_client(
-        self, proxy_client: Server, platform_handler: PlatformHandler, console: Console, mocker: MockerFixture
-    ) -> None:
-        """Proxy client should print info then start."""
-        # Add mocks and spies.
-        # noinspection DuplicatedCode
-        spied_info_print = mocker.spy(console, "info_print")
-
-        patched_get_display_name = mocker.patch.object(platform_handler, "get_display_name", return_value=DUMMY_STRING)
-
-        # Mock out get manipulators.
-        patched_get_manipulators = mocker.patch.object(platform_handler, "get_manipulators", new=mocker.Mock())
-        asyncio_loop = mocker.Mock()
-        patched_run_until_complete = mocker.patch.object(
-            asyncio_loop, "run_until_complete", return_value=GetManipulatorsResponse(manipulators=DUMMY_STRING_LIST)
-        )
-        patched_get_event_loop = mocker.patch.object(
-            ephys_link.back_end.server, "get_event_loop", return_value=asyncio_loop
-        )
-
-        # Mock out run.
-        def run_coroutine(coroutine: Awaitable[None]) -> None:
-            """Run the coroutine."""
-            asyncio.new_event_loop().run_until_complete(coroutine)
-
-        _ = mocker.patch.object(ephys_link.back_end.server, "run", new=run_coroutine)
-        patched_connect = mocker.patch.object(AsyncClient, "connect", new_callable=mocker.AsyncMock)
-        patched_wait = mocker.patch.object(AsyncClient, "wait", new_callable=mocker.AsyncMock)
-
-        # Act.
-        proxy_client.launch()
-
-        # Assert.
-        patched_get_display_name.assert_called_once()
-        patched_get_manipulators.assert_called_once()
-        patched_run_until_complete.assert_called_once()
-        patched_get_event_loop.assert_called_once()
-        spied_info_print.assert_any_call("PLATFORM", platform_handler.get_display_name())
-        spied_info_print.assert_any_call("MANIPULATORS", str(DUMMY_STRING_LIST))
-        spied_info_print.assert_any_call("PINPOINT ID", mocker.ANY)  # pyright: ignore[reportAny]
-        patched_connect.assert_awaited_once()  # pyright: ignore[reportUnusedCallResult]
-        patched_wait.assert_awaited_once()  # pyright: ignore[reportUnusedCallResult]
-
-    def test_launch_proxy_client_failed_init(
-        self, platform_handler: PlatformHandler, console: Console, mocker: MockerFixture
-    ) -> None:
-        """Proxy client should print info then start."""
-        # Add mocks and spies.
-        # noinspection DuplicatedCode
-        spied_info_print = mocker.spy(console, "info_print")
-
-        patched_get_display_name = mocker.patch.object(platform_handler, "get_display_name", return_value=DUMMY_STRING)
-
-        # Mock out get manipulators.
-        patched_get_manipulators = mocker.patch.object(platform_handler, "get_manipulators", new=mocker.Mock())
-        asyncio_loop = mocker.Mock()
-        patched_run_until_complete = mocker.patch.object(
-            asyncio_loop, "run_until_complete", return_value=GetManipulatorsResponse(manipulators=DUMMY_STRING_LIST)
-        )
-        patched_get_event_loop = mocker.patch.object(
-            ephys_link.back_end.server, "get_event_loop", return_value=asyncio_loop
-        )
-
-        # Mock out run.
-        def run_coroutine(coroutine: Awaitable[None]) -> None:
-            """Run the coroutine."""
-            asyncio.new_event_loop().run_until_complete(coroutine)
-
-        _ = mocker.patch.object(ephys_link.back_end.server, "run", new=run_coroutine)
-        patched_connect = mocker.patch.object(AsyncClient, "connect", new_callable=mocker.AsyncMock)
-        patched_wait = mocker.patch.object(AsyncClient, "wait", new_callable=mocker.AsyncMock)
-
-        # Mock out the AsyncServer init.
-        patched_async_server = mocker.patch.object(AsyncClient, "__new__")
-
-        # Act
-        with pytest.raises(TypeError) as init_error:
-            Server(EphysLinkOptions(use_proxy=True), platform_handler, console).launch()
-
-        # Assert.
-        patched_async_server.assert_called_once()
-        patched_get_display_name.assert_called_once()
-        patched_get_manipulators.assert_called_once()
-        patched_run_until_complete.assert_called_once()
-        patched_get_event_loop.assert_called_once()
-        spied_info_print.assert_any_call("PLATFORM", platform_handler.get_display_name())
-        spied_info_print.assert_any_call("MANIPULATORS", str(DUMMY_STRING_LIST))
-        spied_info_print.assert_any_call("PINPOINT ID", mocker.ANY)  # pyright: ignore[reportAny]
-        assert init_error.value.args[0] == PROXY_CLIENT_NOT_INITIALIZED_ERROR
-        patched_connect.assert_not_awaited()  # pyright: ignore[reportUnusedCallResult]
-        patched_wait.assert_not_awaited()  # pyright: ignore[reportUnusedCallResult]
-
     @pytest.mark.asyncio
     async def test_connect_success(self, server: Server, console: Console, mocker: MockerFixture) -> None:
         """Server should allow connection if there is no existing connection."""
@@ -283,28 +165,6 @@ class TestServer:
         spied_info_print.assert_called_once_with("EVENT", event_name)
         assert result == __version__
 
-    @pytest.mark.asyncio
-    async def test_platform_event_handler_get_pinpoint_id(
-        self, server: Server, console: Console, mocker: MockerFixture
-    ) -> None:
-        """Server should return pinpoint ID."""
-        # Spy console.
-        spied_info_print = mocker.spy(console, "debug_print")
-
-        # Mock Pinpoint ID.
-        dummy_id = DUMMY_STRING[:8]
-        _ = mocker.patch.object(server, "_pinpoint_id", new=dummy_id)
-
-        # Act.
-        event_name = "get_pinpoint_id"
-        result = await server.platform_event_handler(event_name, DUMMY_STRING, None)
-        parsed_result = PinpointIdResponse(**loads(result))  # pyright: ignore[reportAny]
-
-        # Assert.
-        spied_info_print.assert_called_once_with("EVENT", event_name)
-        assert parsed_result.pinpoint_id == dummy_id
-        assert not parsed_result.is_requester
-
     @pytest.mark.asyncio
     async def test_platform_event_handler_get_platform_info(
         self, platform_handler: PlatformHandler, server: Server, console: Console, mocker: MockerFixture

{ephys_link-2.1.3 → ephys_link-2.2.0}/tests/utils/test_startup.py

@@ -3,7 +3,8 @@ from io import StringIO
 
 import pytest
 from pytest_mock import MockerFixture
-from requests import ConnectionError, ConnectTimeout
+from requests import ConnectionError as RequestsConnectionError
+from requests import ConnectTimeout as RequestsConnectTimeout
 from vbl_aquarium.models.ephys_link import EphysLinkOptions
 
 from ephys_link.__about__ import __version__
@@ -76,9 +77,9 @@ class TestStartup:
         # Assert: critical_print should be called since an update is available.
         spied_critical_print.assert_called()
 
-    @pytest.mark.parametrize("exception", [ConnectionError, ConnectTimeout])
+    @pytest.mark.parametrize("exception", [RequestsConnectionError, RequestsConnectTimeout])
     def test_check_for_updates_connection_errors(
-        self, exception: ConnectionError | ConnectTimeout, console: Console, mocker: MockerFixture
+        self, exception: RequestsConnectionError | RequestsConnectTimeout, console: Console, mocker: MockerFixture
     ) -> None:
         """Test the check_for_updates function with connection-related errors."""
         # Add mocks and spies.

ephys_link-2.1.3/src/ephys_link/__about__.py

@@ -1 +0,0 @@
-__version__ = "2.1.3"