pack-mm 0.0.14__tar.gz

pack_mm-0.0.14/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 data-driven materials and molecular science
+
+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.

pack_mm-0.0.14/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: pack-mm
+Version: 0.0.14
+Summary: packing materials and molecules in boxes using for machine learnt interatomic potentials
+Author: Alin M. Elena
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Development Status :: 3 - Alpha
+Project-URL: Repository, https://github.com/ddmms/pack-mm/
+Project-URL: Documentation, https://ddmms.github.io/pack-mm/
+Requires-Python: >=3.10
+Requires-Dist: janus-core>=0.7.2
+Requires-Dist: typer<1.0.0,>=0.12.5
+Requires-Dist: typer-config<2.0.0,>=1.4.2
+Description-Content-Type: text/markdown
+
+# pack materials and molecules
+
+[![Python versions][python-badge]][python-link]
+[![Build Status][ci-badge]][ci-link]
+[![Coverage Status][cov-badge]][cov-link]
+[![License][license-badge]][license-link]
+
+[python-badge]: https://img.shields.io/pypi/pyversions/pack-mm.svg
+[python-link]: https://pypi.org/project/pack-mm/
+[ci-badge]: https://github.com/ddmms/pack-mm/actions/workflows/build.yml/badge.svg?branch=main
+[ci-link]: https://github.com/ddmms/pack-mm/actions
+[cov-badge]: https://coveralls.io/repos/github/ddmms/pack-mm/badge.svg?branch=main
+[cov-link]: https://coveralls.io/github/ddmms/pack-mm?branch=main
+[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-link]: https://opensource.org/license/MIT

pack_mm-0.0.14/README.md

@@ -0,0 +1,15 @@
+# pack materials and molecules
+
+[![Python versions][python-badge]][python-link]
+[![Build Status][ci-badge]][ci-link]
+[![Coverage Status][cov-badge]][cov-link]
+[![License][license-badge]][license-link]
+
+[python-badge]: https://img.shields.io/pypi/pyversions/pack-mm.svg
+[python-link]: https://pypi.org/project/pack-mm/
+[ci-badge]: https://github.com/ddmms/pack-mm/actions/workflows/build.yml/badge.svg?branch=main
+[ci-link]: https://github.com/ddmms/pack-mm/actions
+[cov-badge]: https://coveralls.io/repos/github/ddmms/pack-mm/badge.svg?branch=main
+[cov-link]: https://coveralls.io/github/ddmms/pack-mm?branch=main
+[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-link]: https://opensource.org/license/MIT

pack_mm-0.0.14/pack_mm/__init__.py

@@ -0,0 +1,7 @@
+"""Pack molecules in various shapes."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__version__ = version("pack-mm")

pack_mm-0.0.14/pack_mm/cli/packmm.py

@@ -0,0 +1,161 @@
+"""Command line for packmm."""
+
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 22-02-2025
+# ©alin m elena,
+from __future__ import annotations
+
+from enum import Enum
+
+import typer
+
+from pack_mm.core.core import pack_molecules
+
+
+class InsertionMethod(str, Enum):
+    """Insertion options."""
+
+    ANYWHERE = "anywhere"
+    SPHERE = "sphere"
+    BOX = "box"
+    CYLINDER_Z = "cylinderZ"
+    CYLINDER_Y = "cylinderY"
+    CYLINDER_X = "cylinderX"
+    ELLIPSOID = "ellipsoid"
+
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command()
+def packmm(
+    system: str | None = typer.Option(
+        None,
+        help="""The original box in which you want to add particles.
+        If not provided, an empty box will be created.""",
+    ),
+    molecule: str = typer.Option(
+        "H2O",
+        help="""Name of the molecule to be processed, ASE-recognizable or
+        ASE-readable file.""",
+    ),
+    nmols: int = typer.Option(-1, help="Target number of molecules to insert."),
+    ntries: int = typer.Option(
+        50, help="Maximum number of attempts to insert each molecule."
+    ),
+    seed: int = typer.Option(2025, help="Random seed for reproducibility."),
+    where: InsertionMethod = typer.Option(
+        InsertionMethod.ANYWHERE,
+        help="""Where to insert the molecule. Choices: 'anywhere', 'sphere',
+        'box', 'cylinderZ', 'cylinderY', 'cylinderX', 'ellipsoid'.""",
+    ),
+    centre: str | None = typer.Option(
+        None,
+        help="""Centre of the insertion zone in fractional coordinates,
+        e.g., '0.12,0.4,0.5'.""",
+    ),
+    radius: float | None = typer.Option(
+        None,
+        help="""Radius of the sphere or cylinder in Å,
+        depending on the insertion volume.""",
+    ),
+    height: float | None = typer.Option(
+        None, help="Height of the cylinder in fractional coordinates."
+    ),
+    a: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    b: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    c: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    device: str = typer.Option(
+        "cpu", help="Device to run calculations on (e.g., 'cpu' or 'cuda')."
+    ),
+    model: str = typer.Option("medium-omat-0", help="ML model to use."),
+    arch: str = typer.Option("mace_mp", help="MLIP architecture to use."),
+    temperature: float = typer.Option(
+        300.0, help="Temperature for the Monte Carlo acceptance rule."
+    ),
+    cell_a: float = typer.Option(20.0, help="Side of the empty box along the x-axis."),
+    cell_b: float = typer.Option(20.0, help="Side of the empty box along the y-axis."),
+    cell_c: float = typer.Option(20.0, help="Side of the empty box along the z-axis."),
+    fmax: float = typer.Option(
+        0.1, help="force tollerance for optimisation if needed."
+    ),
+    geometry: bool = typer.Option(
+        True, help="Perform geometry optimization at the end."
+    ),
+):
+    """Pack molecules into a system based on the specified parameters."""
+    print("Script called with following input")
+    print(f"{system=}")
+    print(f"{nmols=}")
+    print(f"{molecule=}")
+    print(f"{ntries=}")
+    print(f"{seed=}")
+    print(f"where={where.value}")
+    print(f"{centre=}")
+    print(f"{radius=}")
+    print(f"{height=}")
+    print(f"{a=}")
+    print(f"{b=}")
+    print(f"{c=}")
+    print(f"{cell_a=}")
+    print(f"{cell_b=}")
+    print(f"{cell_c=}")
+    print(f"{arch=}")
+    print(f"{model=}")
+    print(f"{device=}")
+    print(f"{temperature=}")
+    print(f"{fmax=}")
+    print(f"{geometry=}")
+    if nmols == -1:
+        print("nothing to do, no molecule to insert")
+        raise typer.Exit(0)
+
+    center = centre
+    if centre:
+        center = tuple(map(float, centre.split(",")))
+        lc = [x < 0.0 for x in center]
+        if len(center) != 3 or any(lc):
+            err = "Invalid centre 3 coordinates expected!"
+            print(f"{err}")
+            raise Exception("Invalid centre 3 coordinates expected!")
+
+    pack_molecules(
+        system=system,
+        molecule=molecule,
+        nmols=nmols,
+        arch=arch,
+        model=model,
+        device=device,
+        where=where,
+        center=center,
+        radius=radius,
+        height=height,
+        a=a,
+        b=b,
+        c=c,
+        seed=seed,
+        temperature=temperature,
+        ntries=ntries,
+        fmax=fmax,
+        geometry=geometry,
+        ca=cell_a,
+        cb=cell_b,
+        cc=cell_c,
+    )
+
+
+if __name__ == "__main__":
+    app()

pack_mm-0.0.14/pack_mm/core/core.py

@@ -0,0 +1,345 @@
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 16-11-2024
+# ©alin m elena,
+"""pack molecules inside various shapes."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ase import Atoms
+from ase.build import molecule as build_molecule
+from ase.io import read, write
+from janus_core.calculations.geom_opt import GeomOpt
+from janus_core.helpers.mlip_calculators import choose_calculator
+from numpy import cos, exp, pi, random, sin, sqrt
+
+
+def random_point_in_sphere(c: (float, float, float), r: float) -> (float, float, float):
+    """
+    Generate a random point inside a sphere of radius r, centered at c.
+
+    Parameters
+    ----------
+        c (tuple): The center of the sphere as (x, y, z).
+        r (float): The radius of the sphere.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the sphere.
+    """
+    rad = r * random.rand() ** (1 / 3)
+
+    theta = random.uniform(0, 2 * pi)
+    phi = random.uniform(0, pi)
+
+    x = c[0] + rad * sin(phi) * cos(theta)
+    y = c[1] + rad * sin(phi) * sin(theta)
+    z = c[2] + rad * cos(phi)
+
+    return (x, y, z)
+
+
+def random_point_in_ellipsoid(
+    d: (float, float, float), a: float, b: float, c: float
+) -> (float, float, float):
+    """
+    Generate a random point inside an ellipsoid with axes a, b, c, centered at d.
+
+    Parameters
+    ----------
+        d (tuple): The center of the ellipsoid as (x, y, z).
+        a (float): The semi-axis length of the ellipsoid along the x-axis.
+        b (float): The semi-axis length of the ellipsoid along the y-axis.
+        c (float): The semi-axis length of the ellipsoid along the z-axis.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the ellipsoid.
+    """
+    theta = random.uniform(0, 2 * pi)
+    phi = random.uniform(0, pi)
+    rad = random.rand() ** (1 / 3)
+
+    x = d[0] + a * rad * sin(phi) * cos(theta)
+    y = d[1] + b * rad * sin(phi) * sin(theta)
+    z = d[2] + c * rad * cos(phi)
+
+    return (x, y, z)
+
+
+def random_point_in_box(
+    d: (float, float, float), a: float, b: float, c: float
+) -> (float, float, float):
+    """
+    Generate a random point inside a box with sides a, b, c, centered at d.
+
+    Parameters
+    ----------
+        d (tuple): The center of the box as (x, y, z).
+        a (float): The length of the box along the x-axis.
+        b (float): The length of the box along the y-axis.
+        c (float): The length of the box along the z-axis.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the box.
+    """
+    x = d[0] + random.uniform(-a * 0.5, a * 0.5)
+    y = d[1] + random.uniform(-b * 0.5, b * 0.5)
+    z = d[2] + random.uniform(-c * 0.5, c * 0.5)
+
+    return (x, y, z)
+
+
+def random_point_in_cylinder(
+    c: (float, float, float), r: float, h: float, d: str
+) -> (float, float, float):
+    """
+    Generate a random point inside a cylinder with radius r and height h, centered at c.
+
+    Parameters
+    ----------
+        c (tuple): The center of the cylinder as (x, y, z).
+        r (float): The radius of the cylinder's base.
+        h (float): The height of the cylinder.
+        direction (str): direction along which cylinger is oriented
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the cylinder.
+    """
+    theta = random.uniform(0, 2 * pi)
+    rad = r * sqrt(random.rand())
+
+    if d == "z":
+        z = c[2] + random.uniform(-h * 0.5, h * 0.5)
+        x = c[0] + rad * cos(theta)
+        y = c[1] + rad * sin(theta)
+    elif d == "y":
+        y = c[1] + random.uniform(-h * 0.5, h * 0.5)
+        x = c[0] + rad * cos(theta)
+        z = c[2] + rad * sin(theta)
+    elif d == "x":
+        x = c[0] + random.uniform(-h * 0.5, h * 0.5)
+        y = c[1] + rad * sin(theta)
+        z = c[2] + rad * cos(theta)
+
+    return (x, y, z)
+
+
+def validate_value(label, x):
+    """Validate input value, and raise an exception."""
+    if x is not None and x < 0.0:
+        err = f"Invalid {label}, needs to be positive"
+        print(err)
+        raise Exception(err)
+
+
+def pack_molecules(
+    system: str | None,
+    molecule: str,
+    nmols: int,
+    arch: str,
+    model: str,
+    device: str,
+    where: str,
+    center: tuple[float, float, float] | None,
+    radius: float | None,
+    height: float | None,
+    a: float | None,
+    b: float | None,
+    c: float | None,
+    seed: int,
+    temperature: float,
+    ntries: int,
+    geometry: bool,
+    fmax: float,
+    ca: float,
+    cb: float,
+    cc: float,
+) -> None:
+    """
+    Pack molecules into a system based on the specified parameters.
+
+    Parameters
+    ----------
+        system (str): Path to the system file or name of the system.
+        molecule (str): Path to the molecule file or name of the molecule.
+        nmols (int): Number of molecules to insert.
+        arch (str): Architecture for the calculator.
+        model (str): Path to the model file.
+        device (str): Device to run calculations on (e.g., "cpu" or "cuda").
+        where (str): Region to insert molecules ("anywhere",
+                     "sphere", "cylinderZ", etc.).
+        center (Optional[Tuple[float, float, float]]): Center of the insertion region.
+        radius (Optional[float]): Radius for spherical or cylindrical insertion.
+        height (Optional[float]): Height for cylindrical insertion.
+        a, b, c (Optional[float]): Parameters for box or ellipsoid insertion.
+        seed (int): Random seed for reproducibility.
+        temperature (float): Temperature in Kelvin for acceptance probability.
+        ntries (int): Maximum number of attempts to insert each molecule.
+        geometry (bool): Whether to perform geometry optimization after insertion.
+        ca, cb, cc (float): Cell dimensions if system is empty.
+    """
+    kbt = temperature * 8.6173303e-5  # Boltzmann constant in eV/K
+    validate_value("temperature", temperature)
+    validate_value("radius", radius)
+    validate_value("height", height)
+    validate_value("fmax", fmax)
+    validate_value("seed", seed)
+    validate_value("box a", a)
+    validate_value("box b", b)
+    validate_value("box c", c)
+    validate_value("ntries", ntries)
+    validate_value("cell box a", ca)
+    validate_value("cell box b", cb)
+    validate_value("nmols", nmols)
+    validate_value("cell box c", cc)
+
+    random.seed(seed)
+
+    try:
+        sys = read(system)
+        sysname = Path(system).stem
+    except Exception:
+        sys = Atoms(cell=[ca, cb, cc], pbc=[True, True, True])
+        sysname = "empty"
+
+    cell = sys.cell.lengths()
+
+    # Print initial information
+    print(f"Inserting {nmols} {molecule} molecules in {sysname}.")
+    print(f"Using {arch} model {model} on {device}.")
+    print(f"Insert in {where}.")
+
+    # Set center of insertion region
+    if center is None:
+        center = (cell[0] * 0.5, cell[1] * 0.5, cell[2] * 0.5)
+    else:
+        center = tuple(ci * cell[i] for i, ci in enumerate(center))
+
+    # Set parameters based on insertion region
+    if where == "anywhere":
+        a, b, c = 1, 1, 1
+    elif where == "sphere":
+        if radius is None:
+            radius = min(cell) * 0.5
+    elif where in ["cylinderZ", "cylinderY", "cylinderX"]:
+        if radius is None:
+            if where == "cylinderZ":
+                radius = min(cell[0], cell[1]) * 0.5
+            elif where == "cylinderY":
+                radius = min(cell[0], cell[2]) * 0.5
+            elif where == "cylinderX":
+                radius = min(cell[2], cell[1]) * 0.5
+        if height is None:
+            height = 0.5
+    elif where == "box":
+        a, b, c = a or 1, b or 1, c or 1
+    elif where == "ellipsoid":
+        a, b, c = a or 0.5, b or 0.5, c or 0.5
+
+    calc = choose_calculator(
+        arch=arch, model_path=model, device=device, default_dtype="float64"
+    )
+    sys.calc = calc
+
+    e = sys.get_potential_energy() if len(sys) > 0 else 0.0
+
+    csys = sys.copy()
+    for i in range(nmols):
+        accept = False
+        for _itry in range(ntries):
+            mol = load_molecule(molecule)
+            tv = get_insertion_position(where, center, cell, a, b, c, radius, height)
+            mol = rotate_molecule(mol)
+            mol.translate(tv)
+
+            tsys = csys.copy() + mol.copy()
+            tsys.calc = calc
+            en = tsys.get_potential_energy()
+            de = en - e
+
+            acc = exp(-de / kbt)
+            u = random.random()
+            print(f"Old energy={e}, new energy={en}, {de=}, {acc=}, random={u}")
+
+            if u <= acc:
+                accept = True
+                break
+
+        if accept:
+            csys = tsys.copy()
+            e = en
+            print(f"Inserted particle {i + 1}")
+            write(f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
+        else:
+            print(f"Failed to insert particle {i + 1} after {ntries} tries")
+            optimize_geometry(
+                f"{sysname}+{i + 1}{Path(molecule).stem}.cif", device, arch, model, fmax
+            )
+
+    # Perform final geometry optimization if requested
+    if geometry:
+        optimize_geometry(
+            f"{sysname}+{nmols}{Path(molecule).stem}.cif", device, arch, model, fmax
+        )
+
+
+def load_molecule(molecule: str):
+    """Load a molecule from a file or build it."""
+    try:
+        return build_molecule(molecule)
+    except KeyError:
+        return read(molecule)
+
+
+def get_insertion_position(
+    where: str,
+    center: tuple[float, float, float],
+    cell: list[float],
+    a: float,
+    b: float,
+    c: float,
+    radius: float | None,
+    height: float | None,
+) -> tuple[float, float, float]:
+    """Get a random insertion position based on the region."""
+    if where == "sphere":
+        return random_point_in_sphere(center, radius)
+    if where == "box":
+        return random_point_in_box(center, cell[0] * a, cell[1] * b, cell[2] * c)
+    if where == "ellipsoid":
+        return random_point_in_ellipsoid(center, cell[0] * a, cell[1] * b, cell[2] * c)
+    if where in ["cylinderZ", "cylinderY", "cylinderX"]:
+        axis = where[-1].lower()
+        return random_point_in_cylinder(center, radius, cell[2] * height, axis)
+    # now is anywhere
+    return random.random(3) * [a, b, c] * cell
+
+
+def rotate_molecule(mol):
+    """Rotate a molecule randomly."""
+    ang = random.random(3)
+    mol.euler_rotate(
+        phi=ang[0] * 360, theta=ang[1] * 180, psi=ang[2] * 360, center=(0.0, 0.0, 0.0)
+    )
+    return mol
+
+
+def optimize_geometry(
+    struct_path: str, device: str, arch: str, model: str, fmax: float
+) -> float:
+    """Optimize the geometry of a structure."""
+    geo = GeomOpt(
+        struct_path=struct_path,
+        device=device,
+        fmax=fmax,
+        calc_kwargs={"model_paths": model, "default_dtype": "float64"},
+        filter_kwargs={"hydrostatic_strain": True},
+    )
+    geo.run()
+    write(f"{struct_path}-opt.cif", geo.struct)
+    return geo.struct.get_potential_energy()

pack_mm-0.0.14/pyproject.toml

@@ -0,0 +1,138 @@
+[project]
+name = "pack-mm"
+version = "0.0.14"
+description = "packing materials and molecules in boxes using for machine learnt interatomic potentials"
+authors = [
+    { name = "Alin M. Elena" },
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Development Status :: 3 - Alpha",
+]
+readme = "README.md"
+dependencies = [
+    "janus-core>=0.7.2",
+    "typer<1.0.0,>=0.12.5",
+    "typer-config<2.0.0,>=1.4.2",
+]
+
+[project.scripts]
+packmm = "pack_mm.cli.packmm:app"
+
+[project.urls]
+Repository = "https://github.com/ddmms/pack-mm/"
+Documentation = "https://ddmms.github.io/pack-mm/"
+
+[dependency-groups]
+dev = [
+    "coverage[toml]<8.0.0,>=7.4.1",
+    "ipykernel>=6.29.5",
+    "pgtest<2.0.0,>=1.3.2",
+    "pytest<9.0,>=8.0",
+    "pytest-cov<5.0.0,>=4.1.0",
+    "tox-uv<2.0,>=1.16.1",
+    "wheel<1.0,>=0.42",
+]
+docs = [
+    "furo<2025.0.0,>=2024.1.29",
+    "jupyter>=1.1.1",
+    "markupsafe<2.1",
+    "nbsphinx>=0.9.6",
+    "numpydoc<2.0.0,>=1.6.0",
+    "sphinx<9.0.0,>=8.0.2",
+    "sphinxcontrib-contentui<1.0.0,>=0.2.5",
+    "sphinxcontrib-details-directive<1.0,>=0.1",
+    "sphinx-autodoc-typehints<3.0.0,>=2.5.0",
+    "sphinx-collapse>=0.1.3",
+    "sphinx-copybutton<1.0.0,>=0.5.2",
+]
+pre-commit = [
+    "pre-commit<4.0.0,>=3.6.0",
+    "ruff<1.0.0,>=0.9.3",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[tool.pytest.ini_options]
+python_files = "test_*.py"
+addopts = "--cov-report xml"
+pythonpath = [
+    ".",
+]
+
+[tool.coverage.run]
+source = [
+    "pack_mm",
+]
+
+[tool.ruff]
+exclude = [
+    "conf.py",
+    "*ipynb",
+]
+target-version = "py310"
+
+[tool.ruff.lint]
+ignore = [
+    "C901",
+    "B008",
+]
+select = [
+    "B",
+    "C",
+    "R",
+    "D",
+    "E",
+    "W",
+    "F",
+    "FA",
+    "I",
+    "N",
+    "UP",
+]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = true
+required-imports = [
+    "from __future__ import annotations",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.pylint]
+max-args = 10
+
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = false
+
+[tool.numpydoc_validation]
+checks = [
+    "all",
+    "EX01",
+    "SA01",
+    "ES01",
+    "PR04",
+]
+exclude = [
+    ".__weakref__$",
+    ".__repr__$",
+]
+
+[tool.uv]
+default-groups = [
+    "dev",
+    "docs",
+    "pre-commit",
+]

pack_mm-0.0.14/tests/__init__.py

@@ -0,0 +1,7 @@
+"""Tests for pack me."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+TEST_DIR = Path(__file__).resolve().parent

pack_mm-0.0.14/tests/test_packmm.py

@@ -0,0 +1,206 @@
+"""Test cli for packmm."""
+
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 22-02-2025
+# ©alin m elena, GPL v3 https://www.gnu.org/licenses/gpl-3.0.en.html
+from __future__ import annotations
+
+from typer.testing import CliRunner
+
+from pack_mm.cli.packmm import app
+from tests.utils import strip_ansi_codes
+
+runner = CliRunner()
+
+
+def test_packmm_default_values():
+    """Check values."""
+    result = runner.invoke(app)
+    assert result.exit_code == 0
+    assert "nothing to do" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_molecule():
+    """Check molecule."""
+    result = runner.invoke(app, ["--molecule", "CO2"])
+    assert result.exit_code == 0
+    assert "CO2" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_nmols():
+    """Check nmols."""
+    result = runner.invoke(app, ["--nmols", "1"])
+    assert result.exit_code == 0
+    assert "nmols=1" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_ntries():
+    """Check ntries."""
+    result = runner.invoke(app, ["--ntries", "1"])
+    assert result.exit_code == 0
+    assert "ntries=1" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_seed():
+    """Check seed."""
+    result = runner.invoke(app, ["--seed", "1234"])
+    assert result.exit_code == 0
+    assert "seed=1234" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_insertion_method():
+    """Check insertion."""
+    result = runner.invoke(app, ["--where", "sphere"])
+    assert result.exit_code == 0
+    assert "where=sphere" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_center():
+    """Check centre."""
+    result = runner.invoke(app, ["--centre", "0.5,0.5,0.5"])
+    assert result.exit_code == 0
+    assert "centre='0.5,0.5,0.5'" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_radius():
+    """Check radius."""
+    result = runner.invoke(app, ["--radius", "10.0"])
+    assert result.exit_code == 0
+    assert "radius=10.0" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_height():
+    """Check height."""
+    result = runner.invoke(app, ["--height", "5.0"])
+    assert result.exit_code == 0
+    assert "height=5.0" in strip_ansi_codes(result.output)
+
+
+def test_packmm_mlip():
+    """Check mlip."""
+    result = runner.invoke(
+        app, ["--arch", "mace", "--model", "some", "--device", "cuda"]
+    )
+    assert result.exit_code == 0
+    assert "arch='mace'" in strip_ansi_codes(result.output)
+    assert "model='some'" in strip_ansi_codes(result.output)
+    assert "device='cuda'" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_box_dimensions():
+    """Check box."""
+    result = runner.invoke(app, ["--a", "30.0", "--b", "30.0", "--c", "30.0"])
+    assert result.exit_code == 0
+    assert "a=30.0" in strip_ansi_codes(result.output)
+    assert "b=30.0" in strip_ansi_codes(result.output)
+    assert "c=30.0" in strip_ansi_codes(result.output)
+
+
+def test_packmm_empty_box_dimensions():
+    """Check box empty."""
+    result = runner.invoke(
+        app, ["--cell-a", "30.0", "--cell-b", "30.0", "--cell-c", "30.0"]
+    )
+    assert result.exit_code == 0
+    assert "cell_a=30.0" in strip_ansi_codes(result.output)
+    assert "cell_b=30.0" in strip_ansi_codes(result.output)
+    assert "cell_c=30.0" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_temperature():
+    """Check temperature."""
+    result = runner.invoke(app, ["--temperature", "400.0"])
+    assert result.exit_code == 0
+    assert "temperature=400.0" in strip_ansi_codes(result.output)
+
+
+def test_packmm_custom_fmax():
+    """Check fmax."""
+    result = runner.invoke(app, ["--fmax", "0.05"])
+    assert result.exit_code == 0
+    assert "fmax=0.05" in strip_ansi_codes(result.output)
+
+
+def test_packmm_no_geometry_optimization():
+    """Check optimisation."""
+    result = runner.invoke(app, ["--no-geometry"])
+    assert result.exit_code == 0
+    assert "geometry=False" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_insertion_method():
+    """Check insertion."""
+    result = runner.invoke(app, ["--where", "invalid_method"])
+    assert result.exit_code != 0
+    assert "Invalid value for '--where'" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_centre_format():
+    """Check centre."""
+    result = runner.invoke(app, ["--nmols", "1", "--centre", "0.5,0.5"])
+    assert result.exit_code != 0
+    assert "Invalid centre" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_centre_value():
+    """Check centre."""
+    result = runner.invoke(app, ["--nmols", "1", "--centre", "-0.6,0.5,0.5"])
+    assert result.exit_code != 0
+    assert "Invalid centre" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_radius():
+    """Check box radius."""
+    result = runner.invoke(app, ["--nmols", "1", "--radius", "-10.0"])
+    assert result.exit_code != 0
+    assert "Invalid radius" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_height():
+    """Check box height."""
+    result = runner.invoke(app, ["--nmols", "1", "--height", "-5.0"])
+    assert result.exit_code != 0
+    assert "Invalid height" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_box_dimensions_a():
+    """Check box dimension."""
+    result = runner.invoke(app, ["--nmols", "1", "--a", "-30.0"])
+    assert result.exit_code != 0
+    assert "Invalid box a" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_box_dimensions_b():
+    """Check box dimension."""
+    result = runner.invoke(app, ["--nmols", "1", "--b", "-30.0"])
+    assert result.exit_code != 0
+    assert "Invalid box b" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_box_dimensions_c():
+    """Check box dimension."""
+    result = runner.invoke(app, ["--nmols", "1", "--c", "-30.0"])
+    assert result.exit_code != 0
+    assert "Invalid box c" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_temperature():
+    """Check temperature."""
+    result = runner.invoke(app, ["--nmols", "1", "--temperature", "-400.0"])
+    assert result.exit_code != 0
+    assert "Invalid temperature" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_fmax():
+    """Check fmax."""
+    result = runner.invoke(app, ["--nmols", "1", "--fmax", "-0.05"])
+    assert result.exit_code != 0
+    assert "Invalid fmax" in strip_ansi_codes(result.output)
+
+
+def test_packmm_invalid_ntries():
+    """Check ntries."""
+    result = runner.invoke(app, ["--nmols", "1", "--ntries", "-1"])
+    assert result.exit_code != 0
+    assert "Invalid ntries" in strip_ansi_codes(result.output)

pack_mm-0.0.14/tests/utils.py

@@ -0,0 +1,41 @@
+"""Utility functions for tests."""
+
+# lifted from janus_core github.com/stfc/janus-core/
+from __future__ import annotations
+
+import re
+
+
+def strip_ansi_codes(output: str) -> str:
+    """
+    Remove any ANSI sequences from output string.
+
+    Based on:
+    https://stackoverflow.com/questions/14693701/how-can-i-remove-the-ansi-escape-sequences-from-a-string-in-python/14693789#14693789
+
+    Parameters
+    ----------
+    output
+        Output that may contain ANSI sequences to be removed.
+
+    Returns
+    -------
+    str
+        Output with ANSI sequences removed.
+    """
+    # 7-bit C1 ANSI sequences
+    ansi_escape = re.compile(
+        r"""
+        \x1B  # ESC
+        (?:   # 7-bit C1 Fe (except CSI)
+            [@-Z\\-_]
+        |     # or [ for CSI, followed by a control sequence
+            \[
+            [0-?]*  # Parameter bytes
+            [ -/]*  # Intermediate bytes
+            [@-~]   # Final byte
+        )
+    """,
+        re.VERBOSE,
+    )
+    return ansi_escape.sub("", output)