ephys-link 2.0.2__tar.gz → 2.1.0__tar.gz

{ephys_link-2.0.2 → ephys_link-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ephys-link
-Version: 2.0.2
+Version: 2.1.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
@@ -22,16 +22,16 @@ 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.11.16
+Requires-Dist: aiohttp==3.12.13
 Requires-Dist: colorama==0.4.6
 Requires-Dist: keyboard==0.13.5
-Requires-Dist: packaging==24.2
-Requires-Dist: platformdirs==4.3.7
+Requires-Dist: packaging==25.0
+Requires-Dist: platformdirs==4.3.8
 Requires-Dist: pyserial==3.5
-Requires-Dist: python-socketio[asyncio-client]==5.12.1
-Requires-Dist: requests==2.32.3
+Requires-Dist: python-socketio[asyncio-client]==5.13.0
+Requires-Dist: requests==2.32.4
 Requires-Dist: rich==14.0.0
-Requires-Dist: sensapex==1.400.3
+Requires-Dist: sensapex==1.400.4
 Requires-Dist: vbl-aquarium==1.0.0
 Description-Content-Type: text/markdown
 
@@ -43,6 +43,7 @@ Description-Content-Type: text/markdown
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
 [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
+[![Test](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/test.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/test.yml)
 
 <!-- [![Build](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml) -->
 

{ephys_link-2.0.2 → ephys_link-2.1.0}/README.md

@@ -6,6 +6,7 @@
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
 [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)
+[![Test](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/test.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/test.yml)
 
 <!-- [![Build](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml) -->
 

{ephys_link-2.0.2 → ephys_link-2.1.0}/pyproject.toml

@@ -26,15 +26,15 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Medical Science Apps.",
 ]
 dependencies = [
-    "aiohttp==3.11.16",
+    "aiohttp==3.12.13",
     "colorama==0.4.6",
     "keyboard==0.13.5",
-    "packaging==24.2",
-    "platformdirs==4.3.7",
+    "packaging==25.0",
+    "platformdirs==4.3.8",
     "pyserial==3.5",
-    "python-socketio[asyncio_client]==5.12.1",
-    "requests==2.32.3",
-    "sensapex==1.400.3",
+    "python-socketio[asyncio_client]==5.13.0",
+    "requests==2.32.4",
+    "sensapex==1.400.4",
     "rich==14.0.0",
     "vbl-aquarium==1.0.0"
 ]
@@ -59,14 +59,20 @@ exclude = ["/.github", "/.idea", "/docs"]
 installer = "uv"
 python = "3.13"
 dependencies = [
-    "pyinstaller==6.12.0",
-    "basedpyright==1.28.5",
+    "pyinstaller==6.13.0",
+    "basedpyright==1.29.1",
+    "pytest==8.3.5",
+    "pytest-cov==6.1.1",
+    "pytest-mock==3.14.0",
+    "pytest-asyncio==0.26.0"
 ]
 [tool.hatch.envs.default.scripts]
 exe = "pyinstaller.exe ephys_link.spec -y -- -d && pyinstaller.exe ephys_link.spec -y"
 exe-clean = "pyinstaller.exe ephys_link.spec -y --clean"
 check = "basedpyright"
 check-watched = "basedpyright --watch"
+tests = "pytest"
+cov = "pytest --cov=ephys_link --cov-report=html --cov-report=term-missing"
 
 [tool.hatch.envs.docs]
 installer = "uv"
@@ -88,5 +94,16 @@ exclude = ["typings"]
 unsafe-fixes = true
 
 [tool.basedpyright]
-include = ["src/ephys_link"]
-strict = ["src/ephys_link"]
+include = ["src/ephys_link", "tests"]
+strict = ["src/ephys_link", "tests"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.coverage.run]
+source_pkgs = ["ephys_link"]
+branch = true
+omit = [
+    "tests/*",
+    "scripts/*",
+]

{ephys_link-2.0.2 → ephys_link-2.1.0}/scripts/move_tester.py

@@ -1,13 +1,14 @@
 from asyncio import run
 
-from vbl_aquarium.models.ephys_link import EphysLinkOptions, SetDepthRequest
+from vbl_aquarium.models.ephys_link import SetDepthRequest
 from vbl_aquarium.models.unity import Vector4
 
 from ephys_link.back_end.platform_handler import PlatformHandler
-from ephys_link.utils.console import Console
+from ephys_link.bindings.mpm_binding import MPMBinding
+from ephys_link.front_end.console import Console
 
 c = Console(enable_debug=True)
-p = PlatformHandler(EphysLinkOptions(type="pathfinder-mpm"), c)
+p = PlatformHandler(MPMBinding(), c)
 # target = Vector4()
 target = Vector4(x=7.5, y=7.5, z=7.5, w=7.5)
 

ephys_link-2.1.0/src/ephys_link/__about__.py

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

{ephys_link-2.0.2 → ephys_link-2.1.0}/src/ephys_link/__main__.py

@@ -16,9 +16,9 @@ from keyboard import add_hotkey
 from ephys_link.back_end.platform_handler import PlatformHandler
 from ephys_link.back_end.server import Server
 from ephys_link.front_end.cli import CLI
+from ephys_link.front_end.console import Console
 from ephys_link.front_end.gui import GUI
-from ephys_link.utils.console import Console
-from ephys_link.utils.startup import check_for_updates, preamble
+from ephys_link.utils.startup import check_for_updates, get_binding_instance, preamble
 
 
 def main() -> None:
@@ -37,13 +37,16 @@ def main() -> None:
     if not options.ignore_updates:
         check_for_updates(console)
 
-    # 4. Instantiate the Platform Handler with the appropriate platform bindings.
-    platform_handler = PlatformHandler(options, console)
+    # 4. Instantiate the requested platform binding.
+    binding = get_binding_instance(options, console)
 
-    # 5. Add hotkeys for emergency stop.
+    # 5. Instantiate the Platform Handler with the appropriate platform bindings.
+    platform_handler = PlatformHandler(binding, console)
+
+    # 6. Add hotkeys for emergency stop.
     _ = add_hotkey("ctrl+alt+shift+q", lambda: run(platform_handler.emergency_stop()))
 
-    # 6. Start the server.
+    # 7. Start the server.
     Server(options, platform_handler, console).launch()
 
 

{ephys_link-2.0.2 → ephys_link-2.1.0}/src/ephys_link/back_end/platform_handler.py

@@ -8,12 +8,10 @@ Usage:
 """
 
 from typing import final
-from uuid import uuid4
 
 from vbl_aquarium.models.ephys_link import (
     AngularResponse,
     BooleanStateResponse,
-    EphysLinkOptions,
     GetManipulatorsResponse,
     PlatformInfo,
     PositionalResponse,
@@ -23,69 +21,38 @@ from vbl_aquarium.models.ephys_link import (
     SetPositionRequest,
     ShankCountResponse,
 )
-from vbl_aquarium.models.unity import Vector4
 
-from ephys_link.bindings.mpm_binding import MPMBinding
+from ephys_link.front_end.console import Console
 from ephys_link.utils.base_binding import BaseBinding
-from ephys_link.utils.console import Console
+from ephys_link.utils.constants import (
+    EMERGENCY_STOP_MESSAGE,
+    NO_SET_POSITION_WHILE_INSIDE_BRAIN_ERROR,
+    did_not_reach_target_depth_error,
+    did_not_reach_target_position_error,
+)
 from ephys_link.utils.converters import vector4_to_array
-from ephys_link.utils.startup import get_bindings
 
 
 @final
 class PlatformHandler:
     """Handler for platform commands."""
 
-    def __init__(self, options: EphysLinkOptions, console: Console) -> None:
+    def __init__(self, binding: BaseBinding, console: Console) -> None:
         """Initialize platform handler.
 
         Args:
-            options: CLI options.
+            binding: Binding instance for the platform.
             console: Console instance.
         """
-        # Store the CLI options.
-        self._options = options
-
         # Store the console.
         self._console = console
 
         # Define bindings based on platform type.
-        self._bindings = self._get_binding_instance(options)
+        self._bindings = binding
 
         # Record which IDs are inside the brain.
         self._inside_brain: set[str] = set()
 
-        # Generate a Pinpoint ID for proxy usage.
-        self._pinpoint_id = str(uuid4())[:8]
-
-    def _get_binding_instance(self, options: EphysLinkOptions) -> BaseBinding:
-        """Match the platform type to the appropriate bindings.
-
-        Args:
-            options: CLI options.
-
-        Raises:
-            ValueError: If the platform type is not recognized.
-
-        Returns:
-            Bindings for the specified platform type.
-        """
-        for binding_type in get_bindings():
-            binding_cli_name = binding_type.get_cli_name()
-
-            if binding_cli_name == options.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()
-
-        # Raise an error if the platform type is not recognized.
-        error_message = f'Platform type "{options.type}" not recognized.'
-        self._console.critical_print(error_message)
-        raise ValueError(error_message)
-
     # Platform metadata.
 
     def get_display_name(self) -> str:
@@ -140,7 +107,7 @@ class PlatformHandler:
             )
         except Exception as e:  # noqa: BLE001
             self._console.exception_error_print("Get Position", e)
-            return PositionalResponse(error=str(e))
+            return PositionalResponse(error=self._console.pretty_exception(e))
         else:
             return PositionalResponse(position=unified_position)
 
@@ -190,9 +157,8 @@ class PlatformHandler:
         try:
             # 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("Set Position", error_message)
-                return PositionalResponse(error=error_message)
+                self._console.error_print("Set Position", NO_SET_POSITION_WHILE_INSIDE_BRAIN_ERROR)
+                return PositionalResponse(error=NO_SET_POSITION_WHILE_INSIDE_BRAIN_ERROR)
 
             # Move to the new position.
             final_platform_position = await self._bindings.set_position(
@@ -210,11 +176,7 @@ class PlatformHandler:
 
                 # Check if the axis is within the 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}."
-                    )
+                    error_message = did_not_reach_target_position_error(request, index, final_unified_position)
                     self._console.error_print("Set Position", error_message)
                     return PositionalResponse(error=error_message)
         except Exception as e:  # noqa: BLE001
@@ -234,26 +196,22 @@ class PlatformHandler:
         """
         try:
             # Move to the new depth.
-            final_platform_depth = await self._bindings.set_depth(
+            final_depth = await self._bindings.set_depth(
                 manipulator_id=request.manipulator_id,
-                depth=self._bindings.unified_space_to_platform_space(Vector4(w=request.depth)).w,
+                depth=request.depth,
                 speed=request.speed,
             )
-            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}."
-                )
+            if abs(final_depth - request.depth) > self._bindings.get_movement_tolerance():
+                error_message = did_not_reach_target_depth_error(request, final_depth)
                 self._console.error_print("Set Depth", error_message)
                 return SetDepthResponse(error=error_message)
         except Exception as e:  # noqa: BLE001
             self._console.exception_error_print("Set Depth", e)
             return SetDepthResponse(error=self._console.pretty_exception(e))
         else:
-            return SetDepthResponse(depth=final_unified_depth)
+            return SetDepthResponse(depth=final_depth)
 
     async def set_inside_brain(self, request: SetInsideBrainRequest) -> BooleanStateResponse:
         """Mark a manipulator as inside the brain or not.
@@ -266,16 +224,11 @@ class PlatformHandler:
         Returns:
             Inside brain state of the manipulator and an error message if any.
         """
-        try:
-            if request.inside:
-                self._inside_brain.add(request.manipulator_id)
-            else:
-                self._inside_brain.discard(request.manipulator_id)
-        except Exception as e:  # noqa: BLE001
-            self._console.exception_error_print("Set Inside Brain", e)
-            return BooleanStateResponse(error=self._console.pretty_exception(e))
+        if request.inside:
+            self._inside_brain.add(request.manipulator_id)
         else:
-            return BooleanStateResponse(state=request.inside)
+            self._inside_brain.discard(request.manipulator_id)
+        return BooleanStateResponse(state=request.inside)
 
     async def stop(self, manipulator_id: str) -> str:
         """Stop a manipulator.
@@ -304,12 +257,12 @@ class PlatformHandler:
             for manipulator_id in await self._bindings.get_manipulators():
                 await self._bindings.stop(manipulator_id)
         except Exception as e:  # noqa: BLE001
-            self._console.exception_error_print("Stop", e)
+            self._console.exception_error_print("Stop All", e)
             return self._console.pretty_exception(e)
         else:
             return ""
 
     async def emergency_stop(self) -> None:
         """Stops all manipulators with a message."""
-        self._console.critical_print("Emergency Stopping All Manipulators...")
+        self._console.critical_print(EMERGENCY_STOP_MESSAGE)
         _ = await self.stop_all()

{ephys_link-2.0.2 → ephys_link-2.1.0}/src/ephys_link/back_end/server.py

@@ -32,8 +32,16 @@ from vbl_aquarium.utils.vbl_base_model import VBLBaseModel
 
 from ephys_link.__about__ import __version__
 from ephys_link.back_end.platform_handler import PlatformHandler
-from ephys_link.utils.console import Console
-from ephys_link.utils.constants import PORT
+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,
+)
 
 # Server message generic types.
 INPUT_TYPE = TypeVar("INPUT_TYPE", bound=VBLBaseModel)
@@ -61,9 +69,8 @@ class Server:
         if not self._options.use_proxy:
             # Exit if _sio is not a Server.
             if not isinstance(self._sio, AsyncServer):
-                error = "Server not initialized."
-                self._console.critical_print(error)
-                raise TypeError(error)
+                self._console.critical_print(SERVER_NOT_INITIALIZED_ERROR)
+                raise TypeError(SERVER_NOT_INITIALIZED_ERROR)
 
             self._app = Application()
             self._sio.attach(self._app)  # pyright: ignore [reportUnknownMemberType]
@@ -101,9 +108,8 @@ class Server:
             async def connect_proxy() -> None:
                 # Exit if _sio is not a proxy client.
                 if not isinstance(self._sio, AsyncClient):
-                    error = "Proxy client not initialized."
-                    self._console.critical_print(error)
-                    raise TypeError(error)
+                    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]
@@ -125,13 +131,13 @@ class Server:
             Response for a malformed request.
         """
         self._console.error_print("MALFORMED REQUEST", f"{request}: {data}")
-        return dumps({"error": "Malformed request."})
+        return dumps(MALFORMED_REQUEST_ERROR)
 
     async def _run_if_data_available(
         self,
         function: Callable[[str], Coroutine[Any, Any, VBLBaseModel]],  # pyright: ignore [reportExplicitAny]
         event: str,
-        data: tuple[tuple[Any], ...],  # pyright: ignore [reportExplicitAny]
+        data: Any,  # pyright: ignore [reportAny, reportExplicitAny]
     ) -> str:
         """Run a function if data is available.
 
@@ -143,17 +149,16 @@ class Server:
         Returns:
             Response data from function.
         """
-        request_data = data[1]
-        if request_data:
-            return str((await function(str(request_data))).to_json_string())
-        return self._malformed_request_response(event, request_data)
+        if data:
+            return str((await function(str(data))).to_json_string())  # pyright: ignore[reportAny]
+        return self._malformed_request_response(event, data)  # pyright: ignore[reportAny]
 
     async def _run_if_data_parses(
         self,
         function: Callable[[INPUT_TYPE], Coroutine[Any, Any, OUTPUT_TYPE]],  # pyright: ignore [reportExplicitAny]
         data_type: type[INPUT_TYPE],
         event: str,
-        data: tuple[tuple[Any], ...],  # pyright: ignore [reportExplicitAny]
+        data: Any,  # pyright: ignore [reportAny, reportExplicitAny]
     ) -> str:
         """Run a function if data parses.
 
@@ -166,18 +171,17 @@ class Server:
         Returns:
             Response data from function.
         """
-        request_data = data[1]
-        if request_data:
+        if data:
             try:
-                parsed_data = data_type(**loads(str(request_data)))
+                parsed_data = data_type(**loads(str(data)))  # pyright: ignore[reportAny]
             except JSONDecodeError:
-                return self._malformed_request_response(event, request_data)
+                return self._malformed_request_response(event, data)  # pyright: ignore[reportAny]
             except ValidationError as e:
                 self._console.exception_error_print(event, e)
-                return self._malformed_request_response(event, request_data)
+                return self._malformed_request_response(event, data)  # pyright: ignore[reportAny]
             else:
                 return str((await function(parsed_data)).to_json_string())
-        return self._malformed_request_response(event, request_data)
+        return self._malformed_request_response(event, data)  # pyright: ignore[reportAny]
 
     # Event Handlers.
 
@@ -199,7 +203,7 @@ class Server:
             return True
 
         self._console.error_print(
-            "CONNECTION REFUSED", f"Cannot connect {sid} as {self._client_sid} is already connected."
+            "CONNECTION REFUSED", cannot_connect_as_client_is_already_connected_error(sid, self._client_sid)
         )
         return False
 
@@ -209,22 +213,24 @@ class Server:
         Args:
             sid: Socket session ID.
         """
-        self._console.info_print("DISCONNECTED", sid)
+        self._console.info_print("DISCONNECTION REQUEST", sid)
 
         # Reset client SID if it matches.
         if self._client_sid == sid:
             self._client_sid = ""
+            self._console.info_print("DISCONNECTED", sid)
         else:
-            self._console.error_print("DISCONNECTION", f"Client {sid} disconnected without being connected.")
+            self._console.error_print("DISCONNECTION", client_disconnected_without_being_connected_error(sid))
 
-    async def platform_event_handler(self, event: str, *args: tuple[Any]) -> str:  # pyright: ignore [reportExplicitAny]
+    async def platform_event_handler(self, event: str, _: str, data: Any) -> str:  # pyright: ignore [reportAny, reportExplicitAny]
         """Handle events from the server.
 
         Matches incoming events based on the Socket.IO API.
 
         Args:
             event: Event name.
-            args: Event arguments.
+            _: Socket session ID (unused).
+            data: Event data.
 
         Returns:
             Response data.
@@ -247,28 +253,27 @@ class Server:
             case "get_manipulators":
                 return str((await self._platform_handler.get_manipulators()).to_json_string())
             case "get_position":
-                return await self._run_if_data_available(self._platform_handler.get_position, event, args)
+                return await self._run_if_data_available(self._platform_handler.get_position, event, data)
             case "get_angles":
-                return await self._run_if_data_available(self._platform_handler.get_angles, event, args)
+                return await self._run_if_data_available(self._platform_handler.get_angles, event, data)
             case "get_shank_count":
-                return await self._run_if_data_available(self._platform_handler.get_shank_count, event, args)
+                return await self._run_if_data_available(self._platform_handler.get_shank_count, event, data)
             case "set_position":
                 return await self._run_if_data_parses(
-                    self._platform_handler.set_position, SetPositionRequest, event, args
+                    self._platform_handler.set_position, SetPositionRequest, event, data
                 )
             case "set_depth":
-                return await self._run_if_data_parses(self._platform_handler.set_depth, SetDepthRequest, event, args)
+                return await self._run_if_data_parses(self._platform_handler.set_depth, SetDepthRequest, event, data)
             case "set_inside_brain":
                 return await self._run_if_data_parses(
-                    self._platform_handler.set_inside_brain, SetInsideBrainRequest, event, args
+                    self._platform_handler.set_inside_brain, SetInsideBrainRequest, event, data
                 )
             case "stop":
-                request_data = args[1]
-                if request_data:
-                    return await self._platform_handler.stop(str(request_data))
-                return self._malformed_request_response(event, request_data)
+                if data:
+                    return await self._platform_handler.stop(str(data))  # pyright: ignore[reportAny]
+                return self._malformed_request_response(event, data)  # pyright: ignore[reportAny]
             case "stop_all":
                 return await self._platform_handler.stop_all()
             case _:
                 self._console.error_print("EVENT", f"Unknown event: {event}.")
-                return dumps({"error": "Unknown event."})
+                return dumps(UNKNOWN_EVENT_ERROR)