imdclient 0.1.4__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

imdclient/tests/test_gromacs.py

@@ -1,6 +1,9 @@
-import MDAnalysis as mda
-import pytest
 import logging
+from pathlib import Path
+import re
+
+import pytest
+
 from .base import IMDv3IntegrationTest
 from .datafiles import (
     GROMACS_GRO,
@@ -8,7 +11,6 @@ from .datafiles import (
     GROMACS_MDP_NST_1,
     GROMACS_MDP_NST_8,
 )
-from pathlib import Path
 
 logger = logging.getLogger("imdclient.IMDClient")
 file_handler = logging.FileHandler("gromacs_test.log")
@@ -46,6 +48,16 @@ class TestIMDv3Gromacs(IMDv3IntegrationTest):
     def topol(self):
         return Path(GROMACS_GRO).name
 
+    @pytest.fixture()
+    def dt(self, mdp):
+        pattern = re.compile(r"^\s*dt\s*=\s*(\S+)")
+        with open(mdp, "r") as file:
+            for line in file:
+                match = pattern.match(line)
+                if match:
+                    return float(match.group(1))
+        raise ValueError(f"No dt found in {mdp}")
+
     # @pytest.fixture()
     # def match_string(self):
     #     return "IMD: Will wait until I have a connection and IMD_GO orders."

imdclient/tests/test_imdclient.py

@@ -1,10 +1,17 @@
 """Test for IMDClient functionality"""
 
+import logging
+
+import pytest
+from numpy.testing import (
+    assert_allclose,
+)
+import MDAnalysis as mda
 from MDAnalysisTests.datafiles import (
     COORDINATES_TOPOLOGY,
     COORDINATES_H5MD,
 )
-import MDAnalysis as mda
+
 from imdclient.IMDClient import imdframe_memsize, IMDClient
 from imdclient.IMDProtocol import IMDHeaderType
 from .utils import (
@@ -12,12 +19,6 @@ from .utils import (
     create_default_imdsinfo_v3,
 )
 from .server import InThreadIMDServer
-from MDAnalysisTests.coordinates.base import (
-    assert_allclose,
-)
-from MDAnalysisTests.coordinates.test_xdr import TRRReference
-import logging
-import pytest
 
 
 logger = logging.getLogger("imdclient.IMDClient")

imdclient/tests/test_lammps.py

@@ -1,7 +1,11 @@
-import MDAnalysis as mda
-import pytest
-from pathlib import Path
 import logging
+from pathlib import Path
+import re
+
+import pytest
+import MDAnalysis as mda
+
+from .minimalreader import MinimalReader
 from .base import IMDv3IntegrationTest
 from .datafiles import LAMMPS_TOPOL, LAMMPS_IN_NST_1, LAMMPS_IN_NST_8
 
@@ -48,10 +52,15 @@ class TestIMDv3Lammps(IMDv3IntegrationTest):
         else:
             return 0
 
-    # Not present in lammps-produced H5MD
     @pytest.fixture()
-    def comp_dt(self):
-        return False
+    def dt(self, inp):
+        pattern = re.compile(r"^\s*timestep\s*(\S+)")
+        with open(inp, "r") as file:
+            for line in file:
+                match = pattern.match(line)
+                if match:
+                    return float(match.group(1))
+        raise ValueError(f"No dt found in {inp}")
 
     # This must wait until after imd stream has ended
     @pytest.fixture()
@@ -66,18 +75,12 @@ class TestIMDv3Lammps(IMDv3IntegrationTest):
 
     @pytest.fixture()
     def imd_u(self, docker_client, topol, tmp_path, port):
-        u = mda.Universe(
-            (tmp_path / topol),
-            f"imd://localhost:{port}",
-            atom_style="id type x y z",
-        )
-        with mda.Writer(
-            (tmp_path / "imd.trr").as_posix(), u.trajectory.n_atoms
-        ) as w:
-            for ts in u.trajectory:
-                w.write(u.atoms)
-        yield mda.Universe(
-            (tmp_path / topol),
-            (tmp_path / "imd.trr"),
+        n_atoms = mda.Universe(
+            tmp_path / topol,
             atom_style="id type x y z",
+            convert_units=False,
+        ).atoms.n_atoms
+        u = MinimalReader(
+            f"imd://localhost:{port}", n_atoms=n_atoms, process_stream=True
         )
+        yield u

imdclient/tests/test_manual.py

@@ -1,5 +1,4 @@
-import imdclient
-from imdclient.IMD import IMDReader
+from .minimalreader import MinimalReader
 import MDAnalysis as mda
 from numpy.testing import assert_allclose
 import numpy as np
@@ -91,17 +90,15 @@ def load_true_universe(topol_path, traj_path):
 
 def load_imd_universe(topol_path, tmp_path):
     # Pass atom_style (ignored if not using LAMMPS topol)
-    tmp_u = mda.Universe(
+    n_atoms = mda.Universe(
         topol_path,
-        "imd://localhost:8888",
         atom_style="id type x y z",
+        convert_units=False,
+    ).atoms.n_atoms
+    tmp_u = MinimalReader(
+        f"imd://localhost:8888", n_atoms=n_atoms, process_stream=True
     )
-    tmp_traj_file = f"{tmp_path}/imd_test_traj.trr"
-    with mda.Writer(tmp_traj_file, tmp_u.atoms.n_atoms) as w:
-        for ts in tmp_u.trajectory:
-            w.write(tmp_u.atoms)
-    time.sleep(10)  # Give MPI ranks a chance to release FD
-    return mda.Universe(topol_path, tmp_traj_file, atom_style="id type x y z")
+    return tmp_u
 
 
 def test_compare_imd_to_true_traj_vel(imd_u, true_u_vel, first_frame):
@@ -123,23 +120,27 @@ def test_compare_imd_to_true_traj_forces(imd_u, true_u_force, first_frame):
         )
 
 
-def test_compare_imd_to_true_traj(imd_u, true_u, first_frame, vel, force, dt):
+def test_compare_imd_to_true_traj(
+    imd_u, true_u, first_frame, vel, force, dt, step
+):
     for i in range(first_frame, len(true_u.trajectory)):
         assert_allclose(
             true_u.trajectory[i].time,
             imd_u.trajectory[i - first_frame].time,
             atol=1e-03,
         )
-        if dt:
+        # Issue #63
+        # if dt:
+        #     assert_allclose(
+        #         true_u.trajectory[i].dt,
+        #         imd_u.trajectory[i - first_frame].dt,
+        #         atol=1e-03,
+        #     )
+        if step:
             assert_allclose(
-                true_u.trajectory[i].dt,
-                imd_u.trajectory[i - first_frame].dt,
-                atol=1e-03,
+                true_u.trajectory[i].data["step"],
+                imd_u.trajectory[i - first_frame].data["step"],
             )
-        assert_allclose(
-            true_u.trajectory[i].data["step"],
-            imd_u.trajectory[i - first_frame].data["step"],
-        )
         assert_allclose_with_logging(
             true_u.trajectory[i].dimensions,
             imd_u.trajectory[i - first_frame].dimensions,
@@ -207,6 +208,8 @@ def main():
         vel_in_trr = args.vel_path is None
         force_in_trr = args.force_path is None
         dt_in_trr = not args.topol_path.endswith(".data")
+        # True when not using DCDReader
+        step_in_trr = not args.traj_path.endswith(".coor")
 
         test_compare_imd_to_true_traj(
             imd_u,
@@ -215,6 +218,7 @@ def main():
             vel_in_trr,
             force_in_trr,
             dt_in_trr,
+            step_in_trr,
         )
 
         if args.vel_path is not None:
@@ -223,9 +227,7 @@ def main():
             )
             true_vel = load_true_universe(args.topol_path, args.vel_path)
             print("Comparing velocities...")
-            test_compare_imd_to_true_traj_vel(
-                imd_u, true_vel, args.first_frame
-            )
+            test_compare_imd_to_true_traj_vel(imd_u, true_vel, args.first_frame)
 
         if args.force_path is not None:
             print(

imdclient/tests/test_namd.py

@@ -1,6 +1,13 @@
-import MDAnalysis as mda
-import pytest
 import logging
+from pathlib import Path
+import re
+
+import pytest
+from numpy.testing import (
+    assert_allclose,
+)
+import MDAnalysis as mda
+
 from .base import IMDv3IntegrationTest, assert_allclose_with_logging
 from .datafiles import (
     NAMD_TOPOL,
@@ -9,10 +16,6 @@ from .datafiles import (
     NAMD_PARAMS,
     NAMD_PSF,
 )
-from pathlib import Path
-from numpy.testing import (
-    assert_allclose,
-)
 
 logger = logging.getLogger("imdclient.IMDClient")
 file_handler = logging.FileHandler("namd_test.log")
@@ -26,6 +29,10 @@ logger.setLevel(logging.DEBUG)
 
 class TestIMDv3NAMD(IMDv3IntegrationTest):
 
+    @pytest.fixture()
+    def container_name(self):
+        return "ghcr.io/becksteinlab/streaming-namd-docker:main-common-cpu"
+
     @pytest.fixture(params=[NAMD_CONF_NST_1, NAMD_CONF_NST_8])
     def inp(self, request):
         return request.param
@@ -42,6 +49,18 @@ class TestIMDv3NAMD(IMDv3IntegrationTest):
     def topol(self):
         return Path(NAMD_TOPOL).name
 
+    @pytest.fixture()
+    def dt(self, inp):
+        pattern = re.compile(r"^\s*timestep\s*(\S+)")
+        with open(inp, "r") as file:
+            for line in file:
+                match = pattern.match(line)
+                if match:
+                    # NAMD timestep is in femtoseconds, convert to picoseconds
+                    # as IMDv3 expects dt in ps, 1fs = 0.001ps
+                    return float(match.group(1)) * 0.001
+        raise ValueError(f"No dt found in {inp}")
+
     @pytest.fixture()
     def true_u(self, topol, imd_u, tmp_path):
         u = mda.Universe(
@@ -75,40 +94,43 @@ class TestIMDv3NAMD(IMDv3IntegrationTest):
         return 0
 
     # Compare coords, box, time, dt, step
-    def test_compare_imd_to_true_traj(self, imd_u, true_u, first_frame):
+    def test_compare_imd_to_true_traj(self, imd_u, true_u, first_frame, dt):
         for i in range(first_frame, len(true_u.trajectory)):
+
             assert_allclose(
                 true_u.trajectory[i].time,
                 imd_u.trajectory[i - first_frame].time,
                 atol=1e-03,
             )
+
             assert_allclose(
-                true_u.trajectory[i].dt,
+                dt,
                 imd_u.trajectory[i - first_frame].dt,
                 atol=1e-03,
             )
-            assert_allclose(
-                true_u.trajectory[i].data["step"],
-                imd_u.trajectory[i - first_frame].data["step"],
-            )
+            # step in DCDReader is frame index, not integration step
+            # don't compare step
+
             assert_allclose_with_logging(
                 true_u.trajectory[i].dimensions,
                 imd_u.trajectory[i - first_frame].dimensions,
                 atol=1e-03,
             )
+
             assert_allclose_with_logging(
                 true_u.trajectory[i].positions,
                 imd_u.trajectory[i - first_frame].positions,
                 atol=1e-03,
             )
 
+    # Since NAMD does not write velocities, forces to the DCD file, we need to do so seperately by extracting that info from their respective DCD files
     # Compare velocities
-    def test_compare_imd_to_true_traj_vel(
-        self, imd_u, true_u_vel, first_frame
-    ):
+    def test_compare_imd_to_true_traj_vel(self, imd_u, true_u_vel, first_frame):
         for i in range(first_frame, len(true_u_vel.trajectory)):
+
             assert_allclose_with_logging(
-                true_u_vel.trajectory[i].positions,
+                # Unit conversion
+                true_u_vel.trajectory[i].positions * 20.45482706,
                 imd_u.trajectory[i - first_frame].velocities,
                 atol=1e-03,
             )
@@ -118,6 +140,7 @@ class TestIMDv3NAMD(IMDv3IntegrationTest):
         self, imd_u, true_u_force, first_frame
     ):
         for i in range(first_frame, len(true_u_force.trajectory)):
+
             assert_allclose_with_logging(
                 true_u_force.trajectory[i].positions,
                 imd_u.trajectory[i - first_frame].forces,

imdclient/tests/test_utils.py

@@ -0,0 +1,31 @@
+# tests/test_utils.py
+import pytest
+from imdclient.utils import parse_host_port
+
+
+@pytest.mark.parametrize(
+    "server_address,host_port",
+    [
+        ("imd://localhost:8888", ("localhost", 8888)),
+        ("imd://example.com:12345", ("example.com", 12345)),
+    ],
+)
+def test_parse_host_port_valid(server_address, host_port):
+    assert parse_host_port(server_address) == host_port
+
+
+@pytest.mark.parametrize(
+    "server_address",
+    [
+        "",  # empty
+        "http://localhost:80",  # wrong protocol prefix
+        "imd://",  # missing host and port
+        "imd://localhost:",  # missing port
+        "imd://:8080",  # missing host
+        "imd://host:notaport",  # port not integer
+        "imd://host:80:90",  # too many segments
+    ],
+)
+def test_parse_host_port_invalid(server_address):
+    with pytest.raises(ValueError):
+        parse_host_port(server_address)

imdclient/utils.py

@@ -43,23 +43,6 @@ class timeit(object):
         # always propagate exceptions forward
         return False
 
-# NOTE: think of other edge cases as well- should be robust
-def parse_host_port(filename):
-    if not filename.startswith("imd://"):
-        raise ValueError("IMDReader: URL must be in the format 'imd://host:port'")
-    
-    # Check if the format is correct
-    parts = filename.split("imd://")[1].split(":")
-    if len(parts) == 2:
-        host = parts[0] 
-        try:
-            port = int(parts[1])
-            return (host, port)
-        except ValueError:
-            raise ValueError("IMDReader: Port must be an integer")
-    else:
-        raise ValueError("IMDReader: URL must be in the format 'imd://host:port'")
-
 
 def approximate_timestep_memsize(
     n_atoms, energies, dimensions, positions, velocities, forces
@@ -116,3 +99,53 @@ def sock_contains_data(sock, timeout) -> bool:
         [sock], [], [], timeout
     )
     return sock in ready_to_read
+
+
+def parse_host_port(filename):
+    """
+    Parses a URL in the format 'imd://host:port' and returns the host and port.
+    Parameters
+    ----------
+    filename : str
+        The URL to parse, must be in the format 'imd://host:port'.
+
+    Returns
+    -------
+    tuple[str, int]
+        A 2-tuple ``(host, port)`` where `host` is the host server name
+        and `port` is the TCP port number.
+    Raises
+    ------
+    ValueError
+        If the URL is not in the correct format or if the host or port is invalid.
+
+    Examples
+    --------
+    >>> parse_host_port("imd://localhost:8888")
+    ('localhost', 8888)
+    >>> parse_host_port("invalid://localhost:12345")
+    Traceback (most recent call last):
+        ... ValueError: IMDClient: URL must be in the format 'imd://host:port'
+    """
+    if not filename.startswith("imd://"):
+        raise ValueError(
+            "IMDClient: URL must be in the format 'imd://host:port'"
+        )
+
+    # Check if the format is correct
+    parts = filename.split("imd://")[1].split(":")
+    if len(parts) == 2:
+        host = parts[0]
+        if not host:
+            raise ValueError("IMDClient: Host cannot be empty")
+        if not parts[1]:
+            raise ValueError("IMDClient: Port cannot be empty")
+        try:
+            port = int(parts[1])
+            return (host, port)
+        except ValueError:
+            raise ValueError("IMDClient: Port must be an integer")
+    else:
+        raise ValueError(
+            "IMDClient: URL must be in the format 'imd://host:port'"
+        )

{imdclient-0.1.4.dist-info → imdclient-0.2.0b0.dist-info}/METADATA

@@ -1,29 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: imdclient
-Version: 0.1.4
+Version: 0.2.0b0
 Summary: Receiver for IMD v2 and v3 data from simulation engines like Gromacs, LAMMPS, and NAMD
 Author-email: Lawson <ljwoods2@asu.edu>
-Maintainer-email: Lawson <ljwoods2@asu.edu>
+Maintainer-email: Lawson <ljwoods2@asu.edu>, Amruthesh Thirumalaiswamy <athiru12@asu.edu>
 License: Copyright 2024 Lawson Woods
         
         Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
         
         The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: source, https://github.com/becksteinlab/imdclient
+Project-URL: documentation, https://imdclient.readthedocs.io
 Keywords: molecular simulations
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS.md
-Requires-Dist: MDAnalysis>=2.7.0
+Requires-Dist: numpy
 Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-xdist>=2.5; extra == "test"
 Requires-Dist: pytest-cov>=3.0; extra == "test"
-Requires-Dist: MDAnalysisTests>=2.7.0; extra == "test"
+Requires-Dist: MDAnalysis; extra == "test"
+Requires-Dist: MDAnalysisTests; extra == "test"
 Requires-Dist: docker-py; extra == "test"
 Provides-Extra: doc
 Requires-Dist: sphinx; extra == "doc"
-Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Requires-Dist: mdanalysis-sphinx-theme>=1.0.1; extra == "doc"
+Dynamic: license-file
 
 IMDClient
 ==============================
@@ -32,86 +39,99 @@ IMDClient
 | **Latest release** | [![Last release tag][badge_release]][url_latest_release] ![GitHub commits since latest release (by date) for a branch][badge_commits_since]  [![Documentation Status][badge_docs]][url_docs]|
 | :----------------- | :------- |
 | **Status**         | [![GH Actions Status][badge_actions]][url_actions] [![codecov][badge_codecov]][url_codecov] |
-| **Community**      | [![License: MIT][badge_license]][url_license]  [![Powered by MDAnalysis][badge_mda]][url_mda]|
+| **Community**      | [![License: MIT][badge_license]][url_license]
 
 [badge_actions]: https://github.com/becksteinlab/imdclient/actions/workflows/gh-ci.yaml/badge.svg
 [badge_codecov]: https://codecov.io/gh/becksteinlab/imdclient/branch/main/graph/badge.svg
 [badge_commits_since]: https://img.shields.io/github/commits-since/becksteinlab/imdclient/latest
 [badge_docs]: https://readthedocs.org/projects/imdclient/badge/?version=latest
 [badge_license]: https://img.shields.io/badge/License-MIT-blue.svg
-[badge_mda]: https://img.shields.io/badge/powered%20by-MDAnalysis-orange.svg?logoWidth=16&logo=data:image/x-icon;base64,AAABAAEAEBAAAAEAIAAoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJD+XwCY/fEAkf3uAJf97wGT/a+HfHaoiIWE7n9/f+6Hh4fvgICAjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACT/yYAlP//AJ///wCg//8JjvOchXly1oaGhv+Ghob/j4+P/39/f3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJH8aQCY/8wAkv2kfY+elJ6al/yVlZX7iIiI8H9/f7h/f38UAAAAAAAAAAAAAAAAAAAAAAAAAAB/f38egYF/noqAebF8gYaagnx3oFpUUtZpaWr/WFhY8zo6OmT///8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgICAn46Ojv+Hh4b/jouJ/4iGhfcAAADnAAAA/wAAAP8AAADIAAAAAwCj/zIAnf2VAJD/PAAAAAAAAAAAAAAAAICAgNGHh4f/gICA/4SEhP+Xl5f/AwMD/wAAAP8AAAD/AAAA/wAAAB8Aov9/ALr//wCS/Z0AAAAAAAAAAAAAAACBgYGOjo6O/4mJif+Pj4//iYmJ/wAAAOAAAAD+AAAA/wAAAP8AAABhAP7+FgCi/38Axf4fAAAAAAAAAAAAAAAAiIiID4GBgYKCgoKogoB+fYSEgZhgYGDZXl5e/m9vb/9ISEjpEBAQxw8AAFQAAAAAAAAANQAAADcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjo6Mb5iYmP+cnJz/jY2N95CQkO4pKSn/AAAA7gAAAP0AAAD7AAAAhgAAAAEAAAAAAAAAAACL/gsAkv2uAJX/QQAAAAB9fX3egoKC/4CAgP+NjY3/c3Nz+wAAAP8AAAD/AAAA/wAAAPUAAAAcAAAAAAAAAAAAnP4NAJL9rgCR/0YAAAAAfX19w4ODg/98fHz/i4uL/4qKivwAAAD/AAAA/wAAAP8AAAD1AAAAGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALGxsVyqqqr/mpqa/6mpqf9KSUn/AAAA5QAAAPkAAAD5AAAAhQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkUFBSuZ2dn/3V1df8uLi7bAAAATgBGfyQAAAA2AAAAMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0AAADoAAAA/wAAAP8AAAD/AAAAWgC3/2AAnv3eAJ/+dgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9AAAA/wAAAP8AAAD/AAAA/wAKDzEAnP3WAKn//wCS/OgAf/8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQAAANwAAADtAAAA7QAAAMAAABUMAJn9gwCe/e0Aj/2LAP//AQAAAAAAAAAA
 [badge_release]: https://img.shields.io/github/release-pre/becksteinlab/imdclient.svg
 [url_actions]: https://github.com/becksteinlab/imdclient/actions?query=branch%3Amain+workflow%3Agh-ci
 [url_codecov]: https://codecov.io/gh/becksteinlab/imdclient/branch/main
 [url_docs]: https://imdclient.readthedocs.io/en/latest/?badge=latest
 [url_latest_release]: https://github.com/becksteinlab/imdclient/releases
 [url_license]: https://opensource.org/license/mit
-[url_mda]: https://www.mdanalysis.org
 
 Receiver for [IMDv3 protocol](https://imdclient.readthedocs.io/en/latest/protocol_v3.html) from simulation engines like Gromacs, LAMMPS, and NAMD.
 
-IMDClient is bound by a [Code of Conduct](https://github.com/becksteinlab/imdreader/blob/main/CODE_OF_CONDUCT.md).
+IMDClient is bound by a [Code of Conduct](https://github.com/becksteinlab/imdclient/blob/main/CODE_OF_CONDUCT.md).
 
 ### Installation
 
-IMDClient is available via PyPi and can be installed with pip:
-```bash
+#### Install via mamba (recommended)
+To install the latest release of IMDClient from conda-forge:
+
+```
+mamba install -c conda-forge imdclient
+```
+
+#### Install via pip
+To install the latest release of IMDClient from PyPI:
+
+```
 pip install imdclient
 ```
 
-To build IMDClient from source,
-we highly recommend using virtual environments.
-If possible, we strongly recommend that you use
-[Anaconda](https://docs.conda.io/en/latest/) as your package manager.
-Below we provide instructions both for `conda` and
-for `pip`.
+---
 
-#### With conda
+### Building from Source
+To build IMDClient from source, we highly recommend using virtual environments.
+If possible, we recommend that you use [mamba](https://mamba.readthedocs.io/en/latest/) as your package manager through [miniforge](https://github.com/conda-forge/miniforge). (You can substitute `conda` for `mamba` in the commands below if you prefer.)
 
-Ensure that you have [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html) installed.
+Below we provide instructions both for `mamba` and for `pip`.
 
-Create a virtual environment and activate it:
+#### Source build with mamba
+1. Ensure you have [mamba](https://mamba.readthedocs.io/en/latest/installation/mamba-installation.html) installed.
+
+2. Create and activate a new environment:
 
 ```
-conda create --name imdclient
-conda activate imdclient
+mamba create --name imdclient
+mamba activate imdclient
 ```
 
-<!-- Install the development and documentation dependencies:
+3. (Recommended) Install all dependencies using the provided environment YAML files for a clean and reproducible environment:
 
 ```
-conda env update --name imdreader --file devtools/conda-envs/test_env.yaml
-conda env update --name imdreader --file docs/requirements.yaml
-``` -->
+mamba env update --name imdclient --file devtools/conda-envs/test_env.yaml
+mamba env update --name imdclient --file docs/requirements.yaml
+```
 
-Build this package from source:
+4. Build and install IMDClient in editable mode:
 
 ```
 pip install -e .
 ```
 
-If you want to update your dependencies (which can be risky!), run:
+5. (Optional) Update dependencies:
 
 ```
-conda update --all
+mamba update --all
 ```
 
-And when you are finished, you can exit the virtual environment with:
+6. Deactivate the environment when finished:
 
 ```
-conda deactivate
+mamba deactivate
 ```
 
-#### With pip
+#### Source build with pip
 
-To build the package from source, run:
+1. (Optional) Create and activate a virtual environment:
+
+```
+python -m venv venv
+source venv/bin/activate
+```
+
+2. Install IMDClient from source:
 
 ```
 pip install .
 ```
 
-If you want to create a development environment, install
-the dependencies required for tests and docs with:
+3. (Optional) For development (tests and docs):
 
 ```
 pip install ".[test,doc]"
@@ -122,11 +142,12 @@ pip install ".[test,doc]"
 The IMDClient source code is hosted at https://github.com/becksteinlab/imdclient
 and is available under the MIT license (see the file [LICENSE](https://github.com/becksteinlab/imdclient/blob/main/LICENSE)).
 
-Copyright (c) 2024, Lawson
+Copyright (c) 2024-2025, imdclient [AUTHORS](https://github.com/Becksteinlab/imdclient/blob/main/AUTHORS.md)
 
 
 #### Acknowledgements
  
 Project based on the 
 [MDAnalysis Cookiecutter](https://github.com/MDAnalysis/cookiecutter-mda) version 0.1.
-<!-- Please cite [MDAnalysis](https://github.com/MDAnalysis/mdanalysis#citation) when using IMDReader in published work. --> 
+
+**If you use IMDClient in your research, please cite [IMDClient](https://github.com/Becksteinlab/imdclient) in your publications.**