molify 0.2.2__tar.gz → 0.2.4__tar.gz

molify-0.2.4/.github/workflows/build-wheels.yaml

@@ -0,0 +1,42 @@
+name: Build and upload to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v5
+      - name: Build sdist and wheel
+        run: uv build
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+
+  upload_pypi:
+    needs: [build]
+    environment:
+      name: pypi
+      url: https://pypi.org/p/molify
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' || (github.event_name == 'release' && github.event.action == 'published')
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{molify-0.2.2 → molify-0.2.4}/.gitignore

@@ -160,3 +160,8 @@ cython_debug/
 #.idea/
 tmp/
 .DS_Store
+
+# Git worktrees
+.worktrees/
+# hatch-vcs generated version file
+src/molify/_version.py

{molify-0.2.2 → molify-0.2.4}/.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
         additional_dependencies: ["tomli"]
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.7
+    rev: v0.14.14
     hooks:
       # Run the linter.
       - id: ruff

{molify-0.2.2 → molify-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: molify
-Version: 0.2.2
+Version: 0.2.4
 Summary: Molecular Structure Interface with RDKit, ASE, Packmol and NetworkX
 Project-URL: Repository, https://github.com/zincware/molify
 Project-URL: Releases, https://github.com/zincware/molify/releases

{molify-0.2.2 → molify-0.2.4}/paper/bibliography.bib

@@ -202,25 +202,24 @@
   urldate   = {2025-05-24}
 }
 @inproceedings{hagbergExploringNetworkStructure2008,
-  author    = {Aric A. Hagberg and Daniel A. Schult and Pieter J. Swart},
-  title     = {Exploring Network Structure, Dynamics, and Function using NetworkX},
-  booktitle = {Proceedings of the 7th Python in Science Conference},
-  pages     = {11 - 15},
-  address   = {Pasadena, CA USA},
-  year      = {2008},
-  editor    = {Ga\"el Varoquaux and Travis Vaught and Jarrod Millman}
+  author  = {Aric A. Hagberg and Daniel A. Schult and Pieter J. Swart},
+  year    = {2008},
+  month   = {06},
+  title   = {Exploring Network Structure, Dynamics, and Function Using NetworkX},
+  journal = {Proceedings of the 7th Python in Science Conference},
+  doi     = {10.25080/TCWV9851}
 }
 @article{oboyleOpenBabelOpen2011,
-  title = {Open {{Babel}}: {{An}} Open Chemical Toolbox},
+  title      = {Open {{Babel}}: {{An}} Open Chemical Toolbox},
   shorttitle = {Open {{Babel}}},
-  author = {O'Boyle, Noel M. and Banck, Michael and James, Craig A. and Morley, Chris and Vandermeersch, Tim and Hutchison, Geoffrey R.},
-  year = 2011,
-  month = oct,
-  journal = {Journal of Cheminformatics},
-  volume = {3},
-  number = {1},
-  pages = {33},
-  issn = {1758-2946},
-  doi = {10.1186/1758-2946-3-33},
-  urldate = {2025-11-15},
+  author     = {O'Boyle, Noel M. and Banck, Michael and James, Craig A. and Morley, Chris and Vandermeersch, Tim and Hutchison, Geoffrey R.},
+  year       = 2011,
+  month      = oct,
+  journal    = {Journal of Cheminformatics},
+  volume     = {3},
+  number     = {1},
+  pages      = {33},
+  issn       = {1758-2946},
+  doi        = {10.1186/1758-2946-3-33},
+  urldate    = {2025-11-15}
 }

{molify-0.2.2 → molify-0.2.4}/paper/paper.md

@@ -21,17 +21,17 @@ bibliography: bibliography.bib
 # Summary
 
 The increasing prevalence of Machine-Learned Interatomic Potentials (MLIPs) has shifted requirements for setting up atomistic simulations.
-Unlike classical force fields, MLIPs primarily require atomic positions and species, thereby removing the need for predefined topology files used for classical force fields in molecular dynamics software like GROMACS[@abrahamGROMACSHighPerformance2015], LAMMPS[@LAMMPS], ESPResSo[@weikESPResSo40Extensible2019], or OpenMM[@eastmanOpenMM8Molecular2024].
+Unlike classical force fields, MLIPs primarily require atomic positions and species, thereby removing the need for predefined topology files used for classical force fields in molecular dynamics software like GROMACS [@abrahamGROMACSHighPerformance2015], LAMMPS [@LAMMPS], ESPResSo [@weikESPResSo40Extensible2019], or OpenMM [@eastmanOpenMM8Molecular2024].
 Consequently, the Atomic Simulation Environment (ASE) [@larsenAtomicSimulationEnvironment2017] has become a popular Python toolkit for handling atomic structures and interfacing with MLIPs, particularly within the material science and soft matter communities.
 ASE originates from the electronic structure community, which shares the same setup as MLIP-driven studies.
 In contrast to _ab initio_, MLIPs are much faster and can run on much larger systems, making high-throughput simulations of more complex systems feasible and increasing the need for efficient initial structure generation.
 
-Concurrently, RDKit[@landrumRdkitRdkit2023_03_22023] offers extensive functionality for cheminformatics and manipulating chemical structures.
+Concurrently, RDKit [@landrumRdkitRdkit2023_03_22023] offers extensive functionality for cheminformatics and manipulating chemical structures.
 However, standard RDKit workflows are not designed for MLIP-driven simulation, while typical ASE-MLIP workflows may lack rich explicit chemical information such as bond orders or molecular identities, as well as capabilities for generating different conformations or searching substructures.
 
 The `molify` package bridges this gap, providing an interface between RDKit's chemical structure generation and cheminformatics capabilities and ASE's handling of 3D atomic structures.
-Furthermore, `molify` integrates with PACKMOL[@martinezPACKMOLPackageBuilding2009] to facilitate the creation of complex, periodic simulation cells with diverse chemical compositions, all while preserving crucial chemical connectivity information.
-In addition, `molify` simplifies the representation of molecular structures as graphs using NetworkX[@hagbergExploringNetworkStructure2008], e.g., enabling traversing or comparing them.
+Furthermore, `molify` integrates with PACKMOL [@martinezPACKMOLPackageBuilding2009] to facilitate the creation of complex, periodic simulation cells with diverse chemical compositions, all while preserving crucial chemical connectivity information.
+In addition, `molify` simplifies the representation of molecular structures as graphs using NetworkX [@hagbergExploringNetworkStructure2008], e.g., enabling traversing or comparing them.
 Lastly, the combination of these packages enables selection and manipulation of atomistic structures based on chemical knowledge rather than manual index handling.
 While designed for MLIP data, the usage of `molify` is not limited and can be expanded, e.g., by utilizing the bond order information in other ASE-based workflows for classical MD simulations or integrating with machine-learning driven bond order predictions.
 
@@ -41,17 +41,17 @@ While designed for MLIP data, the usage of `molify` is not limited and can be ex
 While its core function is to interface these tools, it thereby unlocks new capabilities and significantly reduces the manual coding and data wrangling typically required for preparing and analyzing molecular simulations.
 For example, ASE has no tools for handling topological information such as bonds or molecular identities, while RDKit cannot natively interface with MLIPs.
 
-`molify` simplifies workflows that previously involved laborious tasks such as sourcing individual structure files from various databases (e.g., the Materials Project[@jainCommentaryMaterialsProject2013] or the ZINC database[@tingleZINC22AFreeMultiBillionScale2023]) and custom setups of simulation cells.
+`molify` simplifies workflows that previously involved laborious tasks such as sourcing individual structure files from various databases (e.g., the Materials Project [@jainCommentaryMaterialsProject2013] or the ZINC database [@tingleZINC22AFreeMultiBillionScale2023]) and custom setups of simulation cells.
 With `molify`, more complex and chemically diverse simulation cells are easier to set up and process.
 
 One challenge in MLIP-driven simulations is the post-simulation identification and analysis of molecular fragments or chemical changes, as explicit topological information is not available and changes in connectivity can occur.
-`molify` addresses this by enabling the use of RDKit's powerful SMILES[@weiningerSMILESChemicalLanguage1988]/SMARTS-based substructure searching on ASE structures.
-In addition, the resulting molecular graph can be exported to a NetworkX[@hagbergExploringNetworkStructure2008] object for further analysis.
-This selection and handling allows for similar functionality as is provided by the MDAnalysis[@gowersMDAnalysisPythonPackage2016] atom selection language, designed for simulations with a fixed topology.
+`molify` addresses this by enabling the use of RDKit's powerful SMILES [@weiningerSMILESChemicalLanguage1988]/SMARTS-based substructure searching on ASE structures.
+In addition, the resulting molecular graph can be exported to a NetworkX [@hagbergExploringNetworkStructure2008] object for further analysis.
+This selection and handling allows for similar functionality as is provided by the MDAnalysis [@gowersMDAnalysisPythonPackage2016] atom selection language, designed for simulations with a fixed topology.
 
 # Features and Implementation
 
-![Visualization of a 3D structure from ASE, visualized with ZnDraw[@elijosiusZeroShotMolecular2024] (left) and its corresponding RDKit 2D chemical structure representation (right).\label{fig:zndraw-rdkit}](zndraw_rdkit.svg)
+![Visualization of a 3D structure from ASE, visualized with ZnDraw [@elijosiusZeroShotMolecular2024] (left) and its corresponding RDKit 2D chemical structure representation (right).\label{fig:zndraw-rdkit}](zndraw_rdkit.svg)
 
 The generation of atomic configurations in `molify` is centered around SMILES for defining molecular species.
 A typical workflow often follows these steps:
@@ -81,7 +81,7 @@ opt.run(fmax=0.01)
 ```
 All ASE Atoms objects generated or processed by `molify` store `connectivity` information (bonds and their orders) within the `ase.Atoms.info` dictionary.
 If this information is available, `molify` uses it to convert between ASE, NetworkX and RDKit.
-If an ASE structure is converted to an RDKit molecule without pre-existing connectivity, `molify` leverages RDKit's bond perception algorithms[@kimUniversalStructureConversion2015] to estimate this information.
+If an ASE structure is converted to an RDKit molecule without pre-existing connectivity, `molify` leverages RDKit's bond perception algorithms [@kimUniversalStructureConversion2015] to estimate this information.
 
 A visualisation of the 2D and 3D structure from the simulation is shown in \autoref{fig:zndraw-rdkit}.
 
@@ -116,9 +116,6 @@ frames: list[ase.Atoms] = get_substructures(
 )
 ```
 
-# Acknowledgements
-F.Z. acknowledges support by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) in the framework of the priority program SPP 2363, "Utilization and Development of Machine Learning for Molecular Applications – Molecular Machine Learning" Project No. 497249646. Further funding through the DFG under Germany's Excellence Strategy – EXC 2075 – 390740016 and the Stuttgart Center for Simulation Science (SimTech) was provided.
-
 # Related software
 The functionality of `molify` relies critically on the following packages:
 
@@ -133,7 +130,12 @@ The `molify` package is currently a crucial part of the following software packa
 - [ZnDraw](https://github.com/zincware/zndraw): Interactive generation of simulation boxes and selection of substructures through a graphical user interface inside a web-based visualization package.
 - [mlipx](https://github.com/basf/mlipx): Creating initial structures for benchmarking different MLIPs on real-world test scenarios.
 
-The OpenBabel[@oboyleOpenBabelOpen2011] package provides similar cheminformatics functionality to RDKit along with extensive file format support.
+The OpenBabel [@oboyleOpenBabelOpen2011] package provides similar cheminformatics functionality to RDKit along with extensive file format support.
 However, OpenBabel is primarily designed as a format conversion tool with a focus on command-line usage and file I/O, while `molify` is designed for Python-native workflows with in-memory object conversions.
 Currently, OpenBabel does not provide direct support for ASE Atoms objects, ASE calculators (including MLIPs), or seamless RDKit-ASE interconversion within Python.
 Furthermore, `molify`'s integration with PACKMOL and NetworkX provides capabilities beyond OpenBabel's core focus on format conversion.
+
+# Acknowledgements
+F.Z. acknowledges support by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) in the framework of the priority program SPP 2363, "Utilization and Development of Machine Learning for Molecular Applications – Molecular Machine Learning" Project No. 497249646. Further funding through the DFG under Germany's Excellence Strategy – EXC 2075 – 390740016 and the Stuttgart Center for Simulation Science (SimTech) was provided.
+
+# References

{molify-0.2.2 → molify-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "molify"
-version = "0.2.2"
+dynamic = ["version"]
 description = "Molecular Structure Interface with RDKit, ASE, Packmol and NetworkX"
 readme = "README.md"
 license = "Apache-2.0"
@@ -52,9 +52,15 @@ extend-ignore = [
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/molify/_version.py"
+
 [tool.codespell]
 ignore-words-list = "basf"
 skip = "*.svg,paper/bibliography.bib,*.ipynb"

molify-0.2.4/src/molify/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
+
+__commit_id__ = commit_id = None

{molify-0.2.2 → molify-0.2.4}/src/molify/ase2x.py

@@ -4,6 +4,8 @@ import numpy as np
 from ase.neighborlist import natural_cutoffs, neighbor_list
 from rdkit import Chem
 
+from molify.constants import EdgeAttr, GraphAttr, NodeAttr
+
 try:
     import vesin
 except ImportError:
@@ -15,20 +17,25 @@ def _create_graph_from_connectivity(
 ) -> nx.Graph:
     """Create NetworkX graph from explicit connectivity information."""
     graph = nx.Graph()
-    graph.graph["pbc"] = atoms.pbc
-    graph.graph["cell"] = atoms.cell
+    graph.graph[GraphAttr.PBC] = atoms.pbc
+    graph.graph[GraphAttr.CELL] = atoms.cell
+
+    stored_indices = atoms.info.get(NodeAttr.ORIGINAL_INDEX)
 
     for i, atom in enumerate(atoms):
+        original_index = stored_indices[i] if stored_indices is not None else atom.index
         graph.add_node(
             i,
-            position=atom.position,
-            atomic_number=int(atom.number),
-            original_index=atom.index,
-            charge=charges[i],
+            **{
+                NodeAttr.POSITION: atom.position,
+                NodeAttr.ATOMIC_NUMBER: int(atom.number),
+                NodeAttr.ORIGINAL_INDEX: original_index,
+                NodeAttr.CHARGE: charges[i],
+            },
         )
 
     for i, j, bond_order in connectivity:
-        graph.add_edge(i, j, bond_order=bond_order)
+        graph.add_edge(i, j, **{EdgeAttr.BOND_ORDER: bond_order})
     return graph
 
 
@@ -85,13 +92,16 @@ def _add_node_properties(
     graph: nx.Graph, atoms: ase.Atoms, charges, non_bonding_atomic_numbers
 ):
     """Add node properties to the graph."""
+    stored_indices = atoms.info.get(NodeAttr.ORIGINAL_INDEX)
+
     for i, atom in enumerate(atoms):
-        graph.nodes[i]["position"] = atom.position
-        graph.nodes[i]["atomic_number"] = int(atom.number)
-        graph.nodes[i]["original_index"] = atom.index
-        graph.nodes[i]["charge"] = float(charges[i])
+        original_index = stored_indices[i] if stored_indices is not None else atom.index
+        graph.nodes[i][NodeAttr.POSITION] = atom.position
+        graph.nodes[i][NodeAttr.ATOMIC_NUMBER] = int(atom.number)
+        graph.nodes[i][NodeAttr.ORIGINAL_INDEX] = original_index
+        graph.nodes[i][NodeAttr.CHARGE] = float(charges[i])
         if atom.number in non_bonding_atomic_numbers:
-            graph.nodes[i]["charge"] = 1.0
+            graph.nodes[i][NodeAttr.CHARGE] = 1.0
 
 
 def ase2networkx(
@@ -158,8 +168,8 @@ def ase2networkx(
         return nx.Graph()
     charges = atoms.get_initial_charges()
 
-    if "connectivity" in atoms.info:
-        connectivity = atoms.info["connectivity"]
+    if GraphAttr.CONNECTIVITY in atoms.info:
+        connectivity = atoms.info[GraphAttr.CONNECTIVITY]
         # ensure connectivity is list[tuple[int, int, float|None]] and
         # does not contain np.generic
         connectivity = [
@@ -174,12 +184,12 @@ def ase2networkx(
 
     graph = nx.from_numpy_array(connectivity_matrix, edge_attr=None)
     for u, v in graph.edges():
-        graph.edges[u, v]["bond_order"] = None
+        graph.edges[u, v][EdgeAttr.BOND_ORDER] = None
 
     _add_node_properties(graph, atoms, charges, non_bonding_atomic_numbers)
 
-    graph.graph["pbc"] = atoms.pbc
-    graph.graph["cell"] = atoms.cell
+    graph.graph[GraphAttr.PBC] = atoms.pbc
+    graph.graph[GraphAttr.CELL] = atoms.cell
 
     return graph
 

{molify-0.2.2 → molify-0.2.4}/src/molify/compress.py

@@ -2,6 +2,7 @@ import ase
 import numpy as np
 from ase.cell import Cell
 
+from molify.constants import GraphAttr
 from molify.utils import calculate_box_dimensions
 
 
@@ -28,7 +29,7 @@ def compress(
     if freeze_molecules:
         new_cell = Cell.new(new_dimensions)
         old_cell = atoms.get_cell()
-        connectivity = atoms.info.get("connectivity")
+        connectivity = atoms.info.get(GraphAttr.CONNECTIVITY)
         if connectivity is None:
             raise ValueError("No connectivity info found for freeze_molecules=True")
 

molify-0.2.4/src/molify/constants.py

@@ -0,0 +1,35 @@
+"""String constants used as attribute keys across molify conversions."""
+
+import sys
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        """Backport of StrEnum for Python 3.10."""
+
+
+class NodeAttr(StrEnum):
+    """Attribute keys stored on networkx graph nodes."""
+
+    POSITION = "position"
+    ATOMIC_NUMBER = "atomic_number"
+    ORIGINAL_INDEX = "original_index"
+    CHARGE = "charge"
+
+
+class EdgeAttr(StrEnum):
+    """Attribute keys stored on networkx graph edges."""
+
+    BOND_ORDER = "bond_order"
+
+
+class GraphAttr(StrEnum):
+    """Attribute keys stored on networkx graph-level or ASE atoms.info dicts."""
+
+    PBC = "pbc"
+    CELL = "cell"
+    CONNECTIVITY = "connectivity"
+    SMILES = "smiles"

{molify-0.2.2 → molify-0.2.4}/src/molify/networkx2x.py

@@ -3,6 +3,7 @@ import networkx as nx
 import numpy as np
 from rdkit import Chem
 
+from molify.constants import EdgeAttr, GraphAttr, NodeAttr
 from molify.utils import bond_type_from_order
 
 
@@ -46,27 +47,33 @@ def networkx2ase(graph: nx.Graph) -> ase.Atoms:
     # Create mapping from original node indices to new sequential indices
     node_mapping = {node: i for i, node in enumerate(graph.nodes)}
 
-    positions = np.array([graph.nodes[n]["position"] for n in graph.nodes])
-    numbers = np.array([graph.nodes[n]["atomic_number"] for n in graph.nodes])
-    charges = np.array([graph.nodes[n]["charge"] for n in graph.nodes])
+    positions = np.array([graph.nodes[n][NodeAttr.POSITION] for n in graph.nodes])
+    numbers = np.array([graph.nodes[n][NodeAttr.ATOMIC_NUMBER] for n in graph.nodes])
+    charges = np.array([graph.nodes[n][NodeAttr.CHARGE] for n in graph.nodes])
 
     atoms = ase.Atoms(
         positions=positions,
         numbers=numbers,
         charges=charges,
-        pbc=graph.graph.get("pbc", False),
-        cell=graph.graph.get("cell", None),
+        pbc=graph.graph.get(GraphAttr.PBC, False),
+        cell=graph.graph.get(GraphAttr.CELL, None),
     )
 
     connectivity = []
     for u, v, data in graph.edges(data=True):
-        bond_order = data["bond_order"]
+        bond_order = data[EdgeAttr.BOND_ORDER]
         # Map original node indices to new sequential indices
         new_u = node_mapping[u]
         new_v = node_mapping[v]
         connectivity.append((new_u, new_v, bond_order))
 
-    atoms.info["connectivity"] = connectivity
+    atoms.info[GraphAttr.CONNECTIVITY] = connectivity
+
+    original_indices = [
+        graph.nodes[n].get(NodeAttr.ORIGINAL_INDEX) for n in graph.nodes
+    ]
+    if all(idx is not None for idx in original_indices):
+        atoms.info[NodeAttr.ORIGINAL_INDEX] = original_indices
 
     return atoms
 
@@ -131,7 +138,7 @@ def networkx2rdkit(graph: nx.Graph, suggestions: list[str] | None = None) -> Che
 
     # Check if any edges have bond_order=None and determine them if needed
     has_none_bond_orders = any(
-        data.get("bond_order") is None for u, v, data in graph.edges(data=True)
+        data.get(EdgeAttr.BOND_ORDER) is None for u, v, data in graph.edges(data=True)
     )
 
     if has_none_bond_orders:
@@ -141,7 +148,7 @@ def networkx2rdkit(graph: nx.Graph, suggestions: list[str] | None = None) -> Che
 
         # Verify all bond orders are now determined
         for u, v, data in graph.edges(data=True):
-            bond_order = data.get("bond_order")
+            bond_order = data.get(EdgeAttr.BOND_ORDER)
             if bond_order is None:
                 raise ValueError(
                     f"Failed to determine bond order for edge ({u}, {v}).\n"
@@ -159,22 +166,29 @@ def networkx2rdkit(graph: nx.Graph, suggestions: list[str] | None = None) -> Che
     nx_to_rdkit_atom_map = {}
 
     for node_id, attributes in graph.nodes(data=True):
-        atomic_number = attributes.get("atomic_number")
-        charge = attributes.get("charge", 0)
+        atomic_number = attributes.get(NodeAttr.ATOMIC_NUMBER)
+        charge = attributes.get(NodeAttr.CHARGE, 0)
 
         if atomic_number is None:
-            raise ValueError(f"Node {node_id} is missing 'atomic_number' attribute.")
+            raise ValueError(
+                f"Node {node_id} is missing '{NodeAttr.ATOMIC_NUMBER}' attribute."
+            )
 
         atom = Chem.Atom(int(atomic_number))
         atom.SetFormalCharge(int(charge))
+        original_index = attributes.get(NodeAttr.ORIGINAL_INDEX)
+        if original_index is not None:
+            atom.SetIntProp(NodeAttr.ORIGINAL_INDEX, int(original_index))
         idx = mol.AddAtom(atom)
         nx_to_rdkit_atom_map[node_id] = idx
 
     for u, v, data in graph.edges(data=True):
-        bond_order = data.get("bond_order")
+        bond_order = data.get(EdgeAttr.BOND_ORDER)
 
         if bond_order is None:
-            raise ValueError(f"Edge ({u}, {v}) is missing 'bond_order' attribute.")
+            raise ValueError(
+                f"Edge ({u}, {v}) is missing '{EdgeAttr.BOND_ORDER}' attribute."
+            )
 
         mol.AddBond(
             nx_to_rdkit_atom_map[u],

{molify-0.2.2 → molify-0.2.4}/src/molify/pack.py

@@ -9,6 +9,7 @@ import numpy as np
 from ase.io.proteindatabank import write_proteindatabank
 from rdkit import Chem
 
+from molify.constants import GraphAttr
 from molify.utils import calculate_box_dimensions
 
 log = logging.getLogger(__name__)
@@ -125,17 +126,20 @@ def _extract_atom_arrays(
             )
             packed_atoms.arrays[key] = concatenated_array
 
-    if all("connectivity" in atoms.info for atoms in selected_images):
+    if all(GraphAttr.CONNECTIVITY in atoms.info for atoms in selected_images):
         bonds = []
         offset = 0
         for atoms in selected_images:
-            for bond in atoms.info["connectivity"]:
+            for bond in atoms.info[GraphAttr.CONNECTIVITY]:
                 bonds.append((bond[0] + offset, bond[1] + offset, bond[2]))
             offset += len(atoms)
-        packed_atoms.info["connectivity"] = bonds
+        packed_atoms.info[GraphAttr.CONNECTIVITY] = bonds
     charges = np.concatenate([atom.get_initial_charges() for atom in selected_images])
     if any(charge != 0 for charge in charges):
         packed_atoms.set_initial_charges(charges)
+    tags = np.concatenate([atom.get_tags() for atom in selected_images])
+    if any(tag != 0 for tag in tags):
+        packed_atoms.set_tags(tags)
     return packed_atoms
 
 

{molify-0.2.2 → molify-0.2.4}/src/molify/rdkit2x.py

@@ -3,6 +3,8 @@ import networkx as nx
 from rdkit import Chem
 from rdkit.Chem import AllChem
 
+from molify.constants import EdgeAttr, GraphAttr, NodeAttr
+
 
 def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
     """Convert an RDKit molecule to an ASE Atoms object.
@@ -45,16 +47,22 @@ def rdkit2ase(mol: Chem.Mol, seed: int = 42) -> ase.Atoms:
         positions=mol.GetConformer().GetPositions(),
         numbers=[atom.GetAtomicNum() for atom in mol.GetAtoms()],
     )
-    atoms.info["smiles"] = smiles
-    atoms.info["connectivity"] = []
+    atoms.info[GraphAttr.SMILES] = smiles
+    atoms.info[GraphAttr.CONNECTIVITY] = []
     for bond in mol.GetBonds():
         a1 = bond.GetBeginAtomIdx()
         a2 = bond.GetEndAtomIdx()
         order = bond.GetBondTypeAsDouble()
-        atoms.info["connectivity"].append((a1, a2, order))
+        atoms.info[GraphAttr.CONNECTIVITY].append((a1, a2, order))
 
     if any(charge != 0 for charge in charges):
         atoms.set_initial_charges(charges)
+
+    if all(atom.HasProp(NodeAttr.ORIGINAL_INDEX) for atom in mol.GetAtoms()):
+        atoms.info[NodeAttr.ORIGINAL_INDEX] = [
+            atom.GetIntProp(NodeAttr.ORIGINAL_INDEX) for atom in mol.GetAtoms()
+        ]
+
     return atoms
 
 
@@ -100,11 +108,18 @@ def rdkit2networkx(mol: Chem.Mol) -> nx.Graph:
     mol = Chem.AddHs(mol)
     graph = nx.Graph()
     for atom in mol.GetAtoms():
+        original_index = (
+            atom.GetIntProp(NodeAttr.ORIGINAL_INDEX)
+            if atom.HasProp(NodeAttr.ORIGINAL_INDEX)
+            else atom.GetIdx()
+        )
         graph.add_node(
             atom.GetIdx(),
-            atomic_number=atom.GetAtomicNum(),
-            original_index=atom.GetIdx(),
-            charge=atom.GetFormalCharge(),
+            **{
+                NodeAttr.ATOMIC_NUMBER: atom.GetAtomicNum(),
+                NodeAttr.ORIGINAL_INDEX: original_index,
+                NodeAttr.CHARGE: atom.GetFormalCharge(),
+            },
         )
 
     for bond in mol.GetBonds():
@@ -120,6 +135,8 @@ def rdkit2networkx(mol: Chem.Mol) -> nx.Graph:
             bond_order = 1.5
 
         graph.add_edge(
-            bond.GetBeginAtomIdx(), bond.GetEndAtomIdx(), bond_order=bond_order
+            bond.GetBeginAtomIdx(),
+            bond.GetEndAtomIdx(),
+            **{EdgeAttr.BOND_ORDER: bond_order},
         )
     return graph

{molify-0.2.2 → molify-0.2.4}/src/molify/smiles2x.py

@@ -3,6 +3,8 @@ import numpy as np
 from rdkit import Chem
 from rdkit.Chem import rdDistGeom
 
+from molify.constants import GraphAttr
+
 
 def get_pf6() -> ase.Atoms:
     directions = np.array(
@@ -23,8 +25,8 @@ def get_pf6() -> ase.Atoms:
 
     atoms = ase.Atoms(symbols=symbols, positions=positions)
 
-    atoms.info["connectivity"] = [(0, i, 1.0) for i in range(1, 7)]
-    atoms.info["smiles"] = "F[P-](F)(F)(F)(F)F"
+    atoms.info[GraphAttr.CONNECTIVITY] = [(0, i, 1.0) for i in range(1, 7)]
+    atoms.info[GraphAttr.SMILES] = "F[P-](F)(F)(F)(F)F"
     atoms.set_initial_charges([-1] + [0] * 6)
 
     return atoms
@@ -140,8 +142,8 @@ def smiles2conformers(
             positions=conf.GetPositions(),
             numbers=[atom.GetAtomicNum() for atom in mol.GetAtoms()],
         )
-        atoms.info["smiles"] = smiles
-        atoms.info["connectivity"] = bonds
+        atoms.info[GraphAttr.SMILES] = smiles
+        atoms.info[GraphAttr.CONNECTIVITY] = bonds
         if charges is not None:
             atoms.set_initial_charges(charges)
         images.append(atoms)

{molify-0.2.2 → molify-0.2.4}/src/molify/substructure.py

@@ -7,6 +7,7 @@ from rdkit import Chem
 from rdkit.Chem import Draw
 
 from molify.ase2x import ase2rdkit
+from molify.constants import GraphAttr
 from molify.utils import find_connected_components
 
 
@@ -303,9 +304,9 @@ def iter_fragments(atoms: ase.Atoms) -> list[ase.Atoms]:
     >>> len(fragments)
     2
     """
-    if "connectivity" in atoms.info:
+    if GraphAttr.CONNECTIVITY in atoms.info:
         # connectivity is a list of tuples (i, j, bond_type)
-        connectivity = atoms.info["connectivity"]
+        connectivity = atoms.info[GraphAttr.CONNECTIVITY]
         for component in find_connected_components(connectivity):
             yield atoms[list(component)]
     else:

{molify-0.2.2 → molify-0.2.4}/tests/integration/test_ase2x.py

@@ -5,6 +5,7 @@ import pytest
 from rdkit import Chem
 
 import molify
+from molify.constants import GraphAttr, NodeAttr
 
 
 class SMILES:
@@ -343,3 +344,48 @@ def test_ase2networkx_preserves_none_bond_orders_in_connectivity():
     for i, j, bond_order in connectivity_without_orders:
         assert graph.has_edge(i, j)
         assert graph.edges[i, j]["bond_order"] is None
+
+
+class TestAse2NetworkxOriginalIndex:
+    """Test that ase2networkx reads back original_index from atoms.info."""
+
+    def test_reads_stored_original_index_with_connectivity(self):
+        """ase2networkx should use atoms.info['original_index'] when present.
+
+        This tests the _create_graph_from_connectivity path.
+        """
+        atoms = molify.smiles2atoms("CCO")
+        # Manually set non-trivial original_index so the test isn't trivially true
+        atoms.info[NodeAttr.ORIGINAL_INDEX] = list(range(10, 10 + len(atoms)))
+
+        graph = molify.ase2networkx(atoms)
+
+        expected = list(range(10, 10 + len(atoms)))
+        actual = [graph.nodes[n][NodeAttr.ORIGINAL_INDEX] for n in graph.nodes]
+        assert actual == expected
+
+    def test_reads_stored_original_index_without_connectivity(self):
+        """ase2networkx should use atoms.info['original_index'] when present.
+
+        This tests the _add_node_properties path (no connectivity in atoms.info).
+        """
+        atoms = molify.smiles2atoms("CCO")
+        # Store non-trivial original_index, then remove connectivity
+        atoms.info[NodeAttr.ORIGINAL_INDEX] = list(range(10, 10 + len(atoms)))
+        del atoms.info[GraphAttr.CONNECTIVITY]
+
+        graph = molify.ase2networkx(atoms)
+
+        expected = list(range(10, 10 + len(atoms)))
+        actual = [graph.nodes[n][NodeAttr.ORIGINAL_INDEX] for n in graph.nodes]
+        assert actual == expected
+
+    def test_defaults_to_atom_index_without_stored_indices(self):
+        """Without atoms.info['original_index'], use sequential atom.index."""
+        atoms = molify.smiles2atoms("CCO")
+        assert NodeAttr.ORIGINAL_INDEX not in atoms.info
+
+        graph = molify.ase2networkx(atoms)
+
+        for n in graph.nodes:
+            assert graph.nodes[n][NodeAttr.ORIGINAL_INDEX] == n

{molify-0.2.2 → molify-0.2.4}/tests/integration/test_networkx2x.py

@@ -3,6 +3,7 @@ import pytest
 from rdkit import Chem
 
 import molify
+from molify.constants import EdgeAttr, NodeAttr
 
 
 class SMILES:
@@ -601,3 +602,94 @@ def test_modify_graph_combined_add_remove_to_rdkit():
     assert 9 in atom_nums  # Fluorine should be present
     assert 6 in atom_nums  # Carbon should be present
     assert 8 in atom_nums  # Oxygen should be present
+
+
+# ============================================================================
+# Tests for original_index preservation (GitHub issue #104)
+# ============================================================================
+
+
+class TestNetworkx2RdkitOriginalIndex:
+    """Test that networkx2rdkit preserves original_index from graph nodes."""
+
+    def test_original_index_stored_on_rdkit_atoms(self):
+        """original_index should be an RDKit atom int property."""
+        atoms = molify.smiles2atoms("CCO")
+        graph = molify.ase2networkx(atoms)
+
+        mol = molify.networkx2rdkit(graph)
+
+        for i, (_node_id, attributes) in enumerate(graph.nodes(data=True)):
+            rdkit_atom = mol.GetAtomWithIdx(i)
+            assert rdkit_atom.HasProp(NodeAttr.ORIGINAL_INDEX)
+            assert (
+                rdkit_atom.GetIntProp(NodeAttr.ORIGINAL_INDEX)
+                == attributes[NodeAttr.ORIGINAL_INDEX]
+            )
+
+    def test_original_index_preserved_with_subgraph(self):
+        """original_index should be preserved even with non-sequential node IDs."""
+        atoms = molify.smiles2atoms("CCO")
+        graph = molify.ase2networkx(atoms)
+
+        heavy_atom_nodes = [
+            n for n, d in graph.nodes(data=True) if d[NodeAttr.ATOMIC_NUMBER] != 1
+        ]
+        subgraph = graph.subgraph(heavy_atom_nodes).copy()
+
+        mol = molify.networkx2rdkit(subgraph)
+
+        for i, (_node_id, attributes) in enumerate(subgraph.nodes(data=True)):
+            rdkit_atom = mol.GetAtomWithIdx(i)
+            assert (
+                rdkit_atom.GetIntProp(NodeAttr.ORIGINAL_INDEX)
+                == attributes[NodeAttr.ORIGINAL_INDEX]
+            )
+
+    def test_original_index_preserved_with_none_bond_orders(self):
+        """original_index preserved with auto bond orders."""
+        atoms = molify.smiles2atoms("CC")
+        graph = molify.ase2networkx(atoms)
+
+        for u, v in graph.edges():
+            graph.edges[u, v][EdgeAttr.BOND_ORDER] = None
+
+        mol = molify.networkx2rdkit(graph, suggestions=[])
+
+        for i, (_node_id, attributes) in enumerate(graph.nodes(data=True)):
+            rdkit_atom = mol.GetAtomWithIdx(i)
+            assert (
+                rdkit_atom.GetIntProp(NodeAttr.ORIGINAL_INDEX)
+                == attributes[NodeAttr.ORIGINAL_INDEX]
+            )
+
+
+class TestNetworkx2AseOriginalIndex:
+    """Test that networkx2ase preserves original_index from graph nodes."""
+
+    def test_original_index_stored_in_atoms_info(self):
+        """original_index from networkx nodes should be stored in atoms.info."""
+        atoms = molify.smiles2atoms("CCO")
+        graph = molify.ase2networkx(atoms)
+
+        new_atoms = molify.networkx2ase(graph)
+
+        assert NodeAttr.ORIGINAL_INDEX in new_atoms.info
+        expected = [graph.nodes[n][NodeAttr.ORIGINAL_INDEX] for n in graph.nodes]
+        assert new_atoms.info[NodeAttr.ORIGINAL_INDEX] == expected
+
+    def test_original_index_preserved_with_subgraph(self):
+        """original_index should reflect original atom indices, not remapped ones."""
+        atoms = molify.smiles2atoms("CCO")
+        graph = molify.ase2networkx(atoms)
+
+        heavy_atom_nodes = [
+            n for n, d in graph.nodes(data=True) if d[NodeAttr.ATOMIC_NUMBER] != 1
+        ]
+        subgraph = graph.subgraph(heavy_atom_nodes).copy()
+
+        new_atoms = molify.networkx2ase(subgraph)
+
+        assert NodeAttr.ORIGINAL_INDEX in new_atoms.info
+        expected = [subgraph.nodes[n][NodeAttr.ORIGINAL_INDEX] for n in subgraph.nodes]
+        assert new_atoms.info[NodeAttr.ORIGINAL_INDEX] == expected

{molify-0.2.2 → molify-0.2.4}/tests/test_rdkit2ase.py

@@ -5,7 +5,8 @@ import pytest
 import rdkit
 from rdkit import Chem
 
-from molify import ase2rdkit, rdkit2ase, smiles2atoms
+from molify import ase2rdkit, rdkit2ase, rdkit2networkx, smiles2atoms
+from molify.constants import NodeAttr
 
 
 @pytest.fixture
@@ -147,3 +148,58 @@ def test_rdkit2ase_nacn():
     ]
     assert atoms.get_initial_charges().tolist() == [-1, 0, 1]
     assert atoms.get_atomic_numbers().tolist() == [6, 7, 11]
+
+
+# ============================================================================
+# Tests for original_index preservation (GitHub issue #104)
+# ============================================================================
+
+
+class TestRdkit2AseOriginalIndex:
+    """Test that rdkit2ase preserves original_index from RDKit atom properties."""
+
+    def test_original_index_carried_from_rdkit_to_ase(self):
+        """If RDKit atoms have original_index, store it."""
+        mol = Chem.RWMol(Chem.MolFromSmiles("CO"))
+        mol = Chem.AddHs(mol)
+        # Set original_index on each atom (simulating a prior networkx2rdkit conversion)
+        for atom in mol.GetAtoms():
+            atom.SetIntProp(NodeAttr.ORIGINAL_INDEX, atom.GetIdx() + 10)
+
+        atoms = rdkit2ase(mol)
+
+        assert NodeAttr.ORIGINAL_INDEX in atoms.info
+        expected = [atom.GetIdx() + 10 for atom in mol.GetAtoms()]
+        assert atoms.info[NodeAttr.ORIGINAL_INDEX] == expected
+
+    def test_no_original_index_when_rdkit_atoms_lack_property(self):
+        """No original_index added when absent from RDKit atoms."""
+        mol = Chem.MolFromSmiles("CO")
+        atoms = rdkit2ase(mol)
+
+        assert NodeAttr.ORIGINAL_INDEX not in atoms.info
+
+
+class TestRdkit2NetworkxOriginalIndex:
+    """Test that rdkit2networkx preserves original_index from RDKit atom properties."""
+
+    def test_original_index_carried_from_rdkit_to_networkx(self):
+        """If RDKit atoms have original_index, use it."""
+        mol = Chem.RWMol(Chem.MolFromSmiles("CO"))
+        mol = Chem.AddHs(mol)
+        for atom in mol.GetAtoms():
+            atom.SetIntProp(NodeAttr.ORIGINAL_INDEX, atom.GetIdx() + 20)
+
+        graph = rdkit2networkx(mol)
+
+        for node_id, attributes in graph.nodes(data=True):
+            assert attributes[NodeAttr.ORIGINAL_INDEX] == node_id + 20
+
+    def test_falls_back_to_getidx_without_property(self):
+        """Falls back to GetIdx() without original_index."""
+        mol = Chem.MolFromSmiles("CO")
+
+        graph = rdkit2networkx(mol)
+
+        for node_id, attributes in graph.nodes(data=True):
+            assert attributes[NodeAttr.ORIGINAL_INDEX] == node_id

{molify-0.2.2 → molify-0.2.4}/tests/test_solvate.py

@@ -109,6 +109,16 @@ def test_pack_charges():
     assert charges == [0, 0, 0, -1, 0, 1] + [1, 0, 0, -1, 0, 0, 0, 0, 0, 0]
 
 
+def test_pack_tags():
+    water = smiles2conformers("O", 1)
+    methane = smiles2conformers("C", 1)
+    water[0].set_tags(range(1, 4))  # O, H, H -> 1, 2, 3
+    methane[0].set_tags(range(4, 9))  # C, H, H, H, H -> 4, 5, 6, 7, 8
+
+    atoms = pack([water, methane], [2, 1], density=1000)
+    npt.assert_array_equal(atoms.get_tags(), [1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 8])
+
+
 def test_pack_ratio():
     water = smiles2conformers("O", 1)
     # pack a cubic box

{molify-0.2.2 → molify-0.2.4}/uv.lock

@@ -1231,7 +1231,6 @@ wheels = [
 
 [[package]]
 name = "molify"
-version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "ase" },

molify-0.2.2/.github/workflows/build-wheels.yaml

@@ -1,25 +0,0 @@
-name: Build and upload to PyPI
-
-on:
-  workflow_dispatch:
-  release:
-    types:
-      - published
-jobs:
-  pypi-publish:
-    name: Upload release to PyPI
-    runs-on: ubuntu-latest
-    environment:
-      name: pypi
-      url: https://pypi.org/p/molify
-    permissions:
-      id-token: write
-    steps:
-    - uses: actions/checkout@v5
-    - name: Install uv
-      uses: astral-sh/setup-uv@v5
-    - name: Build
-      run: |
-          uv build
-    - name: Publish package distributions to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1