ephys-link 1.3.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

ephys_link/server.py

@@ -1,508 +0,0 @@
-"""WebSocket server and communication handler
-
-Manages the WebSocket server and handles connections and events from the client. For
-every event, the server does the following:
-
-1. Extract the arguments passed in the event
-2. Log that the event was received
-3. Call the appropriate function in :mod:`ephys_link.sensapex_handler` with arguments
-4. Relay the response from :mod:`ephys_link.sensapex_handler` to the callback function
-"""
-
-from __future__ import annotations
-
-from asyncio import get_event_loop
-from json import loads
-from signal import SIGINT, SIGTERM, signal
-from typing import TYPE_CHECKING, Any
-from uuid import uuid4
-
-from aiohttp import ClientConnectionError, ClientSession
-from aiohttp.web import Application, run_app
-from aiohttp.web_runner import GracefulExit
-from packaging.version import parse
-from pydantic import ValidationError
-
-# from socketio import AsyncServer
-from socketio import AsyncClient, AsyncServer
-from vbl_aquarium.models.ephys_link import (
-    BooleanStateResponse,
-    CanWriteRequest,
-    DriveToDepthRequest,
-    DriveToDepthResponse,
-    GotoPositionRequest,
-    InsideBrainRequest,
-    PositionalResponse,
-)
-from vbl_aquarium.models.proxy import PinpointIdResponse
-
-from ephys_link.__about__ import __version__
-from ephys_link.common import (
-    ASCII,
-    dprint,
-)
-from ephys_link.platforms.new_scale_handler import NewScaleHandler
-from ephys_link.platforms.new_scale_pathfinder_handler import NewScalePathfinderHandler
-from ephys_link.platforms.sensapex_handler import SensapexHandler
-from ephys_link.platforms.ump3_handler import UMP3Handler
-
-if TYPE_CHECKING:
-    from ephys_link.platform_handler import PlatformHandler
-
-
-class Server:
-    def __init__(self) -> None:
-        """Declare and setup server object. Launching is done is a separate function."""
-
-        # Server object.
-        self.sio: AsyncClient | AsyncServer | None = None
-
-        # Web application object.
-        self.app: Application | None = None
-
-        # Proxy server ID.
-        self.pinpoint_id: str = ""
-
-        # Manipulator platform handler.
-        self.platform: PlatformHandler | None = None
-        # Is there a client connected?
-        self.is_connected = False
-
-        # Is the server running?
-        self.is_running = False
-
-        # Register server exit handlers.
-        signal(SIGTERM, self.close_server)
-        signal(SIGINT, self.close_server)
-
-    # Server events.
-    async def connect(self, sid, _, __) -> bool:
-        """Acknowledge connection to the server.
-
-        :param sid: Socket session ID.
-        :type sid: str
-        :param _: WSGI formatted dictionary with request info (unused).
-        :type _: dict
-        :param __: Authentication details (unused).
-        :type __: dict
-        :return: False on error to refuse connection. True otherwise.
-        :rtype: bool
-        """
-        print(f"[CONNECTION REQUEST]:\t\t {sid}\n")
-
-        if not self.is_connected:
-            print(f"[CONNECTION GRANTED]:\t\t {sid}\n")
-            self.is_connected = True
-            return True
-
-        print(f"[CONNECTION DENIED]:\t\t {sid}: another client is already connected\n")
-        return False
-
-    async def disconnect(self, sid) -> None:
-        """Acknowledge disconnection from the server.
-
-        :param sid: Socket session ID.
-        :type sid: str
-        :return: None
-        """
-        print(f"[DISCONNECTION]:\t {sid}\n")
-
-        self.platform.reset()
-        self.is_connected = False
-
-    # Ephys Link Events
-
-    async def get_pinpoint_id(self) -> str:
-        """Get the pinpoint ID.
-
-        :return: Pinpoint ID and whether the client is a requester.
-        :rtype: tuple[str, bool]
-        """
-        return PinpointIdResponse(pinpoint_id=self.pinpoint_id, is_requester=False).to_string()
-
-    @staticmethod
-    async def get_version(_) -> str:
-        """Get the version number of the server.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :return: Version number as defined in :mod:`ephys_link.__about__`.
-        :rtype: str
-        """
-        dprint("[EVENT]\t\t Get version")
-
-        return __version__
-
-    async def get_manipulators(self, _) -> str:
-        """Get the list of discoverable manipulators.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :return: :class:`vbl_aquarium.models.ephys_link.GetManipulatorsResponse` as JSON formatted string.
-        :rtype: str
-        """
-        dprint("[EVENT]\t\t Get discoverable manipulators")
-
-        return self.platform.get_manipulators().to_string()
-
-    async def register_manipulator(self, _, manipulator_id: str) -> str:
-        """Register a manipulator with the server.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of the manipulator to register.
-        :type manipulator_id: str
-        :return: Error message on error, empty string otherwise.
-        :rtype: str
-        """
-        dprint(f"[EVENT]\t\t Register manipulator: {manipulator_id}")
-
-        return self.platform.register_manipulator(manipulator_id)
-
-    async def unregister_manipulator(self, _, manipulator_id: str) -> str:
-        """Unregister a manipulator from the server.
-
-        :param _: Socket session ID (unused)
-        :type _: str
-        :param manipulator_id: ID of the manipulator to unregister.
-        :type manipulator_id: str
-        :return: Error message on error, empty string otherwise.
-        :rtype: str
-        """
-        dprint(f"[EVENT]\t\t Unregister manipulator: {manipulator_id}")
-
-        return self.platform.unregister_manipulator(manipulator_id)
-
-    async def get_pos(self, _, manipulator_id: str) -> str:
-        """Position of manipulator request.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of manipulator to pull position from.
-        :type manipulator_id: str
-        :return: :class:`vbl_aquarium.models.ephys_link.PositionalResponse` as JSON formatted string.
-        :rtype: str
-        """
-        # dprint(f"[EVENT]\t\t Get position of manipulator" f" {manipulator_id}")
-
-        return self.platform.get_pos(manipulator_id).to_string()
-
-    async def get_angles(self, _, manipulator_id: str) -> str:
-        """Angles of manipulator request.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of manipulator to pull angles from.
-        :type manipulator_id: str
-        :return: :class:`vbl_aquarium.models.ephys_link.AngularResponse` as JSON formatted string.
-        :rtype: str
-        """
-
-        return self.platform.get_angles(manipulator_id).to_string()
-
-    async def get_shank_count(self, _, manipulator_id: str) -> str:
-        """Number of shanks of manipulator request.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of manipulator to pull number of shanks from.
-        :type manipulator_id: str
-        :return: :class:`vbl_aquarium.models.ephys_link.ShankCountResponse` as JSON formatted string.
-        :rtype: str
-        """
-
-        return self.platform.get_shank_count(manipulator_id).to_string()
-
-    async def goto_pos(self, _, data: str) -> str:
-        """Move manipulator to position.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param data: :class:`vbl_aquarium.models.ephys_link.GotoPositionRequest` as JSON formatted string.
-        :type data: str
-        :return: :class:`vbl_aquarium.models.ephys_link.PositionalResponse` as JSON formatted string.
-        :rtype: str
-        """
-        try:
-            request = GotoPositionRequest(**loads(data))
-        except ValidationError as ve:
-            print(f"[ERROR]\t\t Invalid goto_pos data: {data}\n{ve}\n")
-            return PositionalResponse(error="Invalid data format").to_string()
-        except Exception as e:
-            print(f"[ERROR]\t\t Error in goto_pos: {e}\n")
-            return PositionalResponse(error="Error in goto_pos").to_string()
-        else:
-            dprint(f"[EVENT]\t\t Move manipulator {request.manipulator_id} to position {request.position}")
-            goto_result = await self.platform.goto_pos(request)
-            return goto_result.to_string()
-
-    async def drive_to_depth(self, _, data: str) -> str:
-        """Drive to depth.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param data: :class:`vbl_aquarium.models.ephys_link.DriveToDepthRequest` as JSON formatted string.
-        :type data: str
-        :return: :class:`vbl_aquarium.models.ephys_link.DriveToDepthResponse` as JSON formatted string.
-        :rtype: str
-        """
-        try:
-            request = DriveToDepthRequest(**loads(data))
-        except KeyError:
-            print(f"[ERROR]\t\t Invalid drive_to_depth data: {data}\n")
-            return DriveToDepthResponse(error="Invalid data " "format").to_string()
-        except Exception as e:
-            print(f"[ERROR]\t\t Error in drive_to_depth: {e}\n")
-            return DriveToDepthResponse(error="Error in drive_to_depth").to_string()
-        else:
-            dprint(f"[EVENT]\t\t Drive manipulator {request.manipulator_id} to depth {request.depth}")
-            drive_result = await self.platform.drive_to_depth(request)
-            return drive_result.to_string()
-
-    async def set_inside_brain(self, _, data: str) -> str:
-        """Set the inside brain state.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param data: :class:`vbl_aquarium.models.ephys_link.InsideBrainRequest` as JSON formatted string.
-        :type data: str
-        :return: :class:`vbl_aquarium.models.ephys_link.BooleanStateResponse` as JSON formatted string.
-        :rtype: str
-        """
-        try:
-            request = InsideBrainRequest(**loads(data))
-        except KeyError:
-            print(f"[ERROR]\t\t Invalid set_inside_brain data: {data}\n")
-            return BooleanStateResponse(error="Invalid data format").to_string()
-        except Exception as e:
-            print(f"[ERROR]\t\t Error in inside_brain: {e}\n")
-            return BooleanStateResponse(error="Error in set_inside_brain").to_string()
-        else:
-            dprint(f"[EVENT]\t\t Set manipulator {request.manipulator_id} inside brain to {request.inside}")
-            return self.platform.set_inside_brain(request).to_string()
-
-    async def calibrate(self, _, manipulator_id: str) -> str:
-        """Calibrate manipulator.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of manipulator to calibrate.
-        :type manipulator_id: str
-        :return: Error message on error, empty string otherwise.
-        :rtype: str
-        """
-        dprint(f"[EVENT]\t\t Calibrate manipulator" f" {manipulator_id}")
-
-        return await self.platform.calibrate(manipulator_id, self.sio)
-
-    async def bypass_calibration(self, _, manipulator_id: str) -> str:
-        """Bypass calibration of manipulator.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param manipulator_id: ID of manipulator to bypass calibration.
-        :type manipulator_id: str
-        :return: Error message on error, empty string otherwise.
-        :rtype: str
-        """
-        dprint(f"[EVENT]\t\t Bypass calibration of manipulator" f" {manipulator_id}")
-
-        return self.platform.bypass_calibration(manipulator_id)
-
-    async def set_can_write(self, _, data: str) -> str:
-        """Set manipulator can_write state.
-
-        :param _: Socket session ID (unused)
-        :type _: str
-        :param data: :class:`vbl_aquarium.models.ephys_link.CanWriteRequest` as JSON formatted string.
-        :type data: str
-        :return: :class:`vbl_aquarium.models.ephys_link.BooleanStateResponse` as JSON formatted string.
-        :rtype: str
-        """
-        try:
-            request = CanWriteRequest(**loads(data))
-        except KeyError:
-            print(f"[ERROR]\t\t Invalid set_can_write data: {data}\n")
-            return BooleanStateResponse(error="Invalid data format").to_string()
-        except Exception as e:
-            print(f"[ERROR]\t\t Error in inside_brain: {e}\n")
-            return BooleanStateResponse(error="Error in set_can_write").to_string()
-        else:
-            dprint(f"[EVENT]\t\t Set manipulator {request.manipulator_id} can_write state to {request.can_write}")
-            return self.platform.set_can_write(request).to_string()
-
-    def stop(self, _) -> bool:
-        """Stop all manipulators.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :return: True if successful, False otherwise.
-        :rtype: bool
-        """
-        dprint("[EVENT]\t\t Stop all manipulators")
-
-        return self.platform.stop()
-
-    @staticmethod
-    async def catch_all(_, __, data: Any) -> str:
-        """Catch all event.
-
-        :param _: Socket session ID (unused).
-        :type _: str
-        :param __: Client ID (unused).
-        :type __: str
-        :param data: Data received from client.
-        :type data: Any
-        :return: "UNKNOWN_EVENT" response message.
-        :rtype: str
-        """
-        print(f"[UNKNOWN EVENT]:\t {data}")
-        return "UNKNOWN_EVENT"
-
-    # Server functions
-    async def launch_setup(self, platform_type: str, pathfinder_port: int, ignore_updates) -> None:
-        # Import correct manipulator handler
-        match platform_type:
-            case "sensapex":
-                self.platform = SensapexHandler()
-            case "ump3":
-                self.platform = UMP3Handler()
-            case "new_scale":
-                self.platform = NewScaleHandler()
-            case "new_scale_pathfinder":
-                self.platform = NewScalePathfinderHandler(pathfinder_port)
-            case _:
-                error = f"[ERROR]\t\t Invalid manipulator type: {platform_type}"
-                raise ValueError(error)
-
-        # Preamble.
-        print(ASCII)
-        print(f"v{__version__}")
-
-        # Check for newer version.
-        if not ignore_updates:
-            try:
-                async with (
-                    ClientSession() as session,
-                    session.get("https://api.github.com/repos/VirtualBrainLab/ephys-link/tags") as response,
-                ):
-                    latest_version = (await response.json())[0]["name"]
-                    if parse(latest_version) > parse(__version__):
-                        print(f"New version available: {latest_version}")
-                        print("Download at: https://github.com/VirtualBrainLab/ephys-link/releases/latest")
-
-                await session.close()
-            except ClientConnectionError:
-                pass
-
-        # Explain window.
-        print()
-        print("This is the Ephys Link server window.")
-        print("You may safely leave it running in the background.")
-        print("To stop it, close this window or press CTRL + Pause/Break.")
-        print()
-
-        # List available manipulators
-        print("Available Manipulators:")
-        print(self.platform.get_manipulators().manipulators)
-        print()
-
-    async def launch_for_proxy(
-        self, proxy_address: str, port: int, platform_type: str, pathfinder_port: int | None, ignore_updates: bool
-    ) -> None:
-        """Launch the server in proxy mode.
-
-        :param proxy_address: Proxy IP address.
-        :type proxy_address: str
-        :param port: Port to serve the server.
-        :type port: int
-        :param platform_type: Parsed argument for platform type.
-        :type platform_type: str
-        :param pathfinder_port: Port New Scale Pathfinder's server is on.
-        :type pathfinder_port: int
-        :param ignore_updates: Flag to ignore checking for updates.
-        :type ignore_updates: bool
-        :return: None
-        """
-
-        # Launch setup
-        await self.launch_setup(platform_type, pathfinder_port, ignore_updates)
-
-        # Create AsyncClient.
-        self.sio = AsyncClient()
-        self.pinpoint_id = str(uuid4())[:8]
-
-        # Bind events.
-        self.bind_events()
-
-        # Connect and mark that server is running.
-        await self.sio.connect(f"http://{proxy_address}:{port}")
-        self.is_running = True
-        print(f"Pinpoint ID: {self.pinpoint_id}")
-        await self.sio.wait()
-
-    def launch(
-        self,
-        platform_type: str,
-        port: int,
-        pathfinder_port: int | None,
-        ignore_updates: bool,
-    ) -> None:
-        """Launch the server.
-
-        :param platform_type: Parsed argument for platform type.
-        :type platform_type: str
-        :param port: HTTP port to serve the server.
-        :type port: int
-        :param pathfinder_port: Port New Scale Pathfinder's server is on.
-        :type pathfinder_port: int
-        :param ignore_updates: Flag to ignore checking for updates.
-        :type ignore_updates: bool
-        :return: None
-        """
-
-        # Launch setup (synchronously)
-        get_event_loop().run_until_complete(self.launch_setup(platform_type, pathfinder_port, ignore_updates))
-
-        # Create AsyncServer
-        self.sio = AsyncServer()
-        self.app = Application()
-        self.sio.attach(self.app)
-
-        # Bind events
-        self.sio.on("connect", self.connect)
-        self.sio.on("disconnect", self.disconnect)
-        self.bind_events()
-
-        # Mark that server is running
-        self.is_running = True
-        run_app(self.app, port=port)
-
-    def bind_events(self) -> None:
-        """Bind Ephys Link events to the server."""
-        self.sio.on("get_pinpoint_id", self.get_pinpoint_id)
-        self.sio.on("get_version", self.get_version)
-        self.sio.on("get_manipulators", self.get_manipulators)
-        self.sio.on("register_manipulator", self.register_manipulator)
-        self.sio.on("unregister_manipulator", self.unregister_manipulator)
-        self.sio.on("get_pos", self.get_pos)
-        self.sio.on("get_angles", self.get_angles)
-        self.sio.on("get_shank_count", self.get_shank_count)
-        self.sio.on("goto_pos", self.goto_pos)
-        self.sio.on("drive_to_depth", self.drive_to_depth)
-        self.sio.on("set_inside_brain", self.set_inside_brain)
-        self.sio.on("calibrate", self.calibrate)
-        self.sio.on("bypass_calibration", self.bypass_calibration)
-        self.sio.on("set_can_write", self.set_can_write)
-        self.sio.on("stop", self.stop)
-        self.sio.on("*", self.catch_all)
-
-    def close_server(self, _, __) -> None:
-        """Close the server."""
-        print("[INFO]\t\t Closing server")
-
-        # Stop movement
-        self.platform.stop()
-
-        # Exit
-        raise GracefulExit

ephys_link-1.3.3.dist-info/METADATA

@@ -1,164 +0,0 @@
-Metadata-Version: 2.3
-Name: ephys-link
-Version: 1.3.3
-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
-Project-URL: Source, https://github.com/VirtualBrainLab/ephys-link
-Author-email: Kenneth Yang <kjy5@uw.edu>
-Maintainer-email: Kenneth Yang <kjy5@uw.edu>
-License-Expression: GPL-3.0-only
-License-File: LICENSE
-Keywords: electrophysiology,ephys,manipulator,neuroscience,neurotech,new-scale,sensapex,socket-io,virtualbrainlab
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Healthcare Industry
-Classifier: Intended Audience :: Science/Research
-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.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: Implementation :: CPython
-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: platformdirs==4.2.2
-Requires-Dist: pyserial==3.5
-Requires-Dist: python-socketio[asyncio-client]==5.11.2
-Requires-Dist: pythonnet==3.0.3
-Requires-Dist: sensapex==1.400.0
-Requires-Dist: vbl-aquarium==0.0.15
-Description-Content-Type: text/markdown
-
-# Electrophysiology Manipulator Link
-
-[![PyPI version](https://badge.fury.io/py/ephys-link.svg)](https://badge.fury.io/py/ephys-link)
-[![CodeQL](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/codeql-analysis.yml)
-[![Dependency Review](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/dependency-review.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/dependency-review.yml)
-[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
-[![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)
-
-<!-- [![Build](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml/badge.svg)](https://github.com/VirtualBrainLab/ephys-link/actions/workflows/build.yml) -->
-
-<img width="100%" src="https://github.com/VirtualBrainLab/ephys-link/assets/82800265/0c7c60b1-0926-4697-a461-221554f82de1" alt="Manipulator and probe in pinpoint moving in sync">
-
-The [Electrophysiology Manipulator Link](https://github.com/VirtualBrainLab/ephys-link)
-(or Ephys Link for short) is a Python [Socket.IO](https://socket.io/docs/v4/#what-socketio-is) server that allows any
-Socket.IO-compliant application (such
-as [Pinpoint](https://github.com/VirtualBrainLab/Pinpoint))
-to communicate with manipulators used in electrophysiology experiments.
-
-**Supported Manipulators:**
-
-| Manufacturer | Model                                                                   |
-|--------------|-------------------------------------------------------------------------|
-| Sensapex     | <ul> <li>uMp-4</li> <li>uMp-3</li> </ul>                                |
-| New Scale    | <ul> <li>Pathfinder MPM Control v2.8+</li> <li>M3-USB-3:1-EP</li> </ul> |
-
-Ephys Link is an open and extensible platform. It is designed to easily support integration with other manipulators.
-
-For more information regarding the server's implementation and how the code is organized, see
-the [package's development documentation](https://virtualbrainlab.org/ephys_link/development.html).
-
-For detailed descriptions of the server's API, see
-the [API reference](https://virtualbrainlab.org/api_reference_ephys_link.html).
-
-# Installation
-
-## Prerequisites
-
-1. An **x86 Windows PC is required** to run the server.
-2. For Sensapex devices, the controller unit must be connected via an ethernet
-   cable and powered. A USB-to-ethernet adapter is acceptable. For New Scale manipulators,
-   the controller unit must be connected via USB and be powered by a 6V power
-   supply.
-3. To use the emergency stop feature, ensure an Arduino with
-   the [StopSignal](https://github.com/VirtualBrainLab/StopSignal) sketch is
-   connected to the computer. Follow the instructions on that repo for how to
-   set up the Arduino.
-
-**NOTE:** Ephys Link is an HTTP server without cross-origin support. The server
-is currently designed to interface with local/desktop instances of Pinpoint. It
-will not work with the web browser versions of Pinpoint at this time.
-
-## Launch from Pinpoint (Recommended)
-
-Pinpoint comes bundled with the correct version of Ephys Link. If you are using Pinpoint on the same computer your
-manipulators are connected to, you can launch the server from within Pinpoint. Follow the instructions in
-the [Pinpoint documentation](https://virtualbrainlab.org/pinpoint/tutorials/tutorial_ephys_link.html#configure-and-launch-ephys-link).
-
-## Install as Standalone Executable
-
-1. Download the latest executable from
-   the [releases page](https://github.com/VirtualBrainLab/ephys-link/releases/latest).
-2. Double-click the executable file to launch the configuration window.
-    1. Take note of the IP address and port. **Copy this information into Pinpoint to connect**.
-3. Select the desired configuration and click "Launch Server".
-
-The configuration window will close and the server will launch. Your configurations will be saved for future use.
-
-To connect to the server from Pinpoint, provide the IP address and port. For example, if the server is running on the
-same computer that Pinpoint is, use
-
-- Server: `localhost`
-- Port: `8081`
-
-If the server is running on a different (local) computer, use the IP address of that computer as shown in the startup
-window instead of `localhost`.
-
-## Install as a Python package
-
-```bash
-pip install ephys-link
-```
-
-Import the modules you need and launch the server.
-
-```python
-from ephys_link.server import Server
-
-server = Server()
-server.launch("sensapex", args.proxy_address, 8081)
-```
-
-## Install for Development
-
-1. Clone the repository.
-2. Install [Hatch](https://hatch.pypa.io/latest/install/)
-3. In a terminal, navigate to the repository's root directory and run
-
-   ```bash
-   hatch shell
-   ```
-
-This will create a virtual environment, install Python 12 (if not found), and install the package in editable mode.
-
-If you encounter any dependency issues (particularly with `aiohttp`), try installing the latest Microsoft Visual C++
-(MSVC v143+ x86/64) and the Windows SDK (10/11)
-via [Visual Studio Build Tools Installer](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
-
-# Documentation and More Information
-
-Complete documentation including API usage and development installation can be
-found on the [Virtual Brain Lab Documentation page][docs] for Ephys Link.
-
-# Citing
-
-If this project is used as part of a research project you should cite
-the [Pinpoint repository][Pinpoint]. Please email
-Dan ([dbirman@uw.edu](mailto:dbirman@uw.edu)) if you have questions.
-
-Please reach out to Kenneth ([kjy5@uw.edu](mailto:kjy5@uw.edu)) for questions
-about the Electrophysiology Manipulator Link server. Bugs may be reported
-through the issues tab.
-
-[Pinpoint]: https://github.com/VirtualBrainLab/Pinpoint
-
-[StopSignal]: https://github.com/VirtualBrainLab/StopSignal
-
-[docs]: https://virtualbrainlab.org/ephys_link/installation_and_use.html