lammpsparser 0.0.3__tar.gz → 0.0.4__tar.gz

lammpsparser-0.0.4/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lammpsparser
-Version: 0.0.3
+Version: 0.0.4
 Summary: Vector-oriented LAMMPS interface to rapidly iterate over series of atomistic structures or interatomic potentials.
 Project-URL: Homepage, https://github.com/pyiron/lammpsparser
 Project-URL: Documentation, https://github.com/pyiron/lammpsparser
@@ -53,6 +53,8 @@ Requires-Dist: ase<=3.28.0,>=3.22.1
 Requires-Dist: numpy<=2.4.3,>=1.26.0
 Requires-Dist: pandas<=3.0.2,>=2.0.3
 Requires-Dist: scipy<=1.17.1,>=1.11.1
+Provides-Extra: compatibility
+Requires-Dist: structuretoolkit<=0.0.42,>=0.0.30; extra == 'compatibility'
 Provides-Extra: h5md
 Requires-Dist: h5py<=3.16.0,>=3.9.0; extra == 'h5md'
 Description-Content-Type: text/markdown

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/pyproject.toml

@@ -48,6 +48,7 @@ Repository = "https://github.com/pyiron/lammpsparser"
 
 [project.optional-dependencies]
 h5md = ["h5py>=3.9.0,<=3.16.0"]
+compatibility = ["structuretoolkit>=0.0.30,<=0.0.42"]
 
 [tool.hatch.build]
 include = [

lammpsparser-0.0.4/src/lammpsparser/_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.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)
+
+__commit_id__ = commit_id = None

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/compatibility/calculate.py

@@ -1,4 +1,5 @@
 import warnings
+from typing import Any, cast
 
 import numpy as np
 from ase.atoms import Atoms
@@ -121,7 +122,7 @@ def calc_md(
                 "Target temperature for fix nvt/npt/nph cannot be 0 or negative"
             )
 
-        force_skewed = False
+        # force_skewed = False
         pressure = _pressure_to_lammps(
             pressure=pressure, rotation_matrix=rotation_matrix, units=units
         )
@@ -139,8 +140,8 @@ def calc_md(
                     pressure_string += " {0} {1} {1} {2}".format(
                         coord, value, pressure_damping_timescale
                     )
-                    if ii > 2:
-                        force_skewed = True
+                    # if ii > 2:
+                    #     force_skewed = True
 
         if langevin:  # NPT(Langevin)
             fix_ensemble_str = "fix ensemble all nph" + pressure_string
@@ -277,7 +278,7 @@ def calc_minimize(
             pressure=pressure, rotation_matrix=rotation_matrix, units=units
         )
         if np.isscalar(pressure):
-            str_press = " iso {}".format(pressure)
+            str_press = " iso {}".format(float(cast(Any, pressure)))
         else:
             str_press = ""
             for ii, (press, str_axis) in enumerate(

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/compatibility/constraints.py

@@ -2,7 +2,7 @@ import numpy as np
 from ase.atoms import Atoms
 
 
-def _get_fixed_atom_boolean_vector(structure: Atoms):
+def _get_fixed_atom_boolean_vector(structure: Atoms) -> np.ndarray:
     fixed_atom_vector = np.array([[False, False, False]] * len(structure))
     for c in structure.constraints:
         c_dict = c.todict()
@@ -27,8 +27,8 @@ def _get_fixed_atom_boolean_vector(structure: Atoms):
     return fixed_atom_vector
 
 
-def set_selective_dynamics(structure: Atoms, calc_md: bool = False):
-    control_dict = {}
+def set_selective_dynamics(structure: Atoms, calc_md: bool = False) -> dict[str, str]:
+    control_dict: dict[str, str] = {}
     if len(structure.constraints) > 0:
         sel_dyn = _get_fixed_atom_boolean_vector(structure=structure)
         # Enter loop only if constraints present

lammpsparser-0.0.4/src/lammpsparser/compatibility/data.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+
+import numpy as np
+
+
+@dataclass
+class CalcMDInput:
+    temperature: Optional[Union[float, list]] = None
+    pressure: Optional[Union[float, list, np.ndarray]] = None
+    n_ionic_steps: int = 1
+    time_step: float = 1.0
+    n_print: int = 100
+    temperature_damping_timescale: float = 100.0
+    pressure_damping_timescale: float = 1000.0
+    seed: int = 80996
+    tloop: Optional[int] = None
+    initial_temperature: Optional[float] = None
+    langevin: bool = False
+    delta_temp: Optional[float] = None
+    delta_press: Optional[float] = None
+    rotation_matrix: Optional[Union[list, np.ndarray]] = None
+
+
+@dataclass
+class CalcMinimizeInput:
+    ionic_energy_tolerance: float = 0.0
+    ionic_force_tolerance: float = 1e-4
+    max_iter: int = 100000
+    pressure: Optional[Union[float, list, np.ndarray]] = None
+    n_print: int = 1
+    style: str = "cg"
+    rotation_matrix: Optional[Union[list, np.ndarray]] = None

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/compatibility/file.py

@@ -1,7 +1,8 @@
 import os
 import shutil
 import subprocess
-from typing import Optional
+from dataclasses import asdict
+from typing import Optional, Union
 
 import pandas
 from ase.atoms import Atoms
@@ -12,6 +13,7 @@ from lammpsparser.compatibility.calculate import (
     calc_static,
 )
 from lammpsparser.compatibility.constraints import set_selective_dynamics
+from lammpsparser.compatibility.data import CalcMDInput, CalcMinimizeInput
 from lammpsparser.output import parse_lammps_output
 from lammpsparser.potential import get_potential_by_name
 from lammpsparser.structure import write_lammps_datafile
@@ -23,8 +25,9 @@ def lammps_file_interface_function(
     potential: str,
     calc_mode: str = "static",
     calc_kwargs: Optional[dict] = None,
+    calc_dataclass: Optional[Union[CalcMDInput, CalcMinimizeInput]] = None,
     units: str = "metal",
-    lmp_command: str = "mpiexec -n 1 --oversubscribe lmp_mpi -in lmp.in",
+    lmp_command: Optional[str] = None,
     resource_path: Optional[str] = None,
     input_control_file: Optional[dict] = None,
     write_restart_file: bool = False,
@@ -61,13 +64,15 @@ def lammps_file_interface_function(
           "static": No parameters
           "md": "temperature", "pressure", "n_ionic_steps", "time_step", "n_print", "temperature_damping_timescale",
                 "pressure_damping_timescale", "seed", "tloop", "initial_temperature", "langevin", "delta_temp",
-                "delta_press", job_name", "rotation_matrix"
+                "delta_press", "rotation_matrix"
           "minimize": "ionic_energy_tolerance", "ionic_force_tolerance", "max_iter", "pressure", "n_print", "style",
                       "rotation_matrix"
           "vcsgc": "mu", "ordered_element_list", "target_concentration", "kappa", "mc_step_interval", "swap_fraction",
                    "temperature_mc", "window_size", "window_moves", "temperature", "pressure", "n_ionic_steps",
                    "time_step", "n_print", "temperature_damping_timescale", "pressure_damping_timescale", "seed",
-                   "initial_temperature", "langevin", "job_name", "rotation_matrix"
+                   "initial_temperature", "langevin", "rotation_matrix"
+        calc_dataclass (CalcMDInput or CalcMinimizeInput): dataclass containing the parameters for the calculation,
+                                                           if calc_dataclass is provided
         cutoff_radius (float): cut-off radius for the interatomic potential
         units (str): Units for LAMMPS
         bonds_kwargs (dict): key-word arguments to create atomistic bonds:
@@ -88,11 +93,29 @@ def lammps_file_interface_function(
         str, dict, bool: Tuple consisting of the shell output (str), the parsed output (dict) and a boolean flag if
                          the execution raised an accepted error.
     """
+    if calc_dataclass is not None:
+        if isinstance(calc_dataclass, CalcMDInput):
+            calc_mode = "md"
+            calc_kwargs = asdict(calc_dataclass)
+
+        elif isinstance(calc_dataclass, CalcMinimizeInput):
+            calc_mode = "minimize"
+            calc_kwargs = asdict(calc_dataclass)
+        else:
+            raise TypeError(
+                "calc_dataclass must be an instance of either CalcMDInput or CalcMinimizeInput"
+            )
     if calc_kwargs is None:
         calc_kwargs = {}
     else:
         calc_kwargs = calc_kwargs.copy()
 
+    if lmp_command is None:
+        lmp_command = (
+            os.getenv("ASE_LAMMPSRUN_COMMAND", "mpiexec -n 1 --oversubscribe lmp_mpi")
+            + " -in lmp.in"
+        )
+
     os.makedirs(working_directory, exist_ok=True)
     potential_lst, potential_replace, species = _get_potential(
         potential=potential, resource_path=resource_path
@@ -100,21 +123,23 @@ def lammps_file_interface_function(
 
     lmp_str_lst = []
     atom_type = "atomic"
-    for l in lammps_file_initialization(
+    for line in lammps_file_initialization(
         structure=structure,
         units=units,
         read_restart_file=read_restart_file,
         restart_file=restart_file,
     ):
-        if l.strip().startswith("units") and "units" in potential_replace:
+        if line.strip().startswith("units") and "units" in potential_replace:
             lmp_str_lst.append(potential_replace["units"])
-        elif l.strip().startswith("atom_style") and "atom_style" in potential_replace:
+        elif (
+            line.strip().startswith("atom_style") and "atom_style" in potential_replace
+        ):
             lmp_str_lst.append(potential_replace["atom_style"])
             atom_type = potential_replace["atom_style"].split()[-1]
-        elif l.strip().startswith("dimension") and "dimension" in potential_replace:
+        elif line.strip().startswith("dimension") and "dimension" in potential_replace:
             lmp_str_lst.append(potential_replace["dimension"])
         else:
-            lmp_str_lst.append(l)
+            lmp_str_lst.append(line)
 
     lmp_str_lst += potential_lst
     lmp_str_lst += ["variable dumptime equal {} ".format(calc_kwargs.get("n_print", 1))]
@@ -185,7 +210,7 @@ def lammps_file_interface_function(
         lmp_str_lst.append(f"write_restart {os.path.basename(restart_file)}")
 
     with open(os.path.join(working_directory, "lmp.in"), "w") as f:
-        f.writelines([l + "\n" for l in lmp_str_lst])
+        f.writelines([line + "\n" for line in lmp_str_lst])
 
     write_lammps_datafile(
         structure=structure,
@@ -240,15 +265,15 @@ def _modify_input_dict(
 ):
     if input_control_file is not None:
         lmp_tmp_lst, keys_used = [], []
-        for l in lmp_str_lst:
-            ls = l.split()
+        for line in lmp_str_lst:
+            ls = line.split()
             if len(ls) >= 1:  # Remove empty lines
                 key = ls[0]
                 if key in input_control_file.keys():
                     lmp_tmp_lst.append(key + " " + input_control_file[key])
                     keys_used.append(key)
                 else:
-                    lmp_tmp_lst.append(l)
+                    lmp_tmp_lst.append(line)
         for k, v in input_control_file.items():
             if k not in keys_used:
                 lmp_tmp_lst.append(k + " " + v)
@@ -272,14 +297,14 @@ def _get_potential(potential, resource_path: Optional[str] = None):
 
     potential_replace = {}
     potential_lst = []
-    for l in potential_dataframe["Config"]:
-        if l.startswith("units"):
-            potential_replace["units"] = l
-        elif l.startswith("atom_style"):
-            potential_replace["atom_style"] = l
-        elif l.startswith("dimension"):
-            potential_replace["dimension"] = l
+    for line in potential_dataframe["Config"]:
+        if line.startswith("units"):
+            potential_replace["units"] = line
+        elif line.startswith("atom_style"):
+            potential_replace["atom_style"] = line
+        elif line.startswith("dimension"):
+            potential_replace["dimension"] = line
         else:
-            potential_lst.append(l)
+            potential_lst.append(line)
 
     return potential_lst, potential_replace, potential_dataframe["Species"]

lammpsparser-0.0.4/src/lammpsparser/compatibility/output.py

@@ -0,0 +1,38 @@
+from ase.atoms import Atoms
+
+
+def structure_from_parsed_output(
+    initial_structure: Atoms,
+    parsed_output: dict,
+    *,
+    wrap: bool = False,
+    index: int = -1,
+) -> Atoms:
+    """Construct an `Atoms` object from parsed output data.
+
+    Args:
+        initial_structure: The initial atomic structure to use as a template.
+        parsed_output: Parsed output containing atomic positions, cell, and indices.
+        wrap: Whether to wrap the atomic positions to the simulation cell (default is False).
+            Keeping the unwrapped positions is more beneficial if structures are passed between
+            different LAMMPS simulations in one workflow to ensure continuity.
+        index: The index of the frame to use from the parsed output (default is -1, i.e., the last frame).
+
+    Returns:
+        An `Atoms` object with updated positions and cell.
+
+    Example:
+        >>> new_atoms = structure_from_parsed_output(atoms, lammps_output)
+
+    """
+    # Take a copy of the initial structure as template and update the relevant properties
+    atoms_copy = initial_structure.copy()
+    atoms_copy.set_array("indices", parsed_output["generic"]["indices"][index])
+    atoms_copy.set_positions(parsed_output["generic"]["positions"][index])
+    atoms_copy.set_velocities(parsed_output["generic"]["velocities"][index])
+    atoms_copy.set_cell(parsed_output["generic"]["cells"][index])
+    atoms_copy.set_pbc(True)
+    if wrap:
+        atoms_copy.wrap()
+
+    return atoms_copy

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/compatibility/structure.py

@@ -17,7 +17,7 @@ class LammpsStructureCompatibility(LammpsStructure):
         atom_type: str = "atomic",
     ):
         super().__init__(bond_dict=bond_dict, units=units, atom_type=atom_type)
-        self._molecule_ids = []
+        self._molecule_ids: list[int] = []
 
     @property
     def structure(self) -> Optional[Atoms]:
@@ -211,7 +211,7 @@ class LammpsStructureCompatibility(LammpsStructure):
                                     <= cutoff_dist
                                 )
                                 act_ind = ind[bool_1]
-                                bool_2 = np.in1d(act_ind, el_2_list)
+                                bool_2 = np.isin(act_ind, el_2_list)
                                 final_ind = act_ind[bool_2]
                                 # Get the bond and angle type
                                 bond_type = val["bond_type_list"][i]

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/output.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 import warnings
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
@@ -66,8 +66,8 @@ def parse_lammps_output(
     dump_h5_file_name: str = "dump.h5",
     dump_out_file_name: str = "dump.out",
     log_lammps_file_name: str = "log.lammps",
-    remap_indices_funct: callable = remap_indices_ase,
-) -> Dict:
+    remap_indices_funct: Callable[..., np.ndarray] = remap_indices_ase,
+) -> Dict[str, Dict[str, Any]]:
     if prism is None:
         prism = UnfoldingPrism(structure.cell)
     dump_dict = _parse_dump(
@@ -86,7 +86,7 @@ def parse_lammps_output(
 
     convert_units = UnitConverter(units).convert_array_to_pyiron_units
 
-    hdf_output = {"generic": {}, "lammps": {}}
+    hdf_output: Dict[str, Dict[str, Any]] = {"generic": {}, "lammps": {}}
     hdf_generic = hdf_output["generic"]
     hdf_lammps = hdf_output["lammps"]
 
@@ -128,8 +128,8 @@ def _parse_dump(
     prism: UnfoldingPrism,
     structure: Atoms,
     potential_elements: Union[np.ndarray, List],
-    remap_indices_funct: callable = remap_indices_ase,
-) -> Dict:
+    remap_indices_funct: Callable[..., np.ndarray] = remap_indices_ase,
+) -> Dict[str, Any]:
     if os.path.isfile(dump_h5_full_file_name):
         if not _check_ortho_prism(prism=prism):
             raise RuntimeError(
@@ -157,14 +157,14 @@ def _collect_dump_from_text(
     prism: UnfoldingPrism,
     structure: Atoms,
     potential_elements: Union[np.ndarray, List],
-    remap_indices_funct: callable = remap_indices_ase,
-) -> Dict:
+    remap_indices_funct: Callable[..., np.ndarray] = remap_indices_ase,
+) -> Dict[str, Any]:
     """
     general purpose routine to extract static from a lammps dump file
     """
     rotation_lammps2orig = prism.R.T
     dump_lammps_dict = parse_raw_dump_from_text(file_name=file_name)
-    dump_dict = {}
+    dump_dict: Dict[str, Any] = {}
     for key, val in dump_lammps_dict.items():
         if key in ["cells"]:
             dump_dict[key] = [prism.unfold_cell(cell=cell) for cell in val]
@@ -337,4 +337,4 @@ def _check_ortho_prism(
     Returns:
         boolean: True or False
     """
-    return np.isclose(prism.R, np.eye(3), rtol=rtol, atol=atol).all()
+    return bool(np.isclose(prism.R, np.eye(3), rtol=rtol, atol=atol).all())

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/output_raw.py

@@ -221,25 +221,25 @@ def parse_raw_lammps_log(file_name: str) -> pd.DataFrame:
     with open(file_name, "r") as f:
         dfs = []
         read_thermo = False
-        for l in f:
-            l = l.lstrip()
+        for line in f:
+            line = line.lstrip()
 
-            if l.startswith("Step"):
+            if line.startswith("Step"):
                 thermo_lines = ""
                 read_thermo = True
 
             if read_thermo:
-                if l.startswith("Loop") or l.startswith("ERROR"):
+                if line.startswith("Loop") or line.startswith("ERROR"):
                     read_thermo = False
                     dfs.append(
                         pd.read_csv(StringIO(thermo_lines), sep="\\s+", engine="c")
                     )
 
-                elif l.startswith("WARNING:"):
-                    warnings.warn(f"A warning was found in the log:\n{l}")
+                elif line.startswith("WARNING:"):
+                    warnings.warn(f"A warning was found in the log:\n{line}")
 
                 else:
-                    thermo_lines += l
+                    thermo_lines += line
 
     if len(dfs) == 1:
         df = dfs[0]

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/potential.py

@@ -49,8 +49,8 @@ class PotentialAbstract:
     def __init__(
         self,
         potential_df: pandas.DataFrame,
-        default_df: pandas.DataFrame = None,
-        selected_atoms: list[str] = None,
+        default_df: Optional[pandas.DataFrame] = None,
+        selected_atoms: Optional[list[str]] = None,
     ):
         self._potential_df = potential_df
         self._default_df = default_df
@@ -328,7 +328,7 @@ def update_potential_paths(
 
 
 def get_resource_path_from_conda(
-    env_variables: tuple[str] = ("CONDA_PREFIX", "CONDA_DIR"),
+    env_variables: tuple[str, ...] = ("CONDA_PREFIX", "CONDA_DIR"),
 ) -> str:
     env = os.environ
     for conda_var in env_variables:
@@ -359,7 +359,7 @@ def get_potential_by_name(potential_name: str, resource_path: Optional[str] = No
 
 def validate_potential_dataframe(
     potential_dataframe: pandas.DataFrame,
-) -> pandas.DataFrame:
+) -> Union[pandas.DataFrame, pandas.Series]:
     if isinstance(potential_dataframe, pandas.Series):
         return potential_dataframe
     elif isinstance(potential_dataframe, pandas.DataFrame):

{lammpsparser-0.0.3 → lammpsparser-0.0.4}/src/lammpsparser/structure.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import decimal as dec
 import posixpath
 import warnings
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
 import numpy as np
 from ase.atoms import Atoms
@@ -16,12 +16,14 @@ from ase.data import atomic_masses, atomic_numbers
 from lammpsparser.units import UnitConverter
 
 try:
-    from ase.calculators.lammps import Prism
+    from ase.calculators.lammps import Prism as PrismBase
 except ImportError:
     try:
-        from ase.calculators.lammpsrun import Prism
+        from ase.calculators.lammpsrun import Prism as PrismBase
     except ImportError:
-        from ase.calculators.lammpsrun import prism as Prism
+        from ase.calculators.lammpsrun import (
+            prism as PrismBase,  # type: ignore[attr-defined,no-redef]
+        )
 
 __author__ = "Joerg Neugebauer, Sudarsan Surendralal, Yury Lysogorskiy, Jan Janssen, Markus Tautschnig"
 __copyright__ = (
@@ -35,7 +37,7 @@ __status__ = "production"
 __date__ = "Sep 1, 2017"
 
 
-class UnfoldingPrism(Prism):
+class UnfoldingPrism(PrismBase):
     """
     Create a lammps-style triclinic prism object from a cell
 
@@ -69,7 +71,7 @@ class UnfoldingPrism(Prism):
                 cell, pbc=np.array(pbc), tolerance=float("1e-{}".format(digits))
             )
         except TypeError:
-            super(UnfoldingPrism, self).__init__(cell, pbc=np.array(pbc), digits=digits)
+            super(UnfoldingPrism, self).__init__(cell, pbc=np.array(pbc), digits=digits)  # type: ignore[call-arg]
         a, b, c = cell
         an, bn, cn = [np.linalg.norm(v) for v in cell]
 
@@ -270,8 +272,8 @@ class LammpsStructure:
                     input_str += format_str.format(id_atom, x, y, z)
             elif len(self._structure.positions[0]) == 2:
                 format_str = "{0:d} {1:f} {2:f}\n"
-                for id_atom, (x, y) in enumerate(vels, start=1):
-                    input_str += format_str.format(id_atom, x, y)
+                for id_atom, velocity in enumerate(vels, start=1):
+                    input_str += format_str.format(id_atom, velocity[0], velocity[1])
         return input_str
 
     @property
@@ -352,7 +354,7 @@ class LammpsStructure:
             + "0. {} zlo zhi\n".format(zhi)
         )
 
-        if is_skewed(self.structure) or self._force_skewed:
+        if is_skewed(self._structure) or self._force_skewed:
             simulation_cell += "{0} {1} {2} xy xz yz\n".format(xy, xz, yz)
 
         return simulation_cell
@@ -383,7 +385,7 @@ class LammpsStructure:
             )
         return (
             self.lammps_header(
-                structure=self.structure,
+                structure=self._structure,
                 cell_dimensions=self.simulation_cell(),
                 species_lammps_id_dict=species_lammps_id_dict,
             )
@@ -500,7 +502,7 @@ def is_skewed(structure: Atoms, tolerance: float = 1.0e-8) -> bool:
 
 def write_lammps_datafile(
     structure: Atoms,
-    potential_elements: Union[np.ndarray, list],
+    potential_elements: Union[np.ndarray, list[str]],
     bond_dict: Optional[Dict] = None,
     units: str = "metal",
     file_name: str = "lammps.data",
@@ -508,7 +510,7 @@ def write_lammps_datafile(
     atom_type: str = "atomic",
 ) -> None:
     lammps_str = LammpsStructure(bond_dict=bond_dict, units=units, atom_type=atom_type)
-    lammps_str.el_eam_lst = potential_elements
+    lammps_str.el_eam_lst = cast(List[str], list(potential_elements))
     lammps_str.structure = structure
     lammps_str.write_file(file_name=file_name, cwd=working_directory)
 

lammpsparser-0.0.3/src/lammpsparser/_version.py

@@ -1,34 +0,0 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.0.3'
-__version_tuple__ = version_tuple = (0, 0, 3)
-
-__commit_id__ = commit_id = None