ephys-link 1.2.8__py3-none-any.whl → 1.3.0__py3-none-any.whl

ephys_link/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.8"
+__version__ = "1.3.0"

ephys_link/common.py

@@ -6,8 +6,10 @@ callback parameters)
 
 from __future__ import annotations
 
-import json
-from typing import TypedDict
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from vbl_aquarium.models.unity import Vector4
 
 # Debugging flag
 DEBUG = False
@@ -36,191 +38,12 @@ def dprint(message: str) -> None:
         print(message)
 
 
-# Input data formats
-class GotoPositionInputDataFormat(TypedDict):
-    """Data format for positional requests.
-
-    :param manipulator_id: ID of the manipulator to move.
-    :type manipulator_id: str
-    :param pos: Position to move to in mm (X, Y, Z, W).
-    :type pos: list[float]
-    :param speed: Speed to move at in mm/s.
-    :type speed: float
-    """
-
-    manipulator_id: str
-    pos: list[float]
-    speed: float
-
-
-class InsideBrainInputDataFormat(TypedDict):
-    """Data format for setting inside brain state.
-
-    :param manipulator_id: ID of the manipulator to move.
-    :type manipulator_id: str
-    :param inside: Whether the manipulator is inside the brain.
-    :type inside: bool
-    """
-
-    manipulator_id: str
-    inside: bool
-
-
-class DriveToDepthInputDataFormat(TypedDict):
-    """Data format for depth driving requests.
-
-    :param manipulator_id: ID of the manipulator to move.
-    :type manipulator_id: str
-    :param depth: Depth to drive to in mm.
-    :type depth: float
-    :param speed: Speed to drive at in mm/s.
-    :type speed: float
-    """
-
-    manipulator_id: str
-    depth: float
-    speed: float
-
-
-class CanWriteInputDataFormat(TypedDict):
-    """Data format for setting can write state.
-
-    :param manipulator_id: ID of the manipulator to move.
-    :type manipulator_id: str
-    :param can_write: Whether the manipulator can write.
-    :type can_write: bool
-    :param hours: Number of hours the manipulator can write for.
-    :type hours: float
-    """
-
-    manipulator_id: str
-    can_write: bool
-    hours: float
-
-
-# Output data dictionaries
-class GetManipulatorsOutputData(dict):
-    """Output format for get manipulators request.
-
-    :param manipulators: List of manipulator IDs (as strings).
-    :type manipulators: list
-    :param num_axes: Number of axes this manipulator has.
-    :type num_axes: int
-    :param dimensions: Size of the movement space in mm (first 3 axes).
-    :type dimensions: list
-    :param error: Error message.
-    :type error: str
-
-    :example: Example generated dictionary
-        :code:`{"manipulators": ["1", "2"], "num_axes": 4, "dimensions": [20, 20, 20], "error": ""}`
-    """
-
-    def __init__(self, manipulators: list, num_axes: int, dimensions: list, error: str) -> None:
-        """Constructor"""
-        super().__init__(
-            manipulators=manipulators,
-            num_axes=num_axes,
-            dimensions=dimensions,
-            error=error,
-        )
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
-
-
-class PositionalOutputData(dict):
-    """Output format for positional requests.
-
-    :param position: Position in mm (as a list, empty on error) in X, Y, Z, W order.
-    :type position: list
-    :param error: Error message.
-    :type error: str
+def vector4_to_array(vector4: Vector4) -> list[float]:
+    """Convert a Vector4 to a list of floats.
 
-    :example: Example generated dictionary
-        :code:`{"position": [10.429, 12.332, 2.131, 12.312], "error": ""}`
+    :param vector4: Vector4 to convert.
+    :type vector4: :class:`vbl_aquarium.models.unity.Vector4`
+    :return: List of floats.
+    :rtype: list[float]
     """
-
-    def __init__(self, position: list, error: str) -> None:
-        """Constructor"""
-        super().__init__(position=position, error=error)
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
-
-
-class AngularOutputData(dict):
-    """Output format for manipulator angle requests.
-
-    :param angles: Angles in degrees (as a list, can be empty) in yaw, pitch, roll order.
-    :type angles: list
-    :param error: Error message.
-    :type error: str
-    """
-
-    def __init__(self, angles: list, error: str) -> None:
-        """Constructor"""
-        super().__init__(angles=angles, error=error)
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
-
-
-class ShankCountOutputData(dict):
-    """Output format for number of shanks.
-
-    :param shank_count: Number of shanks on the probe (-1 if error).
-    :type shank_count: int
-    :param error: Error message.
-    :type error: str
-    """
-
-    def __init__(self, shank_count: int, error: str) -> None:
-        """Constructor"""
-        super().__init__(shank_count=shank_count, error=error)
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
-
-
-class DriveToDepthOutputData(dict):
-    """Output format for depth driving.
-
-    :param depth: Depth in mm (0 on error).
-    :type depth: float
-    :param error: Error message.
-    :type error: str
-
-    :example: Example generated dictionary :code:`{"depth": 1.23, "error": ""}`
-    """
-
-    def __init__(self, depth: float, error: str) -> None:
-        """Create drive to depth output data dictionary"""
-        super().__init__(depth=depth, error=error)
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
-
-
-class StateOutputData(dict):
-    """Output format for boolean state requests.
-
-    :param state: State of the event.
-    :type state: bool
-    :param error: Error message.
-    :type error: str
-
-    :example: Example generated dictionary :code:`{"state": True, "error": ""}`
-    """
-
-    def __init__(self, state: bool, error: str) -> None:
-        """Create state output data dictionary"""
-        super().__init__(state=state, error=error)
-
-    def json(self) -> str:
-        """Return JSON string"""
-        return json.dumps(self)
+    return [vector4.x, vector4.y, vector4.z, vector4.w]

ephys_link/platform_handler.py

@@ -17,6 +17,20 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
+from vbl_aquarium.models.ephys_link import (
+    AngularResponse,
+    BooleanStateResponse,
+    CanWriteRequest,
+    DriveToDepthRequest,
+    DriveToDepthResponse,
+    GetManipulatorsResponse,
+    GotoPositionRequest,
+    InsideBrainRequest,
+    PositionalResponse,
+    ShankCountResponse,
+)
+from vbl_aquarium.models.unity import Vector4
+
 from ephys_link import common as com
 
 if TYPE_CHECKING:
@@ -30,14 +44,14 @@ class PlatformHandler(ABC):
         """Initialize the manipulator handler with a dictionary of manipulators."""
 
         # Registered manipulators are stored as a dictionary of IDs (string) to
-        # manipulator objects
+        # manipulator objects.
         self.manipulators = {}
         self.num_axes = 4
 
         # Platform axes dimensions in mm
-        self.dimensions = [20, 20, 20, 20]
+        self.dimensions = Vector4(x=20, y=20, z=20, w=20)
 
-    # Platform Handler Methods
+    # Platform Handler Methods.
 
     def reset(self) -> bool:
         """Reset handler.
@@ -65,21 +79,21 @@ class PlatformHandler(ABC):
         else:
             return True
 
-    def get_manipulators(self) -> com.GetManipulatorsOutputData:
+    def get_manipulators(self) -> GetManipulatorsResponse:
         """Get all registered manipulators.
 
         :return: Result of connected manipulators, platform information, and error message (if any).
-        :rtype: :class:`ephys_link.common.GetManipulatorsOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.GetManipulatorsResponse`
         """
-        error = "Error getting manipulators"
         try:
-            devices = self._get_manipulators()
-            error = ""
+            manipulators = self._get_manipulators()
         except Exception as e:
             print(f"[ERROR]\t\t Getting manipulators: {type(e)}: {e}\n")
-            return com.GetManipulatorsOutputData([], self.num_axes, self.dimensions, error)
+            return GetManipulatorsResponse(error="Error getting manipulators")
         else:
-            return com.GetManipulatorsOutputData(devices, self.num_axes, self.dimensions, error)
+            return GetManipulatorsResponse(
+                manipulators=manipulators, num_axes=self.num_axes, dimensions=self.dimensions
+            )
 
     def register_manipulator(self, manipulator_id: str) -> str:
         """Register a manipulator.
@@ -135,46 +149,46 @@ class PlatformHandler(ABC):
             com.dprint(f"[SUCCESS]\t Unregistered manipulator: {manipulator_id}\n")
             return ""
 
-    def get_pos(self, manipulator_id: str) -> com.PositionalOutputData:
+    def get_pos(self, manipulator_id: str) -> PositionalResponse:
         """Get the current position of a manipulator.
 
         :param manipulator_id: The ID of the manipulator to get the position of.
         :type manipulator_id: str
         :return: Positional information for the manipulator and error message (if any).
-        :rtype: :class:`ephys_link.common.PositionalOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.PositionalResponse`
         """
         try:
-            # Check calibration status
+            # Check calibration status.
             if (
                 hasattr(self.manipulators[manipulator_id], "get_calibrated")
                 and not self.manipulators[manipulator_id].get_calibrated()
             ):
                 print(f"[ERROR]\t\t Calibration not complete: {manipulator_id}\n")
-                return com.PositionalOutputData([], "Manipulator not calibrated")
+                return PositionalResponse(error="Manipulator not calibrated")
 
-            # Get position and convert to unified space
+            # Get position and convert to unified space.
             manipulator_pos = self._get_pos(manipulator_id)
 
-            # Shortcut return for Pathfinder
+            # Shortcut return for Pathfinder.
             if self.num_axes == -1:
                 return manipulator_pos
 
-            # Error check and convert position to unified space
-            if manipulator_pos["error"] != "":
-                return manipulator_pos
-            return com.PositionalOutputData(self._platform_space_to_unified_space(manipulator_pos["position"]), "")
+            # Convert position to unified space.
+            return manipulator_pos.model_copy(
+                update={"position": self._platform_space_to_unified_space(manipulator_pos.position)}
+            )
         except KeyError:
-            # Manipulator not found in registered manipulators
+            # Manipulator not found in registered manipulators.
             print(f"[ERROR]\t\t Manipulator not registered: {manipulator_id}")
-            return com.PositionalOutputData([], "Manipulator not registered")
+            return PositionalResponse(error="Manipulator not registered")
 
-    def get_angles(self, manipulator_id: str) -> com.AngularOutputData:
+    def get_angles(self, manipulator_id: str) -> AngularResponse:
         """Get the current position of a manipulator.
 
         :param manipulator_id: The ID of the manipulator to get the angles of.
         :type manipulator_id: str
         :return: Angular information for the manipulator and error message (if any).
-        :rtype: :class:`ephys_link.common.AngularOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.AngularResponse`
         """
         try:
             # Check calibration status
@@ -183,7 +197,7 @@ class PlatformHandler(ABC):
                 and not self.manipulators[manipulator_id].get_calibrated()
             ):
                 print(f"[ERROR]\t\t Calibration not complete: {manipulator_id}\n")
-                return com.AngularOutputData([], "Manipulator not calibrated")
+                return AngularResponse(error="Manipulator not calibrated")
 
             # Get position
             return self._get_angles(manipulator_id)
@@ -191,124 +205,109 @@ class PlatformHandler(ABC):
         except KeyError:
             # Manipulator not found in registered manipulators
             print(f"[ERROR]\t\t Manipulator not registered: {manipulator_id}")
-            return com.AngularOutputData([], "Manipulator not registered")
+            return AngularResponse(error="Manipulator not registered")
 
-    def get_shank_count(self, manipulator_id: str) -> com.ShankCountOutputData:
+    def get_shank_count(self, manipulator_id: str) -> ShankCountResponse:
         """Get the number of shanks on the probe
 
         :param manipulator_id: The ID of the manipulator to get the number of shanks of.
         :type manipulator_id: str
         :return: Number of shanks on the probe.
-        :rtype: :class:`ephys_link.common.ShankCountOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.ShankCountResponse`
         """
         return self._get_shank_count(manipulator_id)
 
-    async def goto_pos(self, manipulator_id: str, position: list[float], speed: float) -> com.PositionalOutputData:
+    async def goto_pos(self, request: GotoPositionRequest) -> PositionalResponse:
         """Move manipulator to position
 
-        :param manipulator_id: The ID of the manipulator to move
-        :type manipulator_id: str
-        :param position: The position to move to in (x, y, z, w) in mm
-        :type position: list[float]
-        :param speed: The speed to move at (in mm/s)
-        :type speed: float
+        :param request: The goto request parsed from the server.
+        :type request: :class:`vbl_aquarium.models.ephys_link.GotoPositionRequest`
         :return: Resulting position of the manipulator and error message (if any).
-        :rtype: :class:`ephys_link.common.PositionalOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.PositionalResponse`
         """
         try:
-            # Check calibration status
-            if not self.manipulators[manipulator_id].get_calibrated():
-                print(f"[ERROR]\t\t Calibration not complete: {manipulator_id}\n")
-                return com.PositionalOutputData([], "Manipulator not calibrated")
+            # Check calibration status.
+            if not self.manipulators[request.manipulator_id].get_calibrated():
+                print(f"[ERROR]\t\t Calibration not complete: {request.manipulator_id}\n")
+                return PositionalResponse(error="Manipulator not calibrated")
 
-            # Check write state
-            if not self.manipulators[manipulator_id].get_can_write():
-                print(f"[ERROR]\t\t Cannot write to manipulator: {manipulator_id}")
-                return com.PositionalOutputData([], "Cannot write to manipulator")
+            # Check write state.
+            if not self.manipulators[request.manipulator_id].get_can_write():
+                print(f"[ERROR]\t\t Cannot write to manipulator: {request.manipulator_id}")
+                return PositionalResponse(error="Cannot write to manipulator")
 
             # Convert position to platform space, move, and convert final position back to
-            # unified space
-            end_position = await self._goto_pos(manipulator_id, self._unified_space_to_platform_space(position), speed)
-            if end_position["error"] != "":
-                return end_position
-            return com.PositionalOutputData(self._platform_space_to_unified_space(end_position["position"]), "")
-
+            # unified space.
+            end_position = await self._goto_pos(
+                request.model_copy(update={"position": self._unified_space_to_platform_space(request.position)})
+            )
+            return end_position.model_copy(
+                update={"position": self._platform_space_to_unified_space(end_position.position)}
+            )
         except KeyError:
-            # Manipulator not found in registered manipulators
-            print(f"[ERROR]\t\t Manipulator not registered: {manipulator_id}\n")
-            return com.PositionalOutputData([], "Manipulator not registered")
+            # Manipulator not found in registered manipulators.
+            print(f"[ERROR]\t\t Manipulator not registered: {request.manipulator_id}\n")
+            return PositionalResponse(error="Manipulator not registered")
 
-    async def drive_to_depth(self, manipulator_id: str, depth: float, speed: float) -> com.DriveToDepthOutputData:
+    async def drive_to_depth(self, request: DriveToDepthRequest) -> DriveToDepthResponse:
         """Drive manipulator to depth
 
-        :param manipulator_id: The ID of the manipulator to drive
-        :type manipulator_id: str
-        :param depth: The depth to drive to in mm
-        :type depth: float
-        :param speed: The speed to drive at (in mm/s)
-        :type speed: float
+        :param request: The drive to depth request parsed from the server.
+        :type request: :class:`vbl_aquarium.models.ephys_link.DriveToDepthRequest`
         :return: Resulting depth of the manipulator and error message (if any).
         :rtype: :class:`ephys_link.common.DriveToDepthOutputData`
         """
         try:
             # Check calibration status
-            if not self.manipulators[manipulator_id].get_calibrated():
-                print(f"[ERROR]\t\t Calibration not complete: {manipulator_id}\n")
-                return com.DriveToDepthOutputData(0, "Manipulator not calibrated")
+            if not self.manipulators[request.manipulator_id].get_calibrated():
+                print(f"[ERROR]\t\t Calibration not complete: {request.manipulator_id}\n")
+                return DriveToDepthResponse(error="Manipulator not calibrated")
 
             # Check write state
-            if not self.manipulators[manipulator_id].get_can_write():
-                print(f"[ERROR]\t\t Cannot write to manipulator: {manipulator_id}")
-                return com.DriveToDepthOutputData(0, "Cannot write to manipulator")
+            if not self.manipulators[request.manipulator_id].get_can_write():
+                print(f"[ERROR]\t\t Cannot write to manipulator: {request.manipulator_id}")
+                return DriveToDepthResponse(error="Cannot write to manipulator")
 
             end_depth = await self._drive_to_depth(
-                manipulator_id,
-                self._unified_space_to_platform_space([0, 0, 0, depth])[3],
-                speed,
+                request.model_copy(update={"depth": self._unified_space_to_platform_space(Vector4(w=request.depth)).w})
             )
-            if end_depth["error"] != "":
-                return end_depth
-            return com.DriveToDepthOutputData(
-                self._platform_space_to_unified_space([0, 0, 0, end_depth["depth"]])[3],
-                "",
+            return end_depth.model_copy(
+                update={"depth": self._platform_space_to_unified_space(Vector4(w=end_depth.depth)).w}
             )
-
         except KeyError:
             # Manipulator not found in registered manipulators
-            print(f"[ERROR]\t\t Manipulator not registered: {manipulator_id}\n")
-            return com.DriveToDepthOutputData(0, "Manipulator " "not registered")
+            print(f"[ERROR]\t\t Manipulator not registered: {request.manipulator_id}\n")
+            return DriveToDepthResponse(error="Manipulator not registered")
 
-    def set_inside_brain(self, manipulator_id: str, inside: bool) -> com.StateOutputData:
+    def set_inside_brain(self, request: InsideBrainRequest) -> BooleanStateResponse:
         """Set manipulator inside brain state (restricts motion)
 
-        :param manipulator_id: The ID of the manipulator to set the state of
-        :type manipulator_id: str
-        :param inside: True if inside brain, False if outside
-        :type inside: bool
+        :param request: The inside brain request parsed from the server.
+        :type request: :class:`vbl_aquarium.models.ephys_link.InsideBrainRequest`
         :return: New inside brain state of the manipulator and error message (if any).
-        :rtype: :class:`ephys_link.common.StateOutputData`
+        :rtype: :class:`vbl_aquarium.models.ephys_link.BooleanStateResponse`
         """
         try:
             # Check calibration status
             if (
-                hasattr(self.manipulators[manipulator_id], "get_calibrated")
-                and not self.manipulators[manipulator_id].get_calibrated()
+                hasattr(self.manipulators[request.manipulator_id], "get_calibrated")
+                and not self.manipulators[request.manipulator_id].get_calibrated()
             ):
                 print("[ERROR]\t\t Calibration not complete\n")
-                return com.StateOutputData(False, "Manipulator not calibrated")
+                return BooleanStateResponse(error="Manipulator not calibrated")
 
-            return self._set_inside_brain(manipulator_id, inside)
+            return self._set_inside_brain(request)
 
         except KeyError:
             # Manipulator not found in registered manipulators
-            print(f"[ERROR]\t\t Manipulator {manipulator_id} not registered\n")
-            return com.StateOutputData(False, "Manipulator not " "registered")
+            print(f"[ERROR]\t\t Manipulator {request.manipulator_id} not registered\n")
+            return BooleanStateResponse(error="Manipulator not " "registered")
 
         except Exception as e:
             # Other error
-            print(f"[ERROR]\t\t Set manipulator {manipulator_id} inside brain " f"state")
+            print(f"[ERROR]\t\t Set manipulator {request.manipulator_id} inside brain " f"state")
             print(f"{e}\n")
-            return com.StateOutputData(False, "Error setting " "inside brain")
+            return BooleanStateResponse(error="Error setting inside brain")
 
     async def calibrate(self, manipulator_id: str, sio: socketio.AsyncServer) -> str:
         """Calibrate manipulator
@@ -364,35 +363,26 @@ class PlatformHandler(ABC):
 
     def set_can_write(
         self,
-        manipulator_id: str,
-        can_write: bool,
-        hours: float,
-        sio: socketio.AsyncServer,
-    ) -> com.StateOutputData:
+        request: CanWriteRequest,
+    ) -> BooleanStateResponse:
         """Set manipulator can_write state (enables/disabled moving manipulator)
 
-        :param manipulator_id: The ID of the manipulator to set the state of
-        :type manipulator_id: str
-        :param can_write: True if allowed to move, False if outside
-        :type can_write: bool
-        :param hours: The number of hours to allow writing (0 = forever)
-        :type hours: float
-        :param sio: SocketIO object from server to emit reset event
-        :type sio: :class:`socketio.AsyncServer`
+        :param request: The can write request parsed from the server.
+        :type request: :class:`vbl_aquarium.models.ephys_link.CanWriteRequest`
         :return: New can_write state of the manipulator and error message (if any).
         :rtype: :class:`ephys_link.common.StateOutputData`
         """
         try:
-            return self._set_can_write(manipulator_id, can_write, hours, sio)
+            return self._set_can_write(request)
         except KeyError:
             # Manipulator not found in registered manipulators
-            print(f"[ERROR]\t\t Manipulator not registered: {manipulator_id}\n")
-            return com.StateOutputData(False, "Manipulator not " "registered")
+            print(f"[ERROR]\t\t Manipulator not registered: {request.manipulator_id}\n")
+            return BooleanStateResponse(error="Manipulator not registered")
         except Exception as e:
             # Other error
-            print(f"[ERROR]\t\t Set manipulator {manipulator_id} can_write state")
+            print(f"[ERROR]\t\t Set manipulator {request.manipulator_id} can_write state")
             print(f"{e}\n")
-            return com.StateOutputData(False, "Error setting " "can_write")
+            return BooleanStateResponse(error="Error setting can_write")
 
     # Platform specific methods to override
 
@@ -409,27 +399,27 @@ class PlatformHandler(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def _get_pos(self, manipulator_id: str) -> com.PositionalOutputData:
+    def _get_pos(self, manipulator_id: str) -> PositionalResponse:
         raise NotImplementedError
 
     @abstractmethod
-    def _get_angles(self, manipulator_id: str) -> com.AngularOutputData:
+    def _get_angles(self, manipulator_id: str) -> AngularResponse:
         raise NotImplementedError
 
     @abstractmethod
-    def _get_shank_count(self, manipulator_id: str) -> com.ShankCountOutputData:
+    def _get_shank_count(self, manipulator_id: str) -> ShankCountResponse:
         raise NotImplementedError
 
     @abstractmethod
-    async def _goto_pos(self, manipulator_id: str, position: list[float], speed: float) -> com.PositionalOutputData:
+    async def _goto_pos(self, request: GotoPositionRequest) -> PositionalResponse:
         raise NotImplementedError
 
     @abstractmethod
-    async def _drive_to_depth(self, manipulator_id: str, depth: float, speed: float) -> com.DriveToDepthOutputData:
+    async def _drive_to_depth(self, request: DriveToDepthRequest) -> DriveToDepthResponse:
         raise NotImplementedError
 
     @abstractmethod
-    def _set_inside_brain(self, manipulator_id: str, inside: bool) -> com.StateOutputData:
+    def _set_inside_brain(self, request: InsideBrainRequest) -> BooleanStateResponse:
         raise NotImplementedError
 
     @abstractmethod
@@ -449,33 +439,27 @@ class PlatformHandler(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def _set_can_write(
-        self,
-        manipulator_id: str,
-        can_write: bool,
-        hours: float,
-        sio: socketio.AsyncServer,
-    ) -> com.StateOutputData:
+    def _set_can_write(self, request: CanWriteRequest) -> BooleanStateResponse:
         raise NotImplementedError
 
     @abstractmethod
-    def _platform_space_to_unified_space(self, platform_position: list[float]) -> list[float]:
+    def _platform_space_to_unified_space(self, platform_position: Vector4) -> Vector4:
         """Convert position in platform space to position in unified manipulator space
 
         :param platform_position: Position in platform space (x, y, z, w) in mm
-        :type platform_position: list[float]
+        :type platform_position: Vector4
         :return: Position in unified manipulator space (x, y, z, w) in mm
-        :rtype: list[float]
+        :rtype: Vector4
         """
         raise NotImplementedError
 
     @abstractmethod
-    def _unified_space_to_platform_space(self, unified_position: list[float]) -> list[float]:
+    def _unified_space_to_platform_space(self, unified_position: Vector4) -> Vector4:
         """Convert position in unified manipulator space to position in platform space
 
         :param unified_position: Position in unified manipulator space (x, y, z, w) in mm
-        :type unified_position: list[float]
+        :type unified_position: Vector4
         :return: Position in platform space (x, y, z, w) in mm
-        :rtype: list[float]
+        :rtype: Vector4
         """
         raise NotImplementedError

ephys_link/platform_manipulator.py

@@ -3,6 +3,7 @@
 Most functionality will be implemented on the platform handler side. This is mostly
 for enforcing implementation of the stop method and hold common properties.
 """
+
 from abc import ABC, abstractmethod
 
 # Constants