nanover-server 0.1.2958__tar.gz

nanover_server-0.1.2958/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: nanover-server
+Version: 0.1.2958
+Summary: Python servers for NanoVer.
+Author: Intangible Realities Lab
+License-Expression: MIT
+Project-URL: homepage, https://github.com/IRL2/nanover-server-py
+Project-URL: source, https://github.com/IRL2/nanover-server-py
+Project-URL: documentation, https://irl2.github.io/nanover-docs/
+Project-URL: issues, https://github.com/IRL2/nanover-server-py/issues
+Project-URL: funding, https://irl2.github.io/nanover-docs/#current-sponsors
+Project-URL: changelog, https://github.com/IRL2/nanover-server-py/commits/main/
+Keywords: molecular dynamics,interactive molecular dynamics,imd,imd-vr,imd-xr,virtual reality,vr,extended reality,xr
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Jupyter
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.12
+Requires-Dist: openmm
+Requires-Dist: MDAnalysis
+Requires-Dist: numpy
+Requires-Dist: nglview>=4.0.1
+Requires-Dist: netifaces
+Requires-Dist: ase>=3.21
+Requires-Dist: websockets>=15.0.0
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: pooch
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: python-osc; extra == "dev"
+Requires-Dist: mock; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Requires-Dist: nbval; extra == "dev"
+Requires-Dist: types-netifaces; extra == "dev"

nanover_server-0.1.2958/VERSION.txt

@@ -0,0 +1 @@
+0.1.2958

nanover_server-0.1.2958/conda/build.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+$PYTHON -m pip install . --no-deps --ignore-installed --no-cache-dir -vvv

nanover_server-0.1.2958/conda/meta.yaml

@@ -0,0 +1,42 @@
+package:
+  name: nanover-server
+  version: {{ NANOVER_BUILD_VERSION }}
+
+source:
+  path: ../
+
+build:
+  noarch: python
+  number: 0
+  entry_points:
+    - nanover-server = nanover.app.cli.server_cli:main
+    - nanover-record = nanover.app.cli.recorder_cli:main
+    - nanover-essd-list = nanover.essd.list_cli:main
+    - nanover-dump-state = nanover.recording.cli.dump_cli:main
+    - nanover-split-recording = nanover.recording.cli.split_cli:main
+
+requirements:
+  build:
+    - python >={{ MIN_PYTHON_VERSION }}
+    - setuptools
+  run:
+    - python >={{ MIN_PYTHON_VERSION }}
+    - netifaces
+    - numpy
+    - openmm
+    - ase >=3.21
+    - mdanalysis
+    - nglview
+    - websockets >=15.0.0
+    - msgpack-python >=1.0.0
+
+about:
+  home: {{ NANOVER_DOC_URL }}
+  license: MIT
+  license_file: {{ NANOVER_LICENSE_PATH }}
+  summary: Python servers for NanoVer.
+  description: |
+    NanoVer is a framework for interactive molecular dynamics simulation in
+    virtual reality. This package cause all the python servers to be installed.
+  doc_url: {{ NANOVER_DOC_URL }}
+  dev_url: {{ NANOVER_REPO_URL }}

nanover_server-0.1.2958/pyproject.toml

@@ -0,0 +1,87 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+dynamic = ["version"]
+name = "nanover-server"
+authors = [
+    {name = "Intangible Realities Lab"},
+]
+description = "Python servers for NanoVer."
+license = "MIT"
+keywords = ["molecular dynamics", "interactive molecular dynamics", "imd", "imd-vr", "imd-xr", "virtual reality", "vr", "extended reality", "xr"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Jupyter",
+    "Programming Language :: Python :: 3 :: Only",
+
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX",
+
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Visualization",
+]
+
+requires-python = ">=3.12"
+dependencies = [
+    "openmm",
+    "MDAnalysis",
+    "numpy",
+    "nglview>=4.0.1",
+    "netifaces",
+    "ase >= 3.21",
+    "websockets>=15.0.0",
+    "msgpack>=1.0.0",
+    # mdanalysis will include this soon anyway
+    "pooch",
+]
+
+[project.urls]
+homepage = "https://github.com/IRL2/nanover-server-py"
+source = "https://github.com/IRL2/nanover-server-py"
+documentation = "https://irl2.github.io/nanover-docs/"
+issues = "https://github.com/IRL2/nanover-server-py/issues"
+funding = "https://irl2.github.io/nanover-docs/#current-sponsors"
+changelog = "https://github.com/IRL2/nanover-server-py/commits/main/"
+
+[project.optional-dependencies]
+dev=[
+    # Requirement files for running the tests.
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-timeout",
+    "pytest-xdist",
+    "hypothesis",
+    # python-osc is needed to test an example
+    "python-osc",
+    # mock is required for some core tests
+    "mock",
+    # type checking
+    "mypy",
+    "typing_extensions",
+    # jupyter notebooks
+    "nbval",
+    # ui
+    #"gradio>=5.18.0",
+    # types
+    "types-netifaces",
+]
+
+[project.scripts]
+nanover-server = "nanover.app.cli.server_cli:main"
+nanover-record = "nanover.app.cli.recorder_cli:main"
+nanover-essd-list = "nanover.essd.list_cli:main"
+nanover-dump-state = "nanover.recording.cli.dump_cli:main"
+nanover-split-recording = "nanover.recording.cli.split_cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]  # list of folders that contain the packages (["."] by default)
+include = ["nanover.*"]  # package names should match these glob patterns (["*"] by default)
+
+[tool.setuptools.dynamic]
+version = {file = "VERSION.txt"}

nanover_server-0.1.2958/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nanover_server-0.1.2958/src/nanover/app/__init__.py

@@ -0,0 +1,12 @@
+"""
+Module providing application level wrappers, orchestrators and managers that can be used to
+easily build and deploy NanoVer services.
+"""
+
+from .imd_app import NanoverImdApplication as NanoverImdApplication
+from .omni import OmniRunner as OmniRunner
+from .selection import (
+    SELECTION_ROOT_ID as SELECTION_ROOT_ID,
+    SELECTION_ROOT_NAME as SELECTION_ROOT_NAME,
+    RenderingSelection as RenderingSelection,
+)

nanover_server-0.1.2958/src/nanover/app/cli/recorder_cli.py

@@ -0,0 +1,123 @@
+"""
+A NanoVer client that records the trajectory and the state updates.
+
+Run the script as `nanover-record` to connect to a server running on localhost
+on the default port (38801) and begin recording to uniquely named .traj and
+.state files. Run `nanover-record --help` to find options for connecting to
+specific servers and changing the output filename.
+"""
+
+import argparse
+import textwrap
+import time
+
+from nanover.essd import DiscoveryClient
+from nanover.utilities.cli import suppress_keyboard_interrupt_as_cancellation
+from nanover.websocket.client.app_client import get_websocket_address_from_hub
+from nanover.websocket.record import BackgroundRecordingContext
+
+
+def handle_user_arguments(args=None) -> argparse.Namespace:
+    """
+    Parse the arguments from the command line.
+
+    :return: The namespace of arguments read from the command line.
+    """
+    description = textwrap.dedent(
+        """\
+    Recording client for NanoVer
+    """
+    )
+    parser = argparse.ArgumentParser(description=description)
+
+    parser.add_argument(
+        "--path",
+        default=".",
+        metavar="PATH",
+        help="Destination for recording files.",
+    )
+
+    parser.add_argument(
+        "--prefix",
+        default="recording",
+        metavar="PREFIX",
+        help="Prefix for the recording filenames.",
+    )
+
+    parser.add_argument(
+        "--address",
+        metavar="PROTOCOL://HOST:PORT",
+        help="Connect to specific host address and port.",
+        default="ws://127.0.0.1:38801",
+    )
+
+    parser.add_argument(
+        "--autoconnect",
+        metavar="QUERY",
+        help="Use server discovery and pick a server with name matching the query.",
+    )
+
+    arguments = parser.parse_args(args)
+    return arguments
+
+
+def main():
+    """
+    Entry point for the command line.
+    """
+
+    arguments = handle_user_arguments()
+    address = arguments.address
+
+    if arguments.autoconnect is not None:
+        print(f"Using server discovery to find '{arguments.autoconnect}'")
+        with DiscoveryClient() as discovery_client:
+            for hub in discovery_client.search_for_services():
+                if arguments.autoconnect in hub.name:
+                    address = get_websocket_address_from_hub(hub)
+                    print(f"Found '{hub.name}' at {address}.")
+                    break
+
+    path = arguments.path
+    prefix = arguments.prefix
+
+    count = 0
+
+    while True:
+        count += 1
+        timestamp = time.strftime("%Y%m%d-%H%M%S")
+        name = f"{prefix}-{count}-{timestamp}"
+
+        outfile = f"{path}/{name}.nanover.zip"
+
+        print(f"Connecting to {address}.")
+
+        interrupted = False
+
+        with (
+            suppress_keyboard_interrupt_as_cancellation() as cancellation,
+            BackgroundRecordingContext.from_address_to_path(
+                address=address, path=outfile
+            ) as recording,
+        ):
+            print(f"Recording from server to {outfile}. Press Ctrl-C to stop.")
+            recording.future.add_done_callback(lambda _: cancellation.cancel())
+            cancellation.wait_cancellation(interval=0.01)
+            interrupted = not recording.future.done()
+
+        if not interrupted:
+            print("Recording ended by disconnection.")
+            break
+
+        try:
+            input(
+                "Recording ended by Ctrl-C. Press Ctrl-C to quit or Return to begin recording again."
+            )
+        except KeyboardInterrupt:
+            break
+        except EOFError:
+            break
+
+
+if __name__ == "__main__":
+    main()

nanover_server-0.1.2958/src/nanover/app/cli/server_cli.py

@@ -0,0 +1,233 @@
+"""
+Command line interface for nanover-server.
+"""
+
+import argparse
+import logging
+import ssl
+import textwrap
+import time
+from collections.abc import Iterable
+from contextlib import contextmanager
+from glob import glob
+
+from MDAnalysis import Universe
+from nanover.app import OmniRunner
+from nanover.mdanalysis import UniverseSimulation
+from nanover.openmm import OpenMMSimulation
+from nanover.recording import PlaybackSimulation
+from nanover.utilities.cli import suppress_keyboard_interrupt_as_cancellation
+from nanover.websocket.client.app_client import NanoverImdClient
+from nanover.websocket.discovery import DiscoveryClient
+from nanover.websocket.record import record_from_runner
+
+
+def handle_user_arguments(args=None) -> argparse.Namespace:
+    """
+    Parse the arguments from the command line.
+
+    :return: The namespace of arguments read from the command line.
+    """
+    description = textwrap.dedent(
+        """\
+    Multi-simulation server for NanoVer
+    """
+    )
+    parser = argparse.ArgumentParser(description=description)
+
+    parser.add_argument(
+        "--omm",
+        dest="openmm_xml_entries",
+        action="append",
+        nargs="+",
+        default=[],
+        metavar="PATH",
+        help="Simulations to run via OpenMM (XML format)",
+    )
+
+    parser.add_argument(
+        "--mda",
+        dest="mdanalysis_entries",
+        action="append",
+        nargs="+",
+        default=[],
+        metavar="PATH",
+        help="Independent structures to load via MDanalysis",
+    )
+
+    parser.add_argument(
+        "--playback",
+        dest="recording_entries",
+        action="append",
+        nargs="+",
+        default=[],
+        metavar="PATH",
+        help="Recorded sessions to playback",
+    )
+
+    parser.add_argument(
+        "--record",
+        dest="record_to_path",
+        nargs="?",
+        default=None,
+        const="",
+        metavar="PATH",
+        help="Record trajectory and state to files.",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--include-velocities",
+        action="store_true",
+        default=False,
+        help="Optionally include the particle velocities in the frame data for OMM and ASE simulations.",
+    )
+    parser.add_argument(
+        "-k",
+        "--include-forces",
+        action="store_true",
+        default=False,
+        help="Optionally include the particle forces in the frame data for OMM and ASE simulations.",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--ssl",
+        nargs=3,
+        metavar=("CERTFILE", "KEYFILE", "PASSWORD"),
+        help="Offer SSL in addition to insecure connections.",
+    )
+
+    parser.add_argument(
+        "--cloud-discovery",
+        dest="cloud_discovery_host",
+        metavar="ENDPOINT",
+        help="Advertise server on cloud discovery.",
+    )
+
+    parser.add_argument(
+        "--remote",
+        nargs="?",
+        metavar="PROTOCOL://HOST:PORT",
+        help="Publish to remote server at specific host address and port.",
+        const="ws://localhost:38801",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--name",
+        help="Give a friendly name to the server.",
+    )
+    parser.add_argument("-p", "--port", type=int, default=None)
+    parser.add_argument("-a", "--address", default=None)
+
+    arguments = parser.parse_args(args)
+    return arguments
+
+
+def get_all_paths(path_sets: Iterable[Iterable[str]]):
+    for paths in path_sets:
+        for pattern in paths:
+            files = list(glob(pattern, recursive=True))
+            if files:
+                yield from files
+            else:
+                logging.getLogger(__name__).warning(
+                    f'Path "{pattern}" yielded 0 files.'
+                )
+
+
+@contextmanager
+def initialise_runner(arguments: argparse.Namespace):
+    @contextmanager
+    def make_runner():
+        if arguments.remote is None:
+            with OmniRunner.with_basic_server(
+                name=arguments.name,
+                address=arguments.address,
+                port=arguments.port,
+                ssl=initialise_ssl(arguments),
+            ) as runner:
+                yield runner
+        else:
+            with NanoverImdClient.from_url(arguments.remote) as client:
+                print(f"Serving as client of remote server at {arguments.remote}")
+                with OmniRunner.from_client(client) as runner:
+                    yield runner
+
+    with make_runner() as runner:
+        for path in get_all_paths(arguments.recording_entries):
+            runner.add_simulation(PlaybackSimulation.from_path(path=path))
+
+        for path in get_all_paths(arguments.openmm_xml_entries):
+            simulation = OpenMMSimulation.from_xml_path(path)
+            simulation.include_velocities = arguments.include_velocities
+            simulation.include_forces = arguments.include_forces
+            runner.add_simulation(simulation)
+
+        for path in get_all_paths(arguments.mdanalysis_entries):
+            universe = Universe(path)
+            simulation = UniverseSimulation.from_universe(universe)
+            runner.add_simulation(simulation)
+
+        if arguments.record_to_path is not None:
+            stem = arguments.record_to_path
+            if stem == "":
+                timestamp = time.strftime("%Y-%m-%d-%H%M-%S", time.gmtime())
+                stem = f"omni-recording-{timestamp}"
+
+            out_path = f"{stem}.nanover.zip"
+            print(f"Recording to {out_path}")
+
+            record_from_runner(runner, out_path)
+
+        if arguments.cloud_discovery_host:
+            with DiscoveryClient.advertise_server(
+                arguments.cloud_discovery_host, app_server=runner.app_server
+            ):
+                yield runner
+        else:
+            yield runner
+
+
+def initialise_ssl(arguments: argparse.Namespace):
+    if arguments.ssl is None:
+        return None
+
+    certfile, keyfile, password = arguments.ssl
+    ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    ssl_context.load_verify_locations(certfile)
+    ssl_context.load_cert_chain(certfile, keyfile=keyfile, password=password)
+
+    return ssl_context
+
+
+def main():
+    """
+    Entry point for the command line.
+    """
+    # use the nice logger formatting if available
+    try:
+        from rich.logging import RichHandler
+
+        logging.basicConfig(handlers=[RichHandler(rich_tracebacks=True)])
+    except ImportError:
+        logging.basicConfig()
+    logging.captureWarnings(True)
+
+    arguments = handle_user_arguments()
+
+    with (
+        suppress_keyboard_interrupt_as_cancellation() as cancellation,
+        initialise_runner(arguments) as runner,
+    ):
+        if len(runner.simulations) > 0:
+            runner.load(0)
+
+        runner.print_basic_info()
+        cancellation.wait_cancellation()
+        print("Closing due to KeyboardInterrupt.")
+
+
+if __name__ == "__main__":
+    main()