ephys-link 1.3.3__tar.gz → 2.0.0b1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ephys-link
-Version: 1.3.3
+Version: 2.0.0b1
 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
@@ -27,12 +27,14 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: <3.13,>=3.10
 Requires-Dist: aiohttp==3.9.5
+Requires-Dist: colorama==0.4.6
 Requires-Dist: platformdirs==4.2.2
 Requires-Dist: pyserial==3.5
-Requires-Dist: python-socketio[asyncio-client]==5.11.2
+Requires-Dist: python-socketio[asyncio-client]==5.11.3
 Requires-Dist: pythonnet==3.0.3
-Requires-Dist: sensapex==1.400.0
-Requires-Dist: vbl-aquarium==0.0.15
+Requires-Dist: requests==2.32.3
+Requires-Dist: sensapex==1.400.1
+Requires-Dist: vbl-aquarium==0.0.19
 Description-Content-Type: text/markdown
 
 # Electrophysiology Manipulator Link

{ephys_link-1.3.3 → ephys_link-2.0.0b1}/ephys_link.spec

@@ -10,6 +10,7 @@ options = parser.parse_args()
 
 FILE_NAME = f"EphysLink-v{version}"
 
+# noinspection PyUnresolvedReferences
 a = Analysis(
     ['src\\ephys_link\\__main__.py'],
     pathex=[],
@@ -23,9 +24,11 @@ a = Analysis(
     noarchive=False,
     optimize=1,
 )
+# noinspection PyUnresolvedReferences
 pyz = PYZ(a.pure)
 
 if options.dir:
+    # noinspection PyUnresolvedReferences
     exe = EXE(
         pyz,
         a.scripts,
@@ -45,8 +48,10 @@ if options.dir:
         entitlements_file=None,
         icon='assets\\icon.ico',
     )
+    # noinspection PyUnresolvedReferences
     coll = COLLECT(exe, a.binaries, a.datas, strip=False, upx=True, upx_exclude=[], name=FILE_NAME)
 else:
+    # noinspection PyUnresolvedReferences
     exe = EXE(
         pyz,
         a.scripts,

{ephys_link-1.3.3 → ephys_link-2.0.0b1}/pyproject.toml

@@ -31,12 +31,14 @@ classifiers = [
 ]
 dependencies = [
     "aiohttp==3.9.5",
+    "colorama==0.4.6",
     "platformdirs==4.2.2",
     "pyserial==3.5",
-    "python-socketio[asyncio_client]==5.11.2",
+    "python-socketio[asyncio_client]==5.11.3",
     "pythonnet==3.0.3",
-    "sensapex==1.400.0",
-    "vbl-aquarium==0.0.15"
+    "requests==2.32.3",
+    "sensapex==1.400.1",
+    "vbl-aquarium==0.0.19"
 ]
 
 [project.urls]
@@ -59,7 +61,6 @@ exclude = ["/.github", "/.idea"]
 python = "3.12"
 dependencies = [
     "coverage[toml]>=6.5",
-    "mypy>=1.0.0",
     "pytest",
 ]
 [tool.hatch.envs.default.scripts]
@@ -73,7 +74,6 @@ cov = [
     "test-cov",
     "cov-report",
 ]
-types = "mypy --strict --install-types --non-interactive {args:src/ephys_link tests}"
 
 #[[tool.hatch.envs.all.matrix]]
 #python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
@@ -88,6 +88,15 @@ build = "pyinstaller.exe ephys_link.spec -y -- -d && pyinstaller.exe ephys_link.
 build_onefile = "pyinstaller.exe ephys_link.spec -y"
 build_clean = "pyinstaller.exe ephys_link.spec -y --clean"
 
+[tool.hatch.envs.types]
+python = "3.12"
+skip-install = true
+dependencies = [
+    "mypy",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --strict --install-types --non-interactive --ignore-missing-imports {args:src/ephys_link tests}"
+
 [tool.coverage.run]
 source_pkgs = ["ephys_link", "tests"]
 branch = true
@@ -105,7 +114,4 @@ exclude_lines = [
     "no cov",
     "if __name__ == .__main__.:",
     "if TYPE_CHECKING:",
-]
-
-[tool.ruff.lint]
-extend-ignore = ["T201", "PLW0603", "BLE001", "FBT001", "ARG002", "S310"]
+]

ephys_link-2.0.0b1/scripts/move_tester.py

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

ephys_link-2.0.0b1/scripts/server_tester.py

@@ -0,0 +1,23 @@
+from time import sleep
+
+from socketio import SimpleClient
+from vbl_aquarium.models.ephys_link import SetDepthRequest, SetInsideBrainRequest
+from vbl_aquarium.models.unity import Vector4
+
+with SimpleClient() as sio:
+    sio.connect("http://localhost:3000")
+
+    print(sio.call("set_inside_brain", SetInsideBrainRequest(manipulator_id="6", inside=True).to_json_string()))
+
+    target = Vector4()
+    # target = Vector4(x=10, y=10, z=10, w=10)
+
+    sio.emit(
+        "set_depth",
+        SetDepthRequest(manipulator_id="6", depth=10, speed=3).to_json_string(),
+    )
+    sleep(1)
+    print(sio.call("stop"))
+    # while True:
+    #     print(sio.call("get_position", "6"))
+    sio.disconnect()

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

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

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

@@ -0,0 +1,43 @@
+"""Ephys Link entry point.
+
+Responsible for gathering launch options, instantiating the appropriate interface, and starting the application.
+
+Usage: call main() to start.
+"""
+
+from sys import argv
+
+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.gui import GUI
+from ephys_link.util.console import Console
+
+
+def main() -> None:
+    """Ephys Link entry point.
+
+    1. Get options via CLI or GUI.
+    2. Instantiate the Console and make it globally accessible.
+    3. Instantiate the Platform Handler with the appropriate platform bindings.
+    4. Instantiate the Emergency Stop service.
+    5. Start the server.
+    """
+
+    # 1. Get options via CLI or GUI (if no CLI options are provided).
+    options = CLI().parse_args() if len(argv) > 1 else GUI().get_options()
+
+    # 2. Instantiate the Console and make it globally accessible.
+    console = Console(enable_debug=options.debug)
+
+    # 3. Instantiate the Platform Handler with the appropriate platform bindings.
+    platform_handler = PlatformHandler(options.type, console)
+
+    # 4. Instantiate the Emergency Stop service.
+
+    # 5. Start the server.
+    Server(options, platform_handler, console).launch()
+
+
+if __name__ == "__main__":
+    main()

ephys_link-2.0.0b1/src/ephys_link/back_end/platform_handler.py

@@ -0,0 +1,298 @@
+# ruff: noqa: BLE001
+"""Manipulator platform handler.
+
+Responsible for performing the various manipulator commands.
+Instantiates the appropriate bindings based on the platform type and uses them to perform the commands.
+
+Usage: Instantiate PlatformHandler with the platform type and call the desired command.
+"""
+
+from uuid import uuid4
+
+from vbl_aquarium.models.ephys_link import (
+    AngularResponse,
+    BooleanStateResponse,
+    GetManipulatorsResponse,
+    PositionalResponse,
+    SetDepthRequest,
+    SetDepthResponse,
+    SetInsideBrainRequest,
+    SetPositionRequest,
+    ShankCountResponse,
+)
+from vbl_aquarium.models.proxy import PinpointIdResponse
+from vbl_aquarium.models.unity import Vector4
+
+from ephys_link.__about__ import __version__
+from ephys_link.bindings.fake_bindings import FakeBindings
+from ephys_link.bindings.ump_4_bindings import Ump4Bindings
+from ephys_link.util.base_bindings import BaseBindings
+from ephys_link.util.common import vector4_to_array
+from ephys_link.util.console import Console
+
+
+class PlatformHandler:
+    """Handler for platform commands."""
+
+    def __init__(self, platform_type: str, console: Console) -> None:
+        """Initialize platform handler.
+
+        :param platform_type: Platform type to initialize bindings from.
+        :type platform_type: str
+        """
+
+        # Store the platform type.
+        self._platform_type = platform_type
+
+        # Store the console.
+        self._console = console
+
+        # Define bindings based on platform type.
+        self._bindings = self._match_platform_type(platform_type)
+
+        # 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 _match_platform_type(self, platform_type: str) -> BaseBindings:
+        """Match the platform type to the appropriate bindings.
+
+        :param platform_type: Platform type.
+        :type platform_type: str
+        :returns: Bindings for the specified platform type.
+        :rtype: :class:`ephys_link.util.base_bindings.BaseBindings`
+        """
+        match platform_type:
+            case "ump-4":
+                return Ump4Bindings()
+            case "fake":
+                return FakeBindings()
+            case _:
+                error_message = f'Platform type "{platform_type}" not recognized.'
+                self._console.labeled_error_print("PLATFORM", error_message)
+                raise ValueError(error_message)
+
+    # Ephys Link metadata.
+
+    @staticmethod
+    def get_version() -> str:
+        """Get Ephys Link's version.
+
+        :returns: Ephys Link's version.
+        :rtype: str
+        """
+        return __version__
+
+    def get_pinpoint_id(self) -> PinpointIdResponse:
+        """Get the Pinpoint ID for proxy usage.
+
+        :returns: Pinpoint ID response.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.PinpointIDResponse`
+        """
+        return PinpointIdResponse(pinpoint_id=self._pinpoint_id, is_requester=False)
+
+    def get_platform_type(self) -> str:
+        """Get the manipulator platform type connected to Ephys Link.
+
+        :returns: Platform type config identifier (see CLI options for examples).
+        :rtype: str
+        """
+        return self._platform_type
+
+    # Manipulator commands.
+
+    async def get_manipulators(self) -> GetManipulatorsResponse:
+        """Get a list of available manipulators on the current handler.
+
+        :returns: List of manipulator IDs, number of axes, dimensions of manipulators (mm), and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.GetManipulatorsResponse`
+        """
+        try:
+            manipulators = await self._bindings.get_manipulators()
+            num_axes = await self._bindings.get_num_axes()
+            dimensions = self._bindings.get_dimensions()
+        except Exception as e:
+            self._console.exception_error_print("Get Manipulators", e)
+            return GetManipulatorsResponse(error=self._console.pretty_exception(e))
+        else:
+            return GetManipulatorsResponse(
+                manipulators=manipulators,
+                num_axes=num_axes,
+                dimensions=dimensions,
+            )
+
+    async def get_position(self, manipulator_id: str) -> PositionalResponse:
+        """Get the current translation position of a manipulator in unified coordinates (mm).
+
+        :param manipulator_id: Manipulator ID.
+        :type manipulator_id: str
+        :returns: Current position of the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.PositionalResponse`
+        """
+        try:
+            unified_position = self._bindings.platform_space_to_unified_space(
+                await self._bindings.get_position(manipulator_id)
+            )
+        except Exception as e:
+            self._console.exception_error_print("Get Position", e)
+            return PositionalResponse(error=str(e))
+        else:
+            return PositionalResponse(position=unified_position)
+
+    async def get_angles(self, manipulator_id: str) -> AngularResponse:
+        """Get the current rotation angles of a manipulator in Yaw, Pitch, Roll (degrees).
+
+        :param manipulator_id: Manipulator ID.
+        :type manipulator_id: str
+        :returns: Current angles of the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.AngularResponse`
+        """
+        try:
+            angles = await self._bindings.get_angles(manipulator_id)
+        except Exception as e:
+            self._console.exception_error_print("Get Angles", e)
+            return AngularResponse(error=self._console.pretty_exception(e))
+        else:
+            return AngularResponse(angles=angles)
+
+    async def get_shank_count(self, manipulator_id: str) -> ShankCountResponse:
+        """Get the number of shanks on a manipulator.
+
+        :param manipulator_id: Manipulator ID.
+        :type manipulator_id: str
+        :returns: Number of shanks on the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.ShankCountResponse`
+        """
+        try:
+            shank_count = await self._bindings.get_shank_count(manipulator_id)
+        except Exception as e:
+            self._console.exception_error_print("Get Shank Count", e)
+            return ShankCountResponse(error=self._console.pretty_exception(e))
+        else:
+            return ShankCountResponse(shank_count=shank_count)
+
+    async def set_position(self, request: SetPositionRequest) -> PositionalResponse:
+        """Move a manipulator to a specified translation position in unified coordinates (mm).
+
+        :param request: Request to move a manipulator to a specified position.
+        :type request: :class:`vbl_aquarium.models.ephys_link.GotoPositionRequest`
+        :returns: Final position of the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.Position`
+        """
+        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(error_message)
+                return PositionalResponse(error=error_message)
+
+            # Move to the new position.
+            final_platform_position = await self._bindings.set_position(
+                manipulator_id=request.manipulator_id,
+                position=self._bindings.unified_space_to_platform_space(request.position),
+                speed=request.speed,
+            )
+            final_unified_position = self._bindings.platform_space_to_unified_space(final_platform_position)
+
+            # Return error if movement did not reach target within tolerance.
+            for index, axis in enumerate(vector4_to_array(final_unified_position - request.position)):
+                # End once index is greater than the number of axes.
+                if index >= await self._bindings.get_num_axes():
+                    break
+
+                # Check if the axis is within the movement tolerance.
+                if abs(axis) > await 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}."
+                    )
+                    self._console.error_print(error_message)
+                    return PositionalResponse(error=error_message)
+        except Exception as e:
+            self._console.exception_error_print("Set Position", e)
+            return PositionalResponse(error=self._console.pretty_exception(e))
+        else:
+            return PositionalResponse(position=final_unified_position)
+
+    async def set_depth(self, request: SetDepthRequest) -> SetDepthResponse:
+        """Move a manipulator's depth translation stage to a specific value (mm).
+
+        :param request: Request to move a manipulator to a specified depth.
+        :type request: :class:`vbl_aquarium.models.ephys_link.DriveToDepthRequest`
+        :returns: Final depth of the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.DriveToDepthResponse`
+        """
+        try:
+            # Create a position based on the new depth.
+            current_platform_position = await self._bindings.get_position(request.manipulator_id)
+            current_unified_position = self._bindings.platform_space_to_unified_space(current_platform_position)
+            target_unified_position = current_unified_position.model_copy(update={"w": request.depth})
+            target_platform_position = self._bindings.unified_space_to_platform_space(target_unified_position)
+
+            # Move to the new depth.
+            final_platform_position = await self._bindings.set_position(
+                manipulator_id=request.manipulator_id,
+                position=target_platform_position,
+                speed=request.speed,
+            )
+            final_unified_position = self._bindings.platform_space_to_unified_space(final_platform_position)
+        except Exception as e:
+            self._console.exception_error_print("Set Depth", e)
+            return SetDepthResponse(error=self._console.pretty_exception(e))
+        else:
+            return SetDepthResponse(depth=final_unified_position.w)
+
+    async def set_inside_brain(self, request: SetInsideBrainRequest) -> BooleanStateResponse:
+        """Mark a manipulator as inside the brain or not.
+
+        This should restrict the manipulator's movement to just the depth axis.
+
+        :param request: Request to set a manipulator's inside brain state.
+        :type request: :class:`vbl_aquarium.models.ephys_link.InsideBrainRequest`
+        :returns: Inside brain state of the manipulator and an error message if any.
+        :rtype: :class:`vbl_aquarium.models.ephys_link.BooleanStateResponse`
+        """
+        try:
+            if request.inside:
+                self._inside_brain.add(request.manipulator_id)
+            else:
+                self._inside_brain.discard(request.manipulator_id)
+        except Exception as e:
+            self._console.exception_error_print("Set Inside Brain", e)
+            return BooleanStateResponse(error=self._console.pretty_exception(e))
+        else:
+            return BooleanStateResponse(state=request.inside)
+
+    async def stop(self, manipulator_id: str) -> str:
+        """Stop a manipulator.
+
+        :param manipulator_id: Manipulator ID.
+        :type manipulator_id: str
+        :returns: Error message if any.
+        :rtype: str
+        """
+        try:
+            await self._bindings.stop(manipulator_id)
+        except Exception as e:
+            self._console.exception_error_print("Stop", e)
+            return self._console.pretty_exception(e)
+        else:
+            return ""
+
+    async def stop_all(self) -> str:
+        """Stop all manipulators.
+
+        :returns: Error message if any.
+        :rtype: str
+        """
+        try:
+            for manipulator_id in await self._bindings.get_manipulators():
+                await self._bindings.stop(manipulator_id)
+        except Exception as e:
+            self._console.exception_error_print("Stop", e)
+            return self._console.pretty_exception(e)
+        else:
+            return ""