pack-mm 0.0.15__py3-none-any.whl → 0.0.20__py3-none-any.whl

pack_mm/cli/packmm.py

@@ -52,30 +52,28 @@ def packmm(
     ),
     centre: str | None = typer.Option(
         None,
-        help="""Centre of the insertion zone in fractional coordinates,
-        e.g., '0.12,0.4,0.5'.""",
+        help="""Centre of the insertion zone, coordinates in Å,
+        e.g., '5.0, 5.0, 5.0'.""",
     ),
     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."
-    ),
+    height: float | None = typer.Option(None, help="Height of the cylinder in Å."),
     a: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     b: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     c: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     device: str = typer.Option(
@@ -86,15 +84,22 @@ def packmm(
     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."),
+    cell_a: float = typer.Option(
+        20.0, help="Side of the empty box along the x-axis in Å."
+    ),
+    cell_b: float = typer.Option(
+        20.0, help="Side of the empty box along the y-axis in Å."
+    ),
+    cell_c: float = typer.Option(
+        20.0, help="Side of the empty box along the z-axis in Å."
+    ),
     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."
     ),
+    out_path: str = typer.Option(".", help="path to save various outputs."),
 ):
     """Pack molecules into a system based on the specified parameters."""
     print("Script called with following input")
@@ -119,6 +124,7 @@ def packmm(
     print(f"{temperature=}")
     print(f"{fmax=}")
     print(f"{geometry=}")
+    print(f"{out_path=}")
     if nmols == -1:
         print("nothing to do, no molecule to insert")
         raise typer.Exit(0)
@@ -151,9 +157,10 @@ def packmm(
         ntries=ntries,
         fmax=fmax,
         geometry=geometry,
-        ca=cell_a,
-        cb=cell_b,
-        cc=cell_c,
+        cell_a=cell_a,
+        cell_b=cell_b,
+        cell_c=cell_c,
+        out_path=out_path,
     )
 
 

pack_mm/core/core.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from ase import Atoms
 from ase.build import molecule as build_molecule
 from ase.io import read, write
+from ase.units import kB
 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
@@ -138,28 +139,29 @@ def validate_value(label, x):
 
 
 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:
+    system: str = None,
+    molecule: str = "H2O",
+    nmols: int = -1,
+    arch: str = "cpu",
+    model: str = "mace_mp",
+    device: str = "medium-omat-0",
+    where: str = "anywhere",
+    center: tuple[float, float, float] = None,
+    radius: float = None,
+    height: float = None,
+    a: float = None,
+    b: float = None,
+    c: float = None,
+    seed: int = 2025,
+    temperature: float = 300.0,
+    ntries: int = 50,
+    geometry: bool = False,
+    fmax: float = 0.1,
+    cell_a: float = None,
+    cell_b: float = None,
+    cell_c: float = None,
+    out_path: str = ".",
+) -> float:
     """
     Pack molecules into a system based on the specified parameters.
 
@@ -181,9 +183,10 @@ def pack_molecules(
         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.
+        cell_a, cell_b, cell_c (float): Cell dimensions if system is empty.
+        out_path (str): path to save various outputs
     """
-    kbt = temperature * 8.6173303e-5  # Boltzmann constant in eV/K
+    kbt = temperature * kB
     validate_value("temperature", temperature)
     validate_value("radius", radius)
     validate_value("height", height)
@@ -193,10 +196,10 @@ def pack_molecules(
     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("cell box cell a", cell_a)
+    validate_value("cell box cell b", cell_b)
     validate_value("nmols", nmols)
-    validate_value("cell box c", cc)
+    validate_value("cell box cell c", cell_c)
 
     random.seed(seed)
 
@@ -204,25 +207,21 @@ def pack_molecules(
         sys = read(system)
         sysname = Path(system).stem
     except Exception:
-        sys = Atoms(cell=[ca, cb, cc], pbc=[True, True, True])
+        sys = Atoms(cell=[cell_a, cell_b, cell_c], pbc=[True, True, True])
         sysname = "empty"
 
     cell = sys.cell.lengths()
 
-    # Print initial information
+    # Print summary
     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
+        a, b, c = cell[0], cell[1], cell[2]
     elif where == "sphere":
         if radius is None:
             radius = min(cell) * 0.5
@@ -230,20 +229,22 @@ def pack_molecules(
         if radius is None:
             if where == "cylinderZ":
                 radius = min(cell[0], cell[1]) * 0.5
+                if height is None:
+                    height = 0.5 * cell[2]
             elif where == "cylinderY":
                 radius = min(cell[0], cell[2]) * 0.5
+                if height is None:
+                    height = 0.5 * cell[1]
             elif where == "cylinderX":
                 radius = min(cell[2], cell[1]) * 0.5
-        if height is None:
-            height = 0.5
+                if height is None:
+                    height = 0.5 * cell[0]
     elif where == "box":
-        a, b, c = a or 1, b or 1, c or 1
+        a, b, c = a or cell[0], b or cell[1], c or cell[2]
     elif where == "ellipsoid":
-        a, b, c = a or 0.5, b or 0.5, c or 0.5
+        a, b, c = a or cell[0], b or cell[1], c or cell[2]
 
-    calc = choose_calculator(
-        arch=arch, model_path=model, device=device, default_dtype="float64"
-    )
+    calc = choose_calculator(arch=arch, model_path=model, device=device)
     sys.calc = calc
 
     e = sys.get_potential_energy() if len(sys) > 0 else 0.0
@@ -253,7 +254,7 @@ def pack_molecules(
         accept = False
         for _itry in range(ntries):
             mol = load_molecule(molecule)
-            tv = get_insertion_position(where, center, cell, a, b, c, radius, height)
+            tv = get_insertion_position(where, center, a, b, c, radius, height)
             mol = rotate_molecule(mol)
             mol.translate(tv)
 
@@ -274,18 +275,31 @@ def pack_molecules(
             csys = tsys.copy()
             e = en
             print(f"Inserted particle {i + 1}")
-            write(f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
+            write(Path(out_path) / f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
         else:
+            # Things are bad, maybe geomatry optimisation saves us
             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
+            _ = optimize_geometry(
+                f"{sysname}+{i + 1}{Path(molecule).stem}.cif",
+                device,
+                arch,
+                model,
+                fmax,
+                out_path,
             )
+    energy_final = e
 
     # Perform final geometry optimization if requested
     if geometry:
-        optimize_geometry(
-            f"{sysname}+{nmols}{Path(molecule).stem}.cif", device, arch, model, fmax
+        energy_final = optimize_geometry(
+            f"{sysname}+{nmols}{Path(molecule).stem}.cif",
+            device,
+            arch,
+            model,
+            fmax,
+            out_path,
         )
+    return energy_final
 
 
 def load_molecule(molecule: str):
@@ -299,25 +313,24 @@ def load_molecule(molecule: str):
 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,
+    a: float = None,
+    b: float = None,
+    c: float = None,
+    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)
+        return random_point_in_box(center, a, b, c)
     if where == "ellipsoid":
-        return random_point_in_ellipsoid(center, cell[0] * a, cell[1] * b, cell[2] * c)
+        return random_point_in_ellipsoid(center, a, b, c)
     if where in ["cylinderZ", "cylinderY", "cylinderX"]:
         axis = where[-1].lower()
-        return random_point_in_cylinder(center, radius, cell[2] * height, axis)
+        return random_point_in_cylinder(center, radius, height, axis)
     # now is anywhere
-    return random.random(3) * [a, b, c] * cell
+    return random.random(3) * [a, b, c]
 
 
 def rotate_molecule(mol):
@@ -330,16 +343,21 @@ def rotate_molecule(mol):
 
 
 def optimize_geometry(
-    struct_path: str, device: str, arch: str, model: str, fmax: float
+    struct_path: str,
+    device: str,
+    arch: str,
+    model: str,
+    fmax: float,
+    out_path: str = ".",
 ) -> 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"},
+        calc_kwargs={"model_paths": model},
         filter_kwargs={"hydrostatic_strain": True},
     )
     geo.run()
-    write(f"{struct_path}-opt.cif", geo.struct)
+    write(Path(out_path) / f"{Path(struct_path).stem}-opt.cif", geo.struct)
     return geo.struct.get_potential_energy()

pack_mm-0.0.20.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.1
+Name: pack-mm
+Version: 0.0.20
+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
+
+[![Python versions][python-badge]][python-link]
+[![Build Status][ci-badge]][ci-link]
+[![Coverage Status][cov-badge]][cov-link]
+[![License][license-badge]][license-link]
+
+# what is packmm
+
+packmm is a simple python package that allows to build atomistic and molecular
+systems which are of interest for materials and molecular modelling.
+
+It tries to generate realistic starting configuration by employing machine learnt
+interatomic potential for describing interactions between atoms and Monte Carlo,
+Molecular Dynamics and hybrid Monte Carlo.
+
+It provides both a cli and a python api, with some examples below.
+
+## Quick install
+
+```bash
+
+   uv pip install pack-mm
+
+```
+or install the lates
+
+```bash
+
+  uv pip install git+https://github.com/ddmms/pack-mm.git
+
+```
+
+## CLI examples
+
+
+### MOF in spherical pocket
+
+```bash
+
+   packmm --system examples/data/UiO-66.cif --molecule H2O --nmols 10  --where sphere --centre 10.0,10.0,10.0 --radius 5.0 --geometry
+
+```
+
+![](examples/pics/UiO66water.png)
+
+### Zeolite in cylindrical channel
+
+
+```bash
+
+   packmm --system examples/data/MFI.cif --molecule H2O --nmols 30  --where cylinderY --centre 10.0,10.0,13.0 --radius 3.5 --height 19.00  --no-geometry
+
+```
+
+![](examples/pics/MFIwater.png)
+
+### NaCl on surface
+
+```bash
+   packmm --system examples/data/NaCl.cif --molecule H2O --nmols 30  --where box --centre 8.5,8.5,16.0 --a 16.9 --b 16.9 --c 7.5 --no-geometry
+
+```
+
+![](examples/pics/NaClwater.png)
+
+### MOF ellipsoid
+
+first add a methanol
+
+```bash
+
+packmm --system examples/data/Cu2L.cif --molecule examples/data/Ethanol.xyz --nmols 1  --where sphere --centre 5.18,8.15,25.25 --radius 1 --model small-0b2 --geometry
+
+```
+
+!()[examples/pics/Cu2L-ethanol.png]
+
+``` bash
+
+packmm --system Cu2L-ethanol.cif --molecule H2O --nmols 10  --where ellipsoid --centre 5.18,8.15,25.25 --a 5.18 --b 8.15 --c 8.25 --no-geometry --model small-0b2
+
+
+```
+
+!()[examples/pics/Cu2l-ethanol-water.png]
+
+### Liquid water
+
+```bash
+
+packmm --molecule H2O --nmols 33  --where anywhere  --cell-a 10.0 --cell-b 10.0 --cell-c 10.0  --model small-0b2
+
+
+```
+
+!()[examples/pics/water.png]
+### interstitials
+
+```bash
+
+packmm --system Pd-super.cif --molecule H2 --nmols 50  --where anywhere   --model small-0b2
+
+```
+
+before optimisation
+
+!()[examples/pics/Pd-H2-noopt.png]
+
+
+after optimisation
+
+!()[examples/pics/Pd-H2.png]
+
+
+
+### full list of options
+
+```bash
+
+  packmm --help
+
+   Usage: packmm [OPTIONS]
+
+ Pack molecules into a system based on the specified parameters.
+
+╭─ Options ────────────────────────────────────────────────────────────────────────────────────────╮
+│ --system                                 TEXT                        The original box in which   │
+│                                                                      you want to add particles.  │
+│                                                                      If not provided, an empty   │
+│                                                                      box will be created.        │
+│                                                                      [default: None]             │
+│ --molecule                               TEXT                        Name of the molecule to be  │
+│                                                                      processed, ASE-recognizable │
+│                                                                      or ASE-readable file.       │
+│                                                                      [default: H2O]              │
+│ --nmols                                  INTEGER                     Target number of molecules  │
+│                                                                      to insert.                  │
+│                                                                      [default: -1]               │
+│ --ntries                                 INTEGER                     Maximum number of attempts  │
+│                                                                      to insert each molecule.    │
+│                                                                      [default: 50]               │
+│ --seed                                   INTEGER                     Random seed for             │
+│                                                                      reproducibility.            │
+│                                                                      [default: 2025]             │
+│ --where                                  [anywhere|sphere|box|cylin  Where to insert the         │
+│                                          derZ|cylinderY|cylinderX|e  molecule. Choices:          │
+│                                          llipsoid]                   'anywhere', 'sphere',       │
+│                                                                      'box', 'cylinderZ',         │
+│                                                                      'cylinderY', 'cylinderX',   │
+│                                                                      'ellipsoid'.                │
+│                                                                      [default: anywhere]         │
+│ --centre                                 TEXT                        Centre of the insertion     │
+│                                                                      zone, coordinates in Å,     │
+│                                                                      e.g., '5.0, 5.0, 5.0'.      │
+│                                                                      [default: None]             │
+│ --radius                                 FLOAT                       Radius of the sphere or     │
+│                                                                      cylinder in Å, depending on │
+│                                                                      the insertion volume.       │
+│                                                                      [default: None]             │
+│ --height                                 FLOAT                       Height of the cylinder in   │
+│                                                                      Å.                          │
+│                                                                      [default: None]             │
+│ --a                                      FLOAT                       Side of the box or          │
+│                                                                      semi-axis of the ellipsoid, │
+│                                                                      in Å, depends on the        │
+│                                                                      insertion method.           │
+│                                                                      [default: None]             │
+│ --b                                      FLOAT                       Side of the box or          │
+│                                                                      semi-axis of the ellipsoid, │
+│                                                                      in Å, depends on the        │
+│                                                                      insertion method.           │
+│                                                                      [default: None]             │
+│ --c                                      FLOAT                       Side of the box or          │
+│                                                                      semi-axis of the ellipsoid, │
+│                                                                      in Å, depends on the        │
+│                                                                      insertion method.           │
+│                                                                      [default: None]             │
+│ --device                                 TEXT                        Device to run calculations  │
+│                                                                      on (e.g., 'cpu' or 'cuda'). │
+│                                                                      [default: cpu]              │
+│ --model                                  TEXT                        ML model to use.            │
+│                                                                      [default: medium-omat-0]    │
+│ --arch                                   TEXT                        MLIP architecture to use.   │
+│                                                                      [default: mace_mp]          │
+│ --temperature                            FLOAT                       Temperature for the Monte   │
+│                                                                      Carlo acceptance rule.      │
+│                                                                      [default: 300.0]            │
+│ --cell-a                                 FLOAT                       Side of the empty box along │
+│                                                                      the x-axis in Å.            │
+│                                                                      [default: 20.0]             │
+│ --cell-b                                 FLOAT                       Side of the empty box along │
+│                                                                      the y-axis in Å.            │
+│                                                                      [default: 20.0]             │
+│ --cell-c                                 FLOAT                       Side of the empty box along │
+│                                                                      the z-axis in Å.            │
+│                                                                      [default: 20.0]             │
+│ --fmax                                   FLOAT                       force tollerance for        │
+│                                                                      optimisation if needed.     │
+│                                                                      [default: 0.1]              │
+│ --geometry              --no-geometry                                Perform geometry            │
+│                                                                      optimization at the end.    │
+│                                                                      [default: geometry]         │
+│ --out-path                               TEXT                        path to save various        │
+│                                                                      outputs.                    │
+│                                                                      [default: .]                │
+│ --install-completion                                                 Install completion for the  │
+│                                                                      current shell.              │
+│ --show-completion                                                    Show completion for the     │
+│                                                                      current shell, to copy it   │
+│                                                                      or customize the            │
+│                                                                      installation.               │
+│ --help                                                               Show this message and exit. │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+
+```
+
+
+[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.20.dist-info/RECORD

@@ -0,0 +1,8 @@
+pack_mm-0.0.20.dist-info/METADATA,sha256=8SHz3ITnBQfnGDQEkjDgb7bLEutNK4DVFuVUvnfz-QI,13498
+pack_mm-0.0.20.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+pack_mm-0.0.20.dist-info/entry_points.txt,sha256=ajKA2oehIa_LCVCP2XTRxV0VNgjGl9c2wYkwk0BasrQ,66
+pack_mm-0.0.20.dist-info/licenses/LICENSE,sha256=ZOYkPdn_vQ8wYJqZnjesow79F_grMbVlHcJ9V91G1pE,1100
+pack_mm/__init__.py,sha256=ct7qfCmTDwhLYip6JKYWRLasmmaGYt0ColbK0CpvYZk,150
+pack_mm/cli/packmm.py,sha256=VqumDT_f1Nf1LCZ1WsF5D6MoLmKEQPEimYenibQHIU4,4944
+pack_mm/core/core.py,sha256=vNMQOVDIXyRCUWosww9sSHUxwqbjPRk5JLsb9muwpVA,11369
+pack_mm-0.0.20.dist-info/RECORD,,

pack_mm-0.0.15.dist-info/METADATA

@@ -1,36 +0,0 @@
-Metadata-Version: 2.1
-Name: pack-mm
-Version: 0.0.15
-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.15.dist-info/RECORD

@@ -1,8 +0,0 @@
-pack_mm-0.0.15.dist-info/METADATA,sha256=1QZ14qnSQmoH2FqowGHIjojlZSEnDnRaJ_WAYFmrojg,1583
-pack_mm-0.0.15.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-pack_mm-0.0.15.dist-info/entry_points.txt,sha256=ajKA2oehIa_LCVCP2XTRxV0VNgjGl9c2wYkwk0BasrQ,66
-pack_mm-0.0.15.dist-info/licenses/LICENSE,sha256=ZOYkPdn_vQ8wYJqZnjesow79F_grMbVlHcJ9V91G1pE,1100
-pack_mm/__init__.py,sha256=ct7qfCmTDwhLYip6JKYWRLasmmaGYt0ColbK0CpvYZk,150
-pack_mm/cli/packmm.py,sha256=FWiBUQBG6Z5Vi5A1VH9DYUn8iBwIs4NbFR5a8mPtEpM,4797
-pack_mm/core/core.py,sha256=gP8j1NJg3_8dj4it3V2Z80dbAKhy0emwUjd_-wuKvws,10839
-pack_mm-0.0.15.dist-info/RECORD,,