Apply ruff fixes

Author: ElliottKasoar

abcd/parsers/extras.py

@@ -97,7 +97,7 @@ def string(self, s):
 if __name__ == "__main__":
     test_string = " ".join(
         [
-            " " "flag",  # start with a separator
+            " flag",  # start with a separator
             'quotedd_string="quoteddd value"',
             r'quotedddd_string_escaped="esc\"aped"',
             "false_value = F",

tests/hash.py

@@ -0,0 +1,47 @@
+import io
+
+import ase
+from ase.calculators.lj import LennardJones
+import ase.io
+import numpy as np
+import pytest
+
+from abcd.model import AbstractModel
+
+
+@pytest.fixture
+def rng():
+    return np.random.default_rng(seed=42)
+
+
+def test_hash_structure(rng):
+    # create atoms & add a calculator
+    atoms = ase.Atoms(
+        "H3",
+        positions=rng.random(size=(3, 3)),
+        pbc=True,
+        cell=[2, 2, 2],
+    )
+    atoms.calc = LennardJones()
+    atoms.calc.calculate(atoms)
+
+    # dump to XYZ
+    buffer = io.StringIO()
+    ase.io.write(buffer, atoms, format="extxyz")
+
+    # read back
+    buffer.seek(0)
+    atoms_read = ase.io.read(buffer, format="extxyz")
+    assert atoms.positions[0, 0] == pytest.approx(atoms_read.positions[0, 0], abs=1e-10)
+
+    # read in both of them
+    abcd_data = AbstractModel.from_atoms(atoms)
+    abcd_data_after_read = AbstractModel.from_atoms(atoms_read)
+
+    assert atoms_read.positions[0, 0:5] == pytest.approx(
+        atoms.positions[0, 0:5], abs=1e-10
+    )
+    assert abcd_data["hash_structure"] == abcd_data_after_read["hash_structure"], (
+        atoms.positions,
+        atoms_read.positions,
+    )

tests/test_abstract_model.py

@@ -229,29 +229,29 @@ def test_write_and_read(store_calc):
         "calculator_name",
         "calculator_parameters",
     }:
-        assert (
-            abcd_data[key] == abcd_data_after_read[key]
-        ), f"{key}'s value does not match"
+        assert abcd_data[key] == abcd_data_after_read[key], (
+            f"{key}'s value does not match"
+        )
 
     # date & hashed will differ
     for key in set(abcd_data.derived_keys) - {
         "hash",
         "modified",
         "uploaded",
     }:
-        assert (
-            abcd_data[key] == abcd_data_after_read[key]
-        ), f"{key}'s value does not match"
+        assert abcd_data[key] == abcd_data_after_read[key], (
+            f"{key}'s value does not match"
+        )
 
     # expected differences - n.b. order of calls above
     assert abcd_data_after_read["modified"] > abcd_data["modified"]
     assert abcd_data_after_read["uploaded"] > abcd_data["uploaded"]
 
     # expect results to match within fp precision
     for key in set(abcd_data.results_keys):
-        assert abcd_data[key] == approx(
-            np.array(abcd_data_after_read[key])
-        ), f"{key}'s value does not match"
+        assert abcd_data[key] == approx(np.array(abcd_data_after_read[key])), (
+            f"{key}'s value does not match"
+        )
 
 
 def test_hash_update():

tests/test_parsers.py

@@ -140,7 +140,7 @@ def test_composite(self, parser):
             'a3x3_array="1 4 7 2 5 8 3 6 9" '  # fortran ordering
             'Lattice="  4.3  0.0 0.0 0.0  3.3 0.0 0.0 0.0  7.0 " '  # spaces in array
             'comma_separated="7, 4, -1"',
-            'array_boolean_2=" T, F, T " ' 'not_array="1.2 3.4 text"',  # leading spaces
+            'array_boolean_2=" T, F, T " not_array="1.2 3.4 text"',  # leading spaces
             "not_bool_array=[T F S]",
         ],
     )