[pre-commit.ci] pre-commit autoupdate

.pre-commit-config.yaml

@@ -24,7 +24,7 @@ repos:
     hooks:
     -   id: black-jupyter
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.282
+    rev: v0.0.284
     hooks:
     - id: ruff
       args: ["--fix"]

dpgen/auto_test/gen_confs.py

@@ -50,7 +50,7 @@
 
 
 def gen_element(ele_name, key):
-    assert type(ele_name) == str
+    assert isinstance(ele_name, str)
     mpr = MPRester(key)
     data = mpr.query(
         {"elements": [ele_name], "nelements": 1},
@@ -87,7 +87,7 @@
 
 
 def gen_element_std(ele_name):
-    assert type(ele_name) == str
+    assert isinstance(ele_name, str)
     for ii in global_std_crystal.keys():
         ss = gen_ele_std(ele_name, ii)
 

dpgen/auto_test/lib/mfp_eosfit.py

@@ -1668,11 +1668,7 @@
         )
         fve.flush()
         p_tmp = repro_press[i]
-        fvp.write(
-            "{:20f}\t{:20f}\t{:20f}\t{:20f}\n".format(
-                vol[i], p_tmp, p_tmp / 100, p_tmp * 10
-            )
-        )
+        fvp.write(f"{vol[i]:20f}\t{p_tmp:20f}\t{p_tmp / 100:20f}\t{p_tmp * 10:20f}\n")
         fvp.flush()
     fve.close()
     fvp.close()

dpgen/auto_test/lib/vasp.py

@@ -112,7 +112,7 @@ def reciprocal_box(box):
 
 
 def make_kspacing_kpoints(poscar, kspacing, kgamma):
-    if type(kspacing) is not list:
+    if not isinstance(kspacing, list):
         kspacing = [kspacing, kspacing, kspacing]
     with open(poscar) as fp:
         lines = fp.read().split("\n")

dpgen/data/gen.py

@@ -576,7 +576,7 @@
     )  # a dictionary in which all of the values are strings
     if "kspacing" not in standard_incar:
         if "gamma_only" in standard_incar:
-            if type(standard_incar["gamma_only"]) == str:
+            if isinstance(standard_incar["gamma_only"], str):
                 standard_incar["gamma_only"] = int(eval(standard_incar["gamma_only"]))
             if standard_incar["gamma_only"] == 0:
                 if "relax_kpt" not in jdata:
@@ -917,7 +917,7 @@
     #        "Cannot find any k-points information."
     if "kspacing" not in standard_incar:
         if "gamma_only" in standard_incar:
-            if type(standard_incar["gamma_only"]) == str:
+            if isinstance(standard_incar["gamma_only"], str):
                 standard_incar["gamma_only"] = int(eval(standard_incar["gamma_only"]))
             if standard_incar["gamma_only"] == 0:
                 if "md_kpt" not in jdata:
@@ -1090,8 +1090,8 @@
         arg_cvt = " "
         if len(valid_outcars) == 0:
             raise RuntimeError(
-                "MD dir: {}: find no valid outcar in sys {}, "
-                "check if your vasp md simulation is correctly done".format(path_md, ii)
+                f"MD dir: {path_md}: find no valid outcar in sys {ii}, "
+                "check if your vasp md simulation is correctly done"
             )
 
         flag = True
@@ -1228,10 +1228,8 @@
         arg_cvt = " "
         if len(valid_outcars) == 0:
             raise RuntimeError(
-                "MD dir: {}: find no valid OUT.ABACUS in sys {}, "
-                "check if your abacus md simulation is correctly done.".format(
-                    path_md, ii
-                )
+                f"MD dir: {path_md}: find no valid OUT.ABACUS in sys {ii}, "
+                "check if your abacus md simulation is correctly done."
             )
 
         flag = True

dpgen/generator/lib/abacus_scf.py

@@ -59,8 +59,8 @@
             ret += "scf_thr %e\n" % fp_params["scf_thr"]
         elif key == "scf_nmax":
             fp_params["scf_nmax"] = int(fp_params["scf_nmax"])
-            assert (
-                fp_params["scf_nmax"] >= 0 and type(fp_params["scf_nmax"]) == int
+            assert fp_params["scf_nmax"] >= 0 and isinstance(
+                fp_params["scf_nmax"], int
             ), "'scf_nmax' should be a positive integer."
             ret += "scf_nmax %d\n" % fp_params["scf_nmax"]
         elif key == "basis_type":
@@ -73,7 +73,7 @@
         elif key == "dft_functional":
             ret += "dft_functional %s\n" % fp_params["dft_functional"]
         elif key == "gamma_only":
-            if type(fp_params["gamma_only"]) == str:
+            if isinstance(fp_params["gamma_only"], str):
                 fp_params["gamma_only"] = int(eval(fp_params["gamma_only"]))
             assert (
                 fp_params["gamma_only"] == 0 or fp_params["gamma_only"] == 1
@@ -95,16 +95,16 @@
             ), "'mixing_beta' should between 0 and 1."
             ret += "mixing_beta %f\n" % fp_params["mixing_beta"]
         elif key == "symmetry":
-            if type(fp_params["symmetry"]) == str:
+            if isinstance(fp_params["symmetry"], str):
                 fp_params["symmetry"] = int(eval(fp_params["symmetry"]))
             assert (
                 fp_params["symmetry"] == 0 or fp_params["symmetry"] == 1
             ), "'symmetry' should be either 0 or 1."
             ret += "symmetry %d\n" % fp_params["symmetry"]
         elif key == "nbands":
             fp_params["nbands"] = int(fp_params["nbands"])
-            assert (
-                fp_params["nbands"] > 0 and type(fp_params["nbands"]) == int
+            assert fp_params["nbands"] > 0 and isinstance(
+                fp_params["nbands"], int
             ), "'nbands' should be a positive integer."
             ret += "nbands %d\n" % fp_params["nbands"]
         elif key == "nspin":
@@ -143,22 +143,22 @@
             ), "'smearing_sigma' should be non-negative."
             ret += "smearing_sigma %f\n" % fp_params["smearing_sigma"]
         elif key == "cal_force":
-            if type(fp_params["cal_force"]) == str:
+            if isinstance(fp_params["cal_force"], str):
                 fp_params["cal_force"] = int(eval(fp_params["cal_force"]))
             assert (
                 fp_params["cal_force"] == 0 or fp_params["cal_force"] == 1
             ), "'cal_force' should be either 0 or 1."
             ret += "cal_force %d\n" % fp_params["cal_force"]
         elif key == "cal_stress":
-            if type(fp_params["cal_stress"]) == str:
+            if isinstance(fp_params["cal_stress"], str):
                 fp_params["cal_stress"] = int(eval(fp_params["cal_stress"]))
             assert (
                 fp_params["cal_stress"] == 0 or fp_params["cal_stress"] == 1
             ), "'cal_stress' should be either 0 or 1."
             ret += "cal_stress %d\n" % fp_params["cal_stress"]
         # paras for deepks
         elif key == "deepks_out_labels":
-            if type(fp_params["deepks_out_labels"]) == str:
+            if isinstance(fp_params["deepks_out_labels"], str):
                 fp_params["deepks_out_labels"] = int(
                     eval(fp_params["deepks_out_labels"])
                 )
@@ -176,7 +176,7 @@
             ), "'deepks_descriptor_lmax' should be  a positive integer."
             ret += "deepks_descriptor_lmax %d\n" % fp_params["deepks_descriptor_lmax"]
         elif key == "deepks_scf":
-            if type(fp_params["deepks_scf"]) == str:
+            if isinstance(fp_params["deepks_scf"], str):
                 fp_params["deepks_scf"] = int(eval(fp_params["deepks_scf"]))
             assert (
                 fp_params["deepks_scf"] == 0 or fp_params["deepks_scf"] == 1
@@ -447,7 +447,7 @@
 
 def make_kspacing_kpoints_stru(stru, kspacing):
     # adapted from dpgen.autotest.lib.vasp.make_kspacing_kpoints
-    if type(kspacing) is not list:
+    if not isinstance(kspacing, list):
         kspacing = [kspacing, kspacing, kspacing]
     box = stru["cells"]
     rbox = vasp.reciprocal_box(box)

dpgen/generator/lib/ele_temp.py

@@ -8,7 +8,7 @@
 
 class NBandsEsti:
     def __init__(self, test_list):
-        if type(test_list) is list:
+        if isinstance(test_list, list):
             ele_t = []
             vol = []
             d_nbd = []
@@ -28,7 +28,7 @@ def __init__(self, test_list):
             self.pref = np.average(alpha)
             # print(np.average(alpha), np.std(alpha), self.err/self.pref)
             # print((ele_t), vol, d_nbd, nbd, alpha)
-        elif type(test_list) is str:
+        elif isinstance(test_list, str):
             with open(test_list) as fp:
                 self.pref = float(fp.readline())
                 self.err = float(fp.readline())

dpgen/generator/lib/gaussian.py

@@ -115,7 +115,7 @@ def make_gaussian_input(sys_data, fp_params):
     else:
         keywords = fp_params["keywords"]
 
-    if type(keywords) == str:
+    if isinstance(keywords, str):
         keywords = [keywords]
     else:
         keywords = keywords.copy()
@@ -128,7 +128,7 @@ def make_gaussian_input(sys_data, fp_params):
 
     use_fragment_guesses = False
     multiplicity = fp_params.get("multiplicity", "auto")
-    if type(multiplicity) == int:
+    if isinstance(multiplicity, int):
         multiplicity = fp_params["multiplicity"]
         mult_auto = False
     elif multiplicity == "auto":

dpgen/generator/lib/make_calypso.py

@@ -39,7 +39,7 @@ def make_calypso_input(
     assert (
         numberofformula is not None
         and len(numberofformula) == 2
-        and type(numberofformula) is list
+        and isinstance(numberofformula, list)
     )
     ret += "NumberOfFormula = %s\n" % (" ".join(list(map(str, numberofformula))))
     ret += "# The volume per formula unit. Unit is in angstrom^3.\n"
@@ -66,9 +66,9 @@ def make_calypso_input(
     ret += (
         "# The population size. Normally, it has a larger number for larger systems.\n"
     )
-    assert popsize is not None and type(popsize) is int
+    assert popsize is not None and isinstance(popsize, int)
     ret += "PopSize = %d\n" % (popsize)
-    assert maxstep is not None and type(maxstep) is int
+    assert maxstep is not None and isinstance(maxstep, int)
     ret += "# The Max step for iteration\n"
     ret += "MaxStep = %d\n" % (maxstep)
     ret += "#It determines which method should be adopted in generation the random structure. \n"
@@ -79,7 +79,7 @@ def make_calypso_input(
     ret += "# 0 combination of all method\n"
     ret += "# If GenType=3 or 4, it determined the small unit to grow the whole structure\n"
     ret += "# It determines which local optimization method should be interfaced in the simulation.\n"
-    assert icode is not None and type(icode) is int
+    assert icode is not None and isinstance(icode, int)
     ret += "ICode= %d\n" % (icode)
     ret += "# ICode= 1 interfaced with VASP\n"
     ret += "# ICode= 2 interfaced with SIESTA\n"
@@ -101,9 +101,11 @@ def make_calypso_input(
     ret += "NumberOfParallel = 4\n"
     assert split is not None
     ret += "Split = %s\n" % (split)
-    assert pstress is not None and (type(pstress) is int or type(pstress) is float)
+    assert pstress is not None and (
+        isinstance(pstress, int) or isinstance(pstress, float)
+    )
     ret += "PSTRESS = %f\n" % (pstress)
-    assert fmax is not None or type(fmax) is float
+    assert fmax is not None or isinstance(fmax, float)
     ret += "fmax = %f\n" % (fmax)
     ret += "################################ End of The Basic Parameters of CALYPSO #######################\n"
     if vsc == "T":

dpgen/generator/lib/pwmat.py

@@ -113,7 +113,7 @@ def _update_input_dict(input_dict_, user_dict):
 def write_input_dict(input_dict):
     lines = []
     for key in input_dict:
-        if type(input_dict[key]) == bool:
+        if isinstance(input_dict[key], bool):
             if input_dict[key]:
                 rs = "T"
             else:

dpgen/generator/lib/pwscf.py

@@ -8,12 +8,12 @@
 def _convert_dict(idict):
     lines = []
     for key in idict.keys():
-        if type(idict[key]) == bool:
+        if isinstance(idict[key], bool):
             if idict[key]:
                 ws = ".TRUE."
             else:
                 ws = ".FALSE."
-        elif type(idict[key]) == str:
+        elif isinstance(idict[key], str):
             ws = "'" + idict[key] + "'"
         else:
             ws = str(idict[key])

dpgen/generator/lib/vasp.py

@@ -59,7 +59,7 @@ def _update_incar_dict(incar_dict_, user_dict):
 def write_incar_dict(incar_dict):
     lines = []
     for key in incar_dict:
-        if type(incar_dict[key]) == bool:
+        if isinstance(incar_dict[key], bool):
             if incar_dict[key]:
                 rs = "T"
             else:

dpgen/generator/run.py

@@ -210,9 +210,9 @@
 def expand_idx(in_list):
     ret = []
     for ii in in_list:
-        if type(ii) == int:
+        if isinstance(ii, int):
             ret.append(ii)
-        elif type(ii) == str:
+        elif isinstance(ii, str):
             step_str = ii.split(":")
             if len(step_str) > 1:
                 step = int(step_str[1])
@@ -566,7 +566,7 @@
                     mdata["deepmd_version"],
                 )
             assert (
-                type(model_devi_activation_func) is list
+                isinstance(model_devi_activation_func, list)
                 and len(model_devi_activation_func) == numb_models
             )
             if (
@@ -601,7 +601,7 @@
             old_model_files = glob.glob(os.path.join(prev_task_path, "model.ckpt*"))
             _link_old_models(work_path, old_model_files, ii)
     else:
-        if type(training_iter0_model) == str:
+        if isinstance(training_iter0_model, str):
             training_iter0_model = [training_iter0_model]
         iter0_models = []
         for ii in training_iter0_model:
@@ -640,7 +640,7 @@
 
 
 def detect_batch_size(batch_size, system=None):
-    if type(batch_size) == int:
+    if isinstance(batch_size, int):
         return batch_size
     elif batch_size == "auto":
         # automaticcaly set batch size, batch_size = 32 // atom_numb (>=1, <=fram_numb)
@@ -1439,7 +1439,7 @@
         for cc in ss:
             for tt_ in temps:
                 if use_ele_temp:
-                    if type(tt_) == list:
+                    if isinstance(tt_, list):
                         tt = tt_[0]
                         if use_ele_temp == 1:
                             te_f = tt_[1]
@@ -1448,7 +1448,7 @@
                             te_f = None
                             te_a = tt_[1]
                     else:
-                        assert type(tt_) == float or type(tt_) == int
+                        assert isinstance(tt_, (float, int))
                         tt = float(tt_)
                         if use_ele_temp == 1:
                             te_f = tt
@@ -3258,15 +3258,15 @@
         if fp_params["basis_type"] == "lcao":
             assert (
                 "fp_orb_files" in jdata
-                and type(jdata["fp_orb_files"]) == list
+                and isinstance(jdata["fp_orb_files"], list)
                 and len(jdata["fp_orb_files"]) == len(fp_pp_files)
             )
             fp_orb_files = jdata["fp_orb_files"]
     dpks_out_labels = fp_params.get("deepks_out_labels", 0)
     dpks_scf = fp_params.get("deepks_scf", 0)
     if dpks_out_labels or dpks_scf:
-        assert (
-            "fp_dpks_descriptor" in jdata and type(jdata["fp_dpks_descriptor"]) == str
+        assert "fp_dpks_descriptor" in jdata and isinstance(
+            jdata["fp_dpks_descriptor"], str
         )
         fp_dpks_descriptor = jdata["fp_dpks_descriptor"]
 

dpgen/simplify/simplify.py

@@ -105,7 +105,7 @@
         return
     iter0_models = []
     training_iter0_model = jdata.get("training_iter0_model_path", [])
-    if type(training_iter0_model) == str:
+    if isinstance(training_iter0_model, str):
         training_iter0_model = [training_iter0_model]
     for ii in training_iter0_model:
         model_is = glob.glob(ii)

tests/auto_test/test_abacus.py

@@ -237,10 +237,10 @@ def test_compuate(self):
         def compare_dict(dict1, dict2):
             self.assertEqual(dict1.keys(), dict2.keys())
             for key in dict1:
-                if type(dict1[key]) is dict:
+                if isinstance(dict1[key], dict):
                     compare_dict(dict1[key], dict2[key])
                 else:
-                    if type(dict1[key]) is np.ndarray:
+                    if isinstance(dict1[key], np.ndarray):
                         np.testing.assert_almost_equal(
                             dict1[key], dict2[key], decimal=5
                         )

tests/auto_test/test_vasp.py

@@ -147,10 +147,10 @@ def compare_dict(dict1, dict2):
             for key in dict1:
                 if key == "stress":
                     self.assertTrue((np.array(dict1[key]["data"]) == dict2[key]).all())
-                elif type(dict1[key]) is dict:
+                elif isinstance(dict1[key], dict):
                     compare_dict(dict1[key], dict2[key])
                 else:
-                    if type(dict1[key]) is np.ndarray:
+                    if isinstance(dict1[key], np.ndarray):
                         self.assertTrue((dict1[key] == dict2[key]).all())
                     else:
                         self.assertTrue(dict1[key] == dict2[key])