kim-tools 0.3.13__py3-none-any.whl → 0.4.2__py3-none-any.whl

kim_tools/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.13"
+__version__ = "0.4.2"
 
 from .aflow_util import *
 from .aflow_util import __all__ as aflow_all

kim_tools/aflow_util/core.py

@@ -17,7 +17,6 @@ import numpy as np
 import numpy.typing as npt
 from ase import Atoms
 from ase.cell import Cell
-from ase.neighborlist import natural_cutoffs, neighbor_list
 from semver import Version
 from sympy import Symbol, linear_eq_to_matrix, matrix2numpy, parse_expr
 
@@ -30,6 +29,7 @@ from ..symmetry_util import (
     cartesian_rotation_is_in_point_group,
     get_possible_primitive_shifts,
     get_primitive_wyckoff_multiplicity,
+    get_smallest_nn_dist,
     get_wyck_pos_xform_under_normalizer,
     space_group_numbers_are_enantiomorphic,
 )
@@ -1605,20 +1605,12 @@ class AFLOW:
         """
         # If max_resid not provided, determine it from neighborlist
         if max_resid is None:
-            nl_len = 0
-            cov_mult = 1
-            while nl_len == 0:
-                logger.info(
-                    "Attempting to find NN distance by searching "
-                    f"within covalent radii times {cov_mult}"
-                )
-                nl = neighbor_list("d", atoms, natural_cutoffs(atoms, mult=cov_mult))
-                nl_len = nl.size
-                cov_mult += 1
             # set the maximum error to 1% of NN distance to follow AFLOW convention
             # rescale by cube root of cell volume to get rough conversion from
             # cartesian to fractional
-            max_resid = nl.min() * 0.01 * atoms.get_volume() ** (-1 / 3)
+            max_resid = (
+                get_smallest_nn_dist(atoms) * 0.01 * atoms.get_volume() ** (-1 / 3)
+            )
             logger.info(
                 "Automatically set max fractional residual for solving position "
                 f"equations to {max_resid}"

kim_tools/kimunits.py

@@ -12,6 +12,8 @@ import re
 import subprocess
 import warnings
 
+import numpy as np
+
 warnings.simplefilter("ignore")
 
 
@@ -24,17 +26,31 @@ _units_output_expression = re.compile(
 )
 
 
-def check_units_util():
+def check_units_util() -> str:
     """
-    Check that units util can be found
+    Figure out if units (first choice) or gunits (second choice) works
+    with the options that we use
     """
+    args = ["-o", r"%1.15e", "-qt1", "0.0 eV/angstrom^3 bar"]
     try:
-        subprocess.check_output(["units", "--help"])
+        output = subprocess.check_output(["units"] + args, encoding="utf-8")
+        assert np.isclose(float(output), 0)
+        units_command = "units"
     except Exception:
-        raise UnitConversion(
-            "Failed to run a 'units' test command. It is likely "
-            "that the 'units' executable was not found."
-        )
+        try:
+            output = subprocess.check_output(["gunits"] + args, encoding="utf-8")
+            assert np.isclose(float(output), 0)
+            units_command = "gunits"
+        except Exception:
+            raise UnitConversion(
+                "Neither "
+                r"units -o %1.15e -qt1 '0.0 eV/angstrom^3 bar'"
+                " nor "
+                r"gunits -o %1.15e -qt1 '0.0 eV/angstrom^3 bar'"
+                " successfully ran and returned 0.e0. Please install a "
+                "compatible version of units."
+            )
+    return units_command
 
 
 def linear_fit(x, y):
@@ -68,7 +84,7 @@ def islinear(unit, to_unit=None):
 
 def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
     """Works with 'units' utility"""
-    check_units_util()
+    units_util = check_units_util()
     from_sign = from_value < 0
     from_value = str(abs(from_value))
     from_unit = str(from_unit)
@@ -77,7 +93,7 @@ def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
 
     if from_unit in TEMPERATURE_FUNCTION_UNITS:
         args = [
-            "units",
+            units_util,
             "-o",
             "%1.15e",
             "-qt1",
@@ -85,7 +101,7 @@ def convert_units(from_value, from_unit, wanted_unit=None, suppress_unit=False):
         ]
 
     else:
-        args = ["units", "-o", "%1.15e", "-qt1", " ".join((from_value, from_unit))]
+        args = [units_util, "-o", "%1.15e", "-qt1", " ".join((from_value, from_unit))]
 
     if wanted_unit:
         args.append(wanted_unit)

kim_tools/symmetry_util/core.py

@@ -9,7 +9,6 @@ from itertools import product
 from math import ceil
 from typing import Dict, List, Optional, Tuple, Union
 
-import matplotlib.pyplot as plt
 import numpy as np
 import numpy.typing as npt
 import sympy as sp
@@ -17,11 +16,9 @@ from ase import Atoms
 from ase.cell import Cell
 from ase.constraints import FixSymmetry
 from ase.geometry import get_distances, get_duplicate_atoms
-from matplotlib.backends.backend_pdf import PdfPages
+from ase.neighborlist import natural_cutoffs, neighbor_list
 from pymatgen.core.operations import SymmOp
 from pymatgen.core.tensors import Tensor
-from scipy.stats import kstest
-from sklearn.decomposition import PCA
 from sympy import Matrix, cos, matrix2numpy, sin, sqrt, symbols
 from sympy.tensor.array.expressions import ArrayContraction, ArrayTensorProduct
 
@@ -50,6 +47,7 @@ __all__ = [
     "change_of_basis_atoms",
     "get_possible_primitive_shifts",
     "get_primitive_genpos_ops",
+    "get_smallest_nn_dist",
 ]
 
 C_CENTERED_ORTHORHOMBIC_GROUPS = (20, 21, 35, 36, 37, 63, 64, 65, 66, 67, 68)
@@ -516,7 +514,9 @@ def get_change_of_basis_matrix_to_conventional_cell_from_formal_bravais_lattice(
     return np.round(change_of_basis_matrix)
 
 
-def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms:
+def change_of_basis_atoms(
+    atoms: Atoms, change_of_basis: npt.ArrayLike, cutoff: Optional[float] = None
+) -> Atoms:
     """
     Perform an arbitrary basis change on an ``Atoms`` object, duplicating or cropping
     atoms as needed. A basic check is made that the determinant of ``change_of_basis``
@@ -524,7 +524,7 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
     that ``change_of_basis`` is appropriate for the particuar crystal described by
     ``atoms``, which is up to the user.
 
-    TODO: Incorporate :func:`kstest_reduced_distances` into this function
+    TODO: Incorporate period extension test into this function
 
     Args:
         atoms:
@@ -543,6 +543,9 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
 
             Relationship between fractional coordinates in each basis:
             **x** = **P** **x**'
+        cutoff:
+            The cutoff to use for deleting duplicate atoms. If not specified,
+            the AFLOW tolerance of 0.01*(smallest NN distance) is used.
 
     Returns:
         The transformed ``Atoms`` object, containing the original number of
@@ -577,7 +580,9 @@ def change_of_basis_atoms(atoms: Atoms, change_of_basis: npt.ArrayLike) -> Atoms
     new_atoms = atoms.repeat(repeat)
     new_atoms.set_cell(new_cell)
     new_atoms.wrap()
-    get_duplicate_atoms(new_atoms, delete=True)
+    if cutoff is None:
+        cutoff = get_smallest_nn_dist(atoms) * 0.01
+    get_duplicate_atoms(new_atoms, cutoff=cutoff, delete=True)
 
     volume_change = np.linalg.det(change_of_basis)
     if not np.isclose(len(atoms) * volume_change, len(new_atoms)):
@@ -634,14 +639,16 @@ def transform_atoms(atoms: Atoms, op: Dict) -> Atoms:
     return atoms_transformed
 
 
-def reduce_and_avg(
-    atoms: Atoms, repeat: Tuple[int, int, int]
-) -> Tuple[Atoms, npt.ArrayLike]:
+def reduce_and_avg(atoms: Atoms, repeat: Tuple[int, int, int]) -> Atoms:
     """
     TODO: Upgrade :func:`change_of_basis_atoms` to provide the distances
     array, obviating this function
 
-    Function to reduce all atoms to the original unit cell position.
+    Function to reduce all atoms to the original unit cell position,
+    assuming the supercell is built from contiguous repeats of the unit cell
+    (i.e. atoms 0 to N-1 in the supercell are the original unit cell, atoms N to
+    2*[N-1] are the original unit cell shifted by an integer multiple of
+    the lattice vectors, and so on)
 
     Args:
         atoms:
@@ -651,10 +658,13 @@ def reduce_and_avg(
             provided supercell
 
     Returns:
-        * The reduced unit cell
-        * An array of displacement vectors. First dimension: index of reference atom
-          in reduced cell. Second dimension: index of atom in provided supercell.
-          Third dimension: x, y, z
+        The reduced unit cell
+
+    Raises:
+        PeriodExtensionException:
+            If two atoms that should be identical by translational symmetry
+            are further than 0.01*(smallest NN distance) apart when
+            reduced to the unit cell
     """
     new_atoms = atoms.copy()
 
@@ -685,126 +695,49 @@ def reduce_and_avg(
     # Start from end of the atoms
     # because we will remove all atoms except the reference ones.
     for i in reversed(range(number_atoms)):
+        reference_atom_index = i % original_number_atoms
         if i >= original_number_atoms:
             # Get the distance to the reference atom in the original unit cell with the
             # minimum image convention.
             distance = new_atoms.get_distance(
-                i % original_number_atoms, i, mic=True, vector=True
+                reference_atom_index, i, mic=True, vector=True
             )
             # Get the position that has the closest distance to
             # the reference atom in the original unit cell.
-            position_i = positions[i % original_number_atoms] + distance
+            position_i = positions[reference_atom_index] + distance
             # Remove atom from atoms object.
             new_atoms.pop()
         else:
             # Atom was part of the original unit cell.
             position_i = positions[i]
         # Average
-        avg_positions_in_prim_cell[i % original_number_atoms] += position_i / M
+        avg_positions_in_prim_cell[reference_atom_index] += position_i / M
         positions_in_prim_cell[i] = position_i
 
     new_atoms.set_positions(avg_positions_in_prim_cell)
 
-    # Calculate the distances.
-    distances = np.empty((original_number_atoms, M, 3))
-    for i in range(number_atoms):
-        dr, _ = get_distances(
-            positions_in_prim_cell[i],
-            avg_positions_in_prim_cell[i % original_number_atoms],
+    # Check that all atoms are within tolerance of their translational images
+    cutoff = get_smallest_nn_dist(new_atoms) * 0.01
+    logger.info(f"Cutoff for period extension test is {cutoff}")
+    for i in range(original_number_atoms):
+        positions_of_all_images_of_atom_i = [
+            positions_in_prim_cell[j * original_number_atoms + i] for j in range(M)
+        ]
+        _, r = get_distances(
+            positions_of_all_images_of_atom_i,
             cell=new_atoms.get_cell(),
             pbc=True,
         )
-        # dr is a distance matrix, here we only have one distance
-        assert dr.shape == (1, 1, 3)
-        distances[i % original_number_atoms, i // original_number_atoms] = dr[0][0]
-
-    return new_atoms, distances
-
-
-def kstest_reduced_distances(
-    reduced_distances: npt.ArrayLike,
-    significance_level: float = 0.05,
-    plot_filename: Optional[str] = None,
-    number_bins: Optional[int] = None,
-) -> None:
-    """
-    TODO: Incorporate this into :func:`change_of_basis_atoms`
-
-    Function to test whether the reduced atom positions are normally distributed
-    around their average.
-
-    Args:
-        reduced_distances:
-            Distance array provided by :func:`reduce_and_avg`
-        significance_level:
-            Significance level for Kolmogorov-Smirnov
-        plot_filename:
-        number_bins:
-            Number of bins for plot
-
-    Raises:
-        PeriodExtensionException:
-            If a non-normal distribution is detected
-    """
-    assert len(reduced_distances.shape) == 3
-    assert reduced_distances.shape[2] == 3
-
-    if plot_filename is not None:
-        if number_bins is None:
-            raise ValueError(
-                "number_bins must be specified if plot_filename is specified"
+        # Checking full MxM matrix, could probably speed up by
+        # checking upper triangle only. Could also save memory
+        # by looping over individual distances instead of
+        # checking the max of a giant matrix
+        assert r.shape == (M, M)
+        if r.max() > cutoff:
+            raise PeriodExtensionException(
+                f"At least one image of atom {i} is outside of tolerance"
             )
-        if not plot_filename.endswith(".pdf"):
-            raise ValueError(f"{plot_filename} is not a PDF file")
-        with PdfPages(plot_filename) as pdf:
-            for i in range(reduced_distances.shape[0]):
-                fig, axs = plt.subplots(1, 3, figsize=(10.0, 4.0))
-                for j in range(reduced_distances.shape[2]):
-                    axs[j].hist(reduced_distances[i, :, j], bins=number_bins)
-                    axs[j].set_xlabel(f"$x_{j}$")
-                axs[0].set_ylabel("Counts")
-                fig.suptitle(f"Atom {i}")
-                pdf.savefig()
-    else:
-        if number_bins is not None:
-            raise ValueError(
-                "number_bins must not be specified if plot_filename is not specified"
-            )
-
-    p_values = np.empty((reduced_distances.shape[0], reduced_distances.shape[2]))
-    for i in range(reduced_distances.shape[0]):
-        atom_distances = reduced_distances[i]
-
-        # Perform PCA on the xyz distribution.
-        pca = PCA(n_components=atom_distances.shape[1])
-        pca_components = pca.fit_transform(atom_distances)
-        assert (
-            pca_components.shape == atom_distances.shape == reduced_distances.shape[1:]
-        )
-
-        # Test each component with a KS test.
-        for j in range(pca_components.shape[1]):
-            component = pca_components[:, j]
-            component_mean = np.mean(component)
-            assert abs(component_mean) < 1.0e-7
-            component_std = np.std(component)
-            # Normalize component
-            normalized_component = (component - component_mean) / component_std
-            assert abs(np.mean(normalized_component)) < 1.0e-7
-            assert abs(np.std(normalized_component) - 1.0) < 1.0e-7
-            res = kstest(normalized_component, "norm")
-            p_values[i, j] = res.pvalue
-
-    if np.any(p_values <= significance_level):
-        raise PeriodExtensionException(
-            "Detected non-normal distribution of reduced atom positions around their "
-            f"average (smallest p value {np.min(p_values)})."
-        )
-    else:
-        print(
-            "Detected normal distribution or reduced atom positions around their "
-            f"average (smallest p value {np.min(p_values)})."
-        )
+    return new_atoms
 
 
 def voigt_to_full_symb(voigt_input: sp.Array) -> sp.MutableDenseNDimArray:
@@ -1073,6 +1006,23 @@ def fit_voigt_tensor_to_cell_and_space_group(
     return t_symmetrized.voigt
 
 
+def get_smallest_nn_dist(atoms: Atoms) -> float:
+    """
+    Get the smallest NN distance in an Atoms object
+    """
+    nl_len = 0
+    cov_mult = 1
+    while nl_len == 0:
+        logger.info(
+            "Attempting to find NN distance by searching "
+            f"within covalent radii times {cov_mult}"
+        )
+        nl = neighbor_list("d", atoms, natural_cutoffs(atoms, mult=cov_mult))
+        nl_len = nl.size
+        cov_mult += 1
+    return nl.min()
+
+
 class FixProvidedSymmetry(FixSymmetry):
     """
     A modification of :obj:`~ase.constraints.FixSymmetry` that takes

kim_tools/test_driver/core.py

@@ -35,9 +35,11 @@ import json
 import logging
 import os
 import shutil
+import tarfile
 from abc import ABC, abstractmethod
 from copy import deepcopy
 from pathlib import Path
+from secrets import token_bytes
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 from typing import IO, Any, Dict, List, Optional, Union
 
@@ -109,6 +111,8 @@ PROP_SEARCH_PATHS_INFO = (
     "- $PWD/local-props/**/\n"
     "- $PWD/local_props/**/"
 )
+TOKEN_NAME = "kim-tools.token"
+TOKENPATH = os.path.join("output", TOKEN_NAME)
 
 
 def get_supported_lammps_atom_style(model: str) -> str:
@@ -395,8 +399,15 @@ def _add_property_instance(
                                 property_name = path_str
                                 found_custom_property = True
                                 break
-                    except Exception:
-                        pass
+                    except Exception as e:
+                        msg = (
+                            "MESSAGE: Trying to load a property from the .edn file at\n"
+                            f"{path}\n"
+                            "failed with the following exception:\n"
+                            f"{repr(e)}"
+                        )
+                        logger.info(msg)
+                        print(msg)
 
         if not found_custom_property:
             raise KIMTestDriverError(
@@ -550,6 +561,14 @@ class KIMTestDriver(ABC):
         __output_property_instances (str):
             Property instances, possibly accumulated over multiple invocations of
             the Test Driver
+        __files_to_keep_in_output (List[PathLike]):
+            List of files that were written by this class explicitly, that we won't
+            touch when cleaning and backing up the output directory. Specified
+            relative to 'output' directory.
+        __token (Optional[bytes]):
+            Token that is written to TOKENPATH upon first evaluation. This
+            is used to check that multiple Test Drivers are not being called
+            concurrently, causing potential conflicts in the output directory
     """
 
     class NonKIMModelError(Exception):
@@ -582,6 +601,8 @@ class KIMTestDriver(ABC):
                     self.__calc.parameters.log_file = None
 
         self.__output_property_instances = "[]"
+        self.__files_to_keep_in_output = []
+        self.__token = None
 
     def _setup(self, material, **kwargs) -> None:
         """
@@ -589,6 +610,106 @@ class KIMTestDriver(ABC):
         """
         pass
 
+    def _init_output_dir(self) -> None:
+        """
+        Initialize the output directory
+        """
+        if self.__token is None:
+            # First time we've called this instance of the class
+            assert len(self.property_instances) == 0
+
+            os.makedirs("output", exist_ok=True)
+
+            # Move all top-level non-hidden files and directories
+            # to backup
+            output_glob = glob.glob("output/*")
+            if len(output_glob) > 0:
+                i = 0
+                while os.path.exists(f"output.{i}"):
+                    i += 1
+                output_bak_name = f"output.{i}"
+                msg = (
+                    "'output' directory is non-empty, backing up all "
+                    f"non-hidden files and directories to {output_bak_name}"
+                )
+                print(msg)
+                logger.info(msg)
+                os.mkdir(output_bak_name)
+                for file_in_output in output_glob:
+                    shutil.move(file_in_output, output_bak_name)
+
+            # Create token
+            self.__token = token_bytes(16)
+            with open(TOKENPATH, "wb") as f:
+                f.write(self.__token)
+            self.__files_to_keep_in_output.append(TOKEN_NAME)
+        else:
+            # Token is stored, check that it matches the token file
+            if not os.path.isfile(TOKENPATH):
+                raise KIMTestDriverError(
+                    f"Token file at {TOKENPATH} was not found,"
+                    "can't confirm non-interference of Test Drivers. Did something "
+                    "edit the 'output' directory between calls to this Test Driver?"
+                )
+            else:
+                with open(TOKENPATH, "rb") as f:
+                    if self.__token != f.read():
+                        raise KIMTestDriverError(
+                            f"Token file at {TOKENPATH} does not match this object's "
+                            "token. This likely means that a different KIMTestDriver "
+                            "instance was called between calls to this one. In order to"
+                            " prevent conflicts in the output directory, this is not "
+                            "allowed."
+                        )
+
+        # We should have a record of all non-hidden files in output. If any
+        # untracked files are present, raise an error
+        output_glob = glob.glob("output/**", recursive=True)
+        for filepath in output_glob:
+            if os.path.isfile(filepath):  # not tracking directories
+                if (
+                    os.path.relpath(filepath, "output")
+                    not in self.__files_to_keep_in_output
+                ):
+                    raise KIMTestDriverError(
+                        f"Unknown file {filepath} in 'output' directory appeared "
+                        "between calls to this Test Driver. This is not allowed "
+                        "because stray files can cause issues."
+                    )
+
+    def _archive_aux_files(self) -> None:
+        """
+        Archive aux files after a run
+        """
+        # Archive untracked files as aux files
+        i = 0
+        while f"aux_files.{i}.txz" in self.__files_to_keep_in_output:
+            assert os.path.isfile(f"output/aux_files.{i}.txz")
+            i += 1
+        tar_prefix = f"aux_files.{i}"
+        output_glob = glob.glob("output/**", recursive=True)
+        archived_files = []  # For deleting them later
+        with tarfile.open(f"output/{tar_prefix}.txz", "w:xz") as tar:
+            for filepath in output_glob:
+                if os.path.isfile(filepath):  # not tracking directories
+                    output_relpath = os.path.relpath(filepath, "output")
+                    if output_relpath not in self.__files_to_keep_in_output:
+                        tar.add(
+                            os.path.join(filepath),
+                            os.path.join(tar_prefix, output_relpath),
+                        )
+                        archived_files.append(filepath)
+        self.__files_to_keep_in_output.append(f"{tar_prefix}.txz")
+        for filepath in archived_files:
+            os.remove(filepath)
+            try:
+                os.removedirs(os.path.dirname(filepath))
+            except OSError:
+                pass  # might not be empty yet
+
+        # should not have removed output dir in any situation
+        assert os.path.isdir("output")
+
     @abstractmethod
     def _calculate(self, **kwargs) -> None:
         """
@@ -603,8 +724,10 @@ class KIMTestDriver(ABC):
 
             * Run :func:`~KIMTestDriver._setup` (the base class provides a barebones
               version, derived classes may override)
+            * Call :func:`~KIMTestDriver._init_output_dir`
             * Call :func:`~KIMTestDriver._calculate` (implemented by each individual
               Test Driver)
+            * Call :func:`~KIMTestDriver._archive_aux_files`
 
         Args:
             material:
@@ -614,10 +737,12 @@ class KIMTestDriver(ABC):
         Returns:
             The property instances calculated during the current run
         """
+
         # count how many instances we had before we started
-        previous_properties_end = len(kim_edn.loads(self.__output_property_instances))
+        previous_properties_end = len(self.property_instances)
 
-        os.makedirs("output", exist_ok=True)
+        # Set up the output directory
+        self._init_output_dir()
 
         # _setup is likely overridden by an derived class
         self._setup(material, **kwargs)
@@ -625,9 +750,12 @@ class KIMTestDriver(ABC):
         # implemented by each individual Test Driver
         self._calculate(**kwargs)
 
+        # Postprocess output directory for this invocation
+        self._archive_aux_files()
+
         # The current invocation returns a Python list of dictionaries containing all
         # properties computed during this run
-        return kim_edn.loads(self.__output_property_instances)[previous_properties_end:]
+        return self.property_instances[previous_properties_end:]
 
     def _add_property_instance(
         self, property_name: str, disclaimer: Optional[str] = None
@@ -745,7 +873,7 @@ class KIMTestDriver(ABC):
 
         input_name = filename_path.name
         if add_instance_id:
-            current_instance_id = len(kim_edn.loads(self.__output_property_instances))
+            current_instance_id = len(self.property_instances)
             root, ext = os.path.splitext(input_name)
             root = root + "-" + str(current_instance_id)
             final_name = root + ext
@@ -758,10 +886,10 @@ class KIMTestDriver(ABC):
 
         shutil.move(filename, final_path)
 
+        output_relpath = os.path.relpath(final_path, output_path)
         # Filenames are reported relative to $CWD/output
-        self._add_key_to_current_property_instance(
-            name, os.path.relpath(final_path, output_path)
-        )
+        self._add_key_to_current_property_instance(name, output_relpath)
+        self.__files_to_keep_in_output.append(output_relpath)
 
     def _get_supported_lammps_atom_style(self) -> str:
         """
@@ -834,17 +962,14 @@ class KIMTestDriver(ABC):
         os.makedirs(filename_parent, exist_ok=True)
         kim_property_dump(self._get_serialized_property_instances(), filename)
         if filename_parent != Path("output").resolve():
-            for file_in_output in glob.glob("output/*"):
-                file_in_output_name = str(Path(file_in_output).name)
-                for instance in self.property_instances:
-                    for key in instance:
-                        if isinstance(instance[key], dict):
-                            if file_in_output_name == instance[key]["source-value"]:
-                                shutil.move(file_in_output, filename_parent)
-                            elif isinstance(instance[key]["source-value"], list):
-                                for file_in_property in instance[key]["source-value"]:
-                                    if file_in_output_name == file_in_property:
-                                        shutil.move(file_in_output, filename_parent)
+            msg = (
+                f"Writing properties .edn file to non-standard location {filename}. "
+                "note that all other files remain in 'output' directory."
+            )
+            print(msg)
+            logger.info(msg)
+        else:
+            self.__files_to_keep_in_output.append(os.path.relpath(filename, "output"))
 
     def get_isolated_energy_per_atom(self, symbol: str) -> float:
         """

{kim_tools-0.3.13.dist-info → kim_tools-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kim-tools
-Version: 0.3.13
+Version: 0.4.2
 Summary: Base classes and helper routines for writing KIM Tests
 Author-email: ilia Nikiforov <nikif002@umn.edu>, Ellad Tadmor <tadmor@umn.edu>, Claire Waters <bwaters@umn.edu>, "Daniel S. Karls" <karl0100umn@gmail.com>, Matt Bierbaum <matt.bierbaum@gmail.com>, Eric Fuemmeler <efuemmel@umn.edu>, Philipp Hoellmer <ph2484@nyu.edu>, Guanming Zhang <gz2241@nyu.edu>, Tom Egg <tje3676@nyu.edu>, Navaneeth Mohan <mohan227@umn.edu>
 Maintainer-email: ilia Nikiforov <nikif002@umn.edu>
@@ -35,6 +35,7 @@ Dynamic: license-file
 [![Testing](https://github.com/openkim/kim-tools/actions/workflows/testing.yml/badge.svg)](https://github.com/openkim/kim-tools/actions/workflows/testing.yml)
 [![docs](https://app.readthedocs.org/projects/kim-tools/badge/?version=latest)](https://kim-tools.readthedocs.io/en/latest/)
 [![PyPI](https://img.shields.io/pypi/v/kim-tools.svg)](https://pypi.org/project/kim-tools/)
+[![codecov](https://codecov.io/gh/openkim/kim-tools/graph/badge.svg?token=G57VDZYY0F)](https://codecov.io/gh/openkim/kim-tools)
 
 KIMTestDriver and SingleCrystalTestDriver classes for creating OpenKIM Test Drivers, and helper routines for writing
 KIM Tests and Verification Checks. Documentation at https://kim-tools.readthedocs.io.

{kim_tools-0.3.13.dist-info → kim_tools-0.4.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-kim_tools/__init__.py,sha256=z9M4HWOpT0qCOUbGIKeUY-Oskrw_ZG6xeXli9iLTyzo,434
-kim_tools/kimunits.py,sha256=jOxBv9gRVhxPE6ygAIUxOzCAfPI6tT6sBaF_FNl9m-M,5387
+kim_tools/__init__.py,sha256=ATvBQMEr5NBWxGzIDxLFJxMZIXTwxIx5RVS5-OO4H98,433
+kim_tools/kimunits.py,sha256=aCouh7z6fQDR1rcbRTO72l-_RuccuznrKrNF18F-cEQ,6076
 kim_tools/aflow_util/__init__.py,sha256=lJnQ8fZCma80QVRQeKvY4MQ87oCWu-9KATV3dKJfpDc,80
-kim_tools/aflow_util/core.py,sha256=mMS2r9ayJJ6ApOFTAIkCZ72Dg3g1EnREbrqe2YEipMo,81273
+kim_tools/aflow_util/core.py,sha256=OmU4-m2jl81jfs0ni4bSECpC8GYt7-hEEH7cfKmrdoM,80886
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A108B24C11D24_cP334_222_h4i_i_bf_i-001/info.json,sha256=IsFiO9X2Ko7yoq2QkDurUVP7k1BE4WFgblu7oxl6iZs,2013
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A10B11_tI84_139_dehim_eh2n-001/info.json,sha256=f1EdtouuSL2y9NNw40Rvz2J9ZZcsqQBcyEmlHj6XoW8,1186
 kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A10B2C_hP39_171_5c_c_a-001/info.json,sha256=vD1xjZKWShL0E6XNsSlmIhilGcGNefl56oQDLQlHO1M,1596
@@ -2004,7 +2004,7 @@ kim_tools/aflow_util/aflow_prototype_encyclopedia/data/A_tP50_134_a2m2n-001/info
 kim_tools/ase/__init__.py,sha256=1i6ko5tNr0VZC3T7hoEzq4fnSU0DdxNpxXcSaWMcJWc,76
 kim_tools/ase/core.py,sha256=umJY0LV3_zrEZLOXAFoz6AFigxA69sAOBzAGoBTDzxA,34335
 kim_tools/symmetry_util/__init__.py,sha256=uu-ZSUDUTe2P81rkAS3tXverx31s_uZ3wL4SD_dn5aI,86
-kim_tools/symmetry_util/core.py,sha256=eMGgVt9MPcaLi_8jVMJ5UyQHvYbiiAFQ4HdJotnp8dk,43277
+kim_tools/symmetry_util/core.py,sha256=y9LGnUYxWE5e5KMxzM96t_UzrC-B_aT3XnntW8p_jRA,41392
 kim_tools/symmetry_util/elasticity.py,sha256=VxJ8wUcsSOPyJ8id6OpKmVlRAbIUIWxtzYJtkvVJIVs,13328
 kim_tools/symmetry_util/data/elast_cubic.svg,sha256=UpN4XcoLoOwv8a7KE0WyINkSH5AU2DPVZ08eGQf-Cds,8953
 kim_tools/symmetry_util/data/elast_hexagonal.svg,sha256=wOkw5IO3fZy039tLHhvtwrkatVYs5XzigUormLKtRlw,8705
@@ -2023,11 +2023,11 @@ kim_tools/symmetry_util/data/wyck_pos_xform_under_normalizer.json,sha256=6g1YuYh
 kim_tools/symmetry_util/data/wyckoff_multiplicities.json,sha256=qG2RPBd_-ejDIfz-E4ZhkHyRpIboxRy7oiXkdDf5Eg8,32270
 kim_tools/symmetry_util/data/wyckoff_sets.json,sha256=f5ZpHKDHo6_JWki1b7KUGoYLlhU-44Qikw_-PtbLssw,9248
 kim_tools/test_driver/__init__.py,sha256=KOiceeZNqkfrgZ66CiRiUdniceDrCmmDXQkOw0wXaCQ,92
-kim_tools/test_driver/core.py,sha256=vHmhSWix5t95SCmJEapdpZXfJS0ZlbG-8bcmV9O9v9M,101261
+kim_tools/test_driver/core.py,sha256=ugPL_wDzKwT7ch7Xh6SFMCLTF1Qf8x405HqcGJ29fd4,106587
 kim_tools/vc/__init__.py,sha256=zXjhxXCKVMLBMXXWYG3if7VOpBnsFrn_RjVpnohDm5c,74
 kim_tools/vc/core.py,sha256=BIjzEExnQAL2S90a_npptRm3ACqAo4fZBtvTDBMWMdw,13963
-kim_tools-0.3.13.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
-kim_tools-0.3.13.dist-info/METADATA,sha256=7ldqSmsLFyzrEtIeV-wJacw1BEJoj55DgMOupJlycIs,2069
-kim_tools-0.3.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-kim_tools-0.3.13.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
-kim_tools-0.3.13.dist-info/RECORD,,
+kim_tools-0.4.2.dist-info/licenses/LICENSE.CDDL,sha256=I2luEED_SHjuZ01B4rYG-AF_135amL24JpHvZ1Jhqe8,16373
+kim_tools-0.4.2.dist-info/METADATA,sha256=dCmTQkNmZhR6y-2GtlwbgMnFMh14kgKgTlkvGL4UHpw,2196
+kim_tools-0.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kim_tools-0.4.2.dist-info/top_level.txt,sha256=w_YCpJ5ERigj9te74ln7k64tqj1VumOzM_s9dsalIWY,10
+kim_tools-0.4.2.dist-info/RECORD,,