Fix TestMPScanStaticSet.test_as_from_dict() (#3266)

* fix TestMPScanStaticSet test-as_from_dict()

* rename Kpoint private attrs _ccoords->_cart_coords, _fcoords->_frac_coords

* delete test_surface.py's get_path() and refactor test path construction

Author: janosh

pymatgen/alchemy/transmuters.py

@@ -346,9 +346,9 @@ def batch_write_vasp_input(
         formula = re.sub(r"\s+", "", struct.final_structure.formula)
         if subfolder is not None:
             subdir = subfolder(struct)
-            dirname = os.path.join(output_dir, subdir, f"{formula}_{idx}")
+            dirname = f"{output_dir}/{subdir}/{formula}_{idx}"
         else:
-            dirname = os.path.join(output_dir, f"{formula}_{idx}")
+            dirname = f"{output_dir}/{formula}_{idx}"
         struct.write_vasp_input(vasp_input_set, dirname, create_directory=create_directory, **kwargs)
         if include_cif:
             from pymatgen.io.cif import CifWriter

pymatgen/analysis/elasticity/strain.py

@@ -38,9 +38,8 @@ class Deformation(SquareTensor):
 
     def __new__(cls, deformation_gradient):
         """
-        Create a Deformation object. Note that the constructor uses __new__
-        rather than __init__ according to the standard method of subclassing
-        numpy ndarrays.
+        Create a Deformation object. Note that the constructor uses __new__ rather than
+        __init__ according to the standard method of subclassing numpy ndarrays.
 
         Args:
             deformation_gradient (3x3 array-like): the 3x3 array-like

pymatgen/electronic_structure/bandstructure.py

@@ -54,14 +54,14 @@ def __init__(
             label: the label of the kpoint if any (None by default).
         """
         self._lattice = lattice
-        self._fcoords = lattice.get_fractional_coords(coords) if coords_are_cartesian else coords
+        self._frac_coords = lattice.get_fractional_coords(coords) if coords_are_cartesian else coords
         self._label = label
 
         if to_unit_cell:
-            for i, fc in enumerate(self._fcoords):
-                self._fcoords[i] -= math.floor(fc)
+            for idx, fc in enumerate(self._frac_coords):
+                self._frac_coords[idx] -= math.floor(fc)
 
-        self._ccoords = lattice.get_cartesian_coords(self._fcoords)
+        self._cart_coords = lattice.get_cartesian_coords(self._frac_coords)
 
     @property
     def lattice(self):
@@ -78,27 +78,27 @@ def label(self):
     @property
     def frac_coords(self):
         """The fractional coordinates of the kpoint as a numpy array."""
-        return np.copy(self._fcoords)
+        return np.copy(self._frac_coords)
 
     @property
     def cart_coords(self):
         """The Cartesian coordinates of the kpoint as a numpy array."""
-        return np.copy(self._ccoords)
+        return np.copy(self._cart_coords)
 
     @property
     def a(self):
         """Fractional a coordinate of the kpoint."""
-        return self._fcoords[0]
+        return self._frac_coords[0]
 
     @property
     def b(self):
         """Fractional b coordinate of the kpoint."""
-        return self._fcoords[1]
+        return self._frac_coords[1]
 
     @property
     def c(self):
         """Fractional c coordinate of the kpoint."""
-        return self._fcoords[2]
+        return self._frac_coords[2]
 
     def __str__(self):
         """Returns a string with fractional, Cartesian coordinates and label."""

tests/core/test_lattice.py

@@ -459,9 +459,9 @@ def test_lll_basis(self):
         l1 = Lattice([a, b, c])
         l2 = Lattice([a + b, b + c, c])
 
-        ccoords = np.array([[1, 1, 2], [2, 2, 1.5]])
-        l1_fcoords = l1.get_fractional_coords(ccoords)
-        l2_fcoords = l2.get_fractional_coords(ccoords)
+        cart_coords = np.array([[1, 1, 2], [2, 2, 1.5]])
+        l1_fcoords = l1.get_fractional_coords(cart_coords)
+        l2_fcoords = l2.get_fractional_coords(cart_coords)
 
         assert_allclose(l1.matrix, l2.lll_matrix)
         assert_allclose(np.dot(l2.lll_mapping, l2.matrix), l1.matrix)

tests/core/test_surface.py

@@ -29,20 +29,16 @@
 from pymatgen.util.testing import TEST_FILES_DIR, PymatgenTest
 
 
-def get_path(path_str):
-    return os.path.join(TEST_FILES_DIR, "surface_tests", path_str)
-
-
 class TestSlab(PymatgenTest):
     def setUp(self):
-        zno1 = Structure.from_file(get_path("ZnO-wz.cif"), primitive=False)
+        zno1 = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/ZnO-wz.cif", primitive=False)
         zno55 = SlabGenerator(zno1, [1, 0, 0], 5, 5, lll_reduce=False, center_slab=False).get_slab()
 
         Ti = Structure(
             Lattice.hexagonal(4.6, 2.82),
             ["Ti", "Ti", "Ti"],
             [
-                [0.000000, 0.000000, 0.000000],
+                [0, 0, 0],
                 [0.333333, 0.666667, 0.500000],
                 [0.666667, 0.333333, 0.500000],
             ],
@@ -52,10 +48,10 @@ def setUp(self):
             Lattice.cubic(4.06),
             ["Ag", "Ag", "Ag", "Ag"],
             [
-                [0.000000, 0.000000, 0.000000],
-                [0.000000, 0.500000, 0.500000],
-                [0.500000, 0.000000, 0.500000],
-                [0.500000, 0.500000, 0.000000],
+                [0, 0, 0],
+                [0, 0.500000, 0.500000],
+                [0.500000, 0, 0.500000],
+                [0.500000, 0.500000, 0],
             ],
         )
 
@@ -68,7 +64,7 @@ def setUp(self):
         self.agfcc = Ag_fcc
         self.zno1 = zno1
         self.zno55 = zno55
-        self.nonlaue = non_laue
+        self.non_laue = non_laue
         self.h = Structure(Lattice.cubic(3), ["H"], [[0, 0, 0]])
         self.libcc = Structure(Lattice.cubic(3.51004), ["Li", "Li"], [[0, 0, 0], [0.5, 0.5, 0.5]])
 
@@ -235,7 +231,7 @@ def test_symmetrization(self):
             assert symmetric_count == len(slabs)
 
         # Check if we can generate symmetric slabs from bulk with no inversion
-        all_non_laue_slabs = generate_all_slabs(self.nonlaue, 1, 15, 15, symmetrize=True)
+        all_non_laue_slabs = generate_all_slabs(self.non_laue, 1, 15, 15, symmetrize=True)
         assert len(all_non_laue_slabs) > 0
 
     def test_get_symmetric_sites(self):
@@ -393,26 +389,7 @@ def test_get_slab(self):
                 and (
                     sg.symbol.endswith("H")
                     or sg.int_number
-                    in [
-                        143,
-                        144,
-                        145,
-                        147,
-                        149,
-                        150,
-                        151,
-                        152,
-                        153,
-                        154,
-                        156,
-                        157,
-                        158,
-                        159,
-                        162,
-                        163,
-                        164,
-                        165,
-                    ]
+                    in [143, 144, 145, 147, 149, 150, 151, 152, 153, 154, 156, 157, 158, 159, 162, 163, 164, 165]
                 )
             ):
                 latt = Lattice.hexagonal(5, 10)
@@ -484,7 +461,7 @@ def test_get_slabs(self):
         # slabs is of sites in LiFePO4 unit cell - 2 + 1.
         assert len(gen.get_slabs(tol=1e-4, ftol=1e-4)) == 15
 
-        LiCoO2 = Structure.from_file(get_path("icsd_LiCoO2.cif"), primitive=False)
+        LiCoO2 = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_LiCoO2.cif", primitive=False)
         gen = SlabGenerator(LiCoO2, [0, 0, 1], 10, 10)
         lco = gen.get_slabs(bonds={("Co", "O"): 3})
         assert len(lco) == 1
@@ -518,14 +495,14 @@ def test_triclinic_TeI(self):
         # in other Miller indices can cause some ambiguity when choosing a
         # higher tolerance.
         numb_slabs = {(0, 0, 1): 5, (0, 1, 0): 3, (1, 0, 0): 7}
-        TeI = Structure.from_file(get_path("icsd_TeI.cif"), primitive=False)
+        TeI = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_TeI.cif", primitive=False)
         for k, v in numb_slabs.items():
             trclnc_TeI = SlabGenerator(TeI, k, 10, 10)
             TeI_slabs = trclnc_TeI.get_slabs()
             assert v == len(TeI_slabs)
 
     def test_get_orthogonal_c_slab(self):
-        TeI = Structure.from_file(get_path("icsd_TeI.cif"), primitive=False)
+        TeI = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_TeI.cif", primitive=False)
         trclnc_TeI = SlabGenerator(TeI, (0, 0, 1), 10, 10)
         TeI_slabs = trclnc_TeI.get_slabs()
         slab = TeI_slabs[0]
@@ -534,7 +511,7 @@ def test_get_orthogonal_c_slab(self):
         assert norm_slab.lattice.angles[1] == approx(90)
 
     def test_get_orthogonal_c_slab_site_props(self):
-        TeI = Structure.from_file(get_path("icsd_TeI.cif"), primitive=False)
+        TeI = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_TeI.cif", primitive=False)
         trclnc_TeI = SlabGenerator(TeI, (0, 0, 1), 10, 10)
         TeI_slabs = trclnc_TeI.get_slabs()
         slab = TeI_slabs[0]
@@ -719,7 +696,7 @@ def test_previous_reconstructions(self):
                 el = self.Si[0].species_string
 
             slabs = rec.build_slabs()
-            struct = Structure.from_file(get_path(os.path.join("reconstructions", el + "_" + n + ".cif")))
+            struct = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/reconstructions/{el}_{n}.cif")
             assert any(len(m.group_structures([struct, slab])) == 1 for slab in slabs)
 
 
@@ -730,8 +707,8 @@ def setUp(self):
         mglatt = Lattice.from_parameters(3.2, 3.2, 5.13, 90, 90, 120)
         self.Mg = Structure(mglatt, ["Mg", "Mg"], [[1 / 3, 2 / 3, 1 / 4], [2 / 3, 1 / 3, 3 / 4]])
         self.lifepo4 = self.get_structure("LiFePO4")
-        self.tei = Structure.from_file(get_path("icsd_TeI.cif"), primitive=False)
-        self.LiCoO2 = Structure.from_file(get_path("icsd_LiCoO2.cif"), primitive=False)
+        self.tei = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_TeI.cif", primitive=False)
+        self.LiCoO2 = Structure.from_file(f"{TEST_FILES_DIR}/surface_tests/icsd_LiCoO2.cif", primitive=False)
 
         self.p1 = Structure(
             Lattice.from_parameters(3, 4, 5, 31, 43, 50),

tests/files/.pytest-split-durations

@@ -1570,7 +1570,7 @@
     "tests/io/exciting/test_inputs.py::TestExcitingInput::test_fromfile": 0.0033374580089002848,
     "tests/io/exciting/test_inputs.py::TestExcitingInput::test_paramdict": 0.008810124010778964,
     "tests/io/exciting/test_inputs.py::TestExcitingInput::test_writebandstr": 0.009053541987668723,
-    "tests/io/exciting/test_inputs.py::TestExcitingInput::test_writestring": 0.01415829302277416,
+    "tests/io/exciting/test_inputs.py::TestExcitingInput::test_write_string": 0.01415829302277416,
     "tests/io/feff/test_inputs.py::TestFeffAtoms::test_absorber_line": 0.007966249017044902,
     "tests/io/feff/test_inputs.py::TestFeffAtoms::test_absorbing_atom": 0.0037107079406268895,
     "tests/io/feff/test_inputs.py::TestFeffAtoms::test_as_dict_and_from_dict": 0.025775165995582938,

tests/io/exciting/test_inputs.py

@@ -26,16 +26,16 @@ def test_fromfile(self):
         # Test for the import of a structure directly from an exciting
         # input file
         filepath = f"{TEST_FILES_DIR}/input_exciting1.xml"
-        excin = ExcitingInput.from_file(filepath)
+        exc_input = ExcitingInput.from_file(filepath)
         lattice = [[0.0, 2.81, 2.81], [2.81, 0.0, 2.81], [2.81, 2.81, 0.0]]
         atoms = ["Na", "Cl"]
-        fraccoords = [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]]
-        assert_allclose(lattice, excin.structure.lattice.matrix.tolist())
-        assert atoms == [site.specie.symbol for site in excin.structure]
-        assert fraccoords == [site.frac_coords.tolist() for site in excin.structure]
+        frac_coords = [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]]
+        assert_allclose(lattice, exc_input.structure.lattice.matrix.tolist())
+        assert atoms == [site.specie.symbol for site in exc_input.structure]
+        assert frac_coords == [site.frac_coords.tolist() for site in exc_input.structure]
 
-    def test_writestring(self):
-        # Test for the string export of s atructure into the exciting input xml schema
+    def test_write_string(self):
+        # Test for the string export of structure into the exciting input xml schema
         input_string = (
             '<input xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
             'xsi:noNamespaceSchemaLocation="http://xml.exciting-code.org/excitinginput'