use dict.get over explicit key in dict check

Author: janosh

pymatgen/analysis/chemenv/coordination_environments/chemenv_strategies.py

@@ -1864,7 +1864,7 @@ def from_dict(cls, dd):
             delta_cn_weight_estimators={
                 int(dcn): dcn_estimator for dcn, dcn_estimator in dd["delta_cn_weight_estimators"].items()
             }
-            if ("delta_cn_weight_estimators" in dd and dd["delta_cn_weight_estimators"] is not None)
+            if dd.get("delta_cn_weight_estimators") is not None
             else None,
             symmetry_measure_type=dd["symmetry_measure_type"],
         )

pymatgen/analysis/chemenv/coordination_environments/coordination_geometries.py

@@ -631,9 +631,11 @@ def from_dict(cls, dct):
             if dct["_algorithms"] is not None
             else None,
             equivalent_indices=dct.get("equivalent_indices"),
-            neighbors_sets_hints=[cls.NeighborsSetsHints.from_dict(nbshd) for nbshd in dct["neighbors_sets_hints"]]
-            if ("neighbors_sets_hints" in dct and dct["neighbors_sets_hints"] is not None)
-            else None,
+            neighbors_sets_hints=[
+                cls.NeighborsSetsHints.from_dict(nb_sets_hints)
+                for nb_sets_hints in dct.get("neighbors_sets_hints") or []
+            ]
+            or None,
         )
 
     def __str__(self):

pymatgen/analysis/chemenv/utils/defs_utils.py

@@ -85,20 +85,20 @@ def check_condition(self, condition, structure: Structure, parameters):
         if condition == self.NO_E2SEB:
             ii = parameters["site_index"]
             jj = parameters["neighbor_index"]
-            elmts_ii = [sp.symbol for sp in structure[ii].species]
-            elmts_jj = [sp.symbol for sp in structure[jj].species]
-            return len(set(elmts_ii) & set(elmts_jj)) == 0
+            elems_ii = [sp.symbol for sp in structure[ii].species]
+            elems_jj = [sp.symbol for sp in structure[jj].species]
+            return len(set(elems_ii) & set(elems_jj)) == 0
         if condition == self.ONLY_ACB_AND_NO_E2SEB:
             valences = parameters["valences"]
             ii = parameters["site_index"]
             jj = parameters["neighbor_index"]
-            elmts_ii = [sp.symbol for sp in structure[ii].species]
-            elmts_jj = [sp.symbol for sp in structure[jj].species]
-            return len(set(elmts_ii) & set(elmts_jj)) == 0 and is_anion_cation_bond(valences, ii, jj)
+            elems_ii = [sp.symbol for sp in structure[ii].species]
+            elems_jj = [sp.symbol for sp in structure[jj].species]
+            return len(set(elems_ii) & set(elems_jj)) == 0 and is_anion_cation_bond(valences, ii, jj)
         if condition == self.ONLY_E2OB:
             ii = parameters["site_index"]
             jj = parameters["neighbor_index"]
-            elmts_ii = [sp.symbol for sp in structure[ii].species]
-            elmts_jj = [sp.symbol for sp in structure[jj].species]
-            return ("O" in elmts_jj and "O" not in elmts_ii) or ("O" in elmts_ii and "O" not in elmts_jj)
+            elems_ii = [sp.symbol for sp in structure[ii].species]
+            elems_jj = [sp.symbol for sp in structure[jj].species]
+            return ("O" in elems_jj and "O" not in elems_ii) or ("O" in elems_ii and "O" not in elems_jj)
         return None

pymatgen/analysis/chemenv/utils/graph_utils.py

@@ -194,14 +194,12 @@ def validate(self, check_strict_ordering=False):
     def order(self, raise_on_fail=True):
         """Orders the SimpleGraphCycle.
 
-        The ordering is performed such that the first node is the "lowest" one
-        and the second node is the lowest one of the two neighbor nodes of the
-        first node. If raise_on_fail is set to True a RuntimeError will be
-        raised if the ordering fails.
+        The ordering is performed such that the first node is the "lowest" one and the
+        second node is the lowest one of the two neighbor nodes of the first node. If
+        raise_on_fail is set to True a RuntimeError will be raised if the ordering fails.
 
-        :param raise_on_fail: If set to True, will raise a RuntimeError if the
-                              ordering fails.
-        :return: None
+        Args:
+            raise_on_fail (bool): If set to True, will raise a RuntimeError if the ordering fails.
         """
         # always validate the cycle if it needs to be ordered
         # also validates that the nodes can be strictly ordered

pymatgen/io/abinit/pseudos.py

@@ -262,14 +262,14 @@ def as_dict(self, **kwargs):
         }
 
     @classmethod
-    def from_dict(cls, d):
+    def from_dict(cls, dct):
         """Build instance from dictionary (MSONable protocol)."""
-        new = cls.from_file(d["filepath"])
+        new = cls.from_file(dct["filepath"])
 
         # Consistency test based on md5
-        if "md5" in d and d["md5"] != new.md5:
+        if "md5" in dct and dct["md5"] != new.md5:
             raise ValueError(
-                f"The md5 found in file does not agree with the one in dict\nReceived {d['md5']}\nComputed {new.md5}"
+                f"The md5 found in file does not agree with the one in dict\nReceived {dct['md5']}\nComputed {new.md5}"
             )
 
         return new

pymatgen/io/cp2k/outputs.py

@@ -212,8 +212,8 @@ def is_metal(self) -> bool:
     @property
     def is_hubbard(self) -> bool:
         """Returns True if hubbard +U correction was used."""
-        for v in self.data.get("atomic_kind_info", {}).values():
-            if "DFT_PLUS_U" in v and v.get("DFT_PLUS_U").get("U_MINUS_J") > 0:
+        for val in self.data.get("atomic_kind_info", {}).values():
+            if val.get("DFT_PLUS_U", {}).get("U_MINUS_J", 0) > 0:
                 return True
         return False
 

pymatgen/io/lmto.py

@@ -250,45 +250,44 @@ def from_str(cls, data, sigfigs=8):
         return LMTOCtrl.from_dict(structure_tokens)
 
     @classmethod
-    def from_dict(cls, d):
+    def from_dict(cls, dct):
         """
         Creates a CTRL file object from a dictionary. The dictionary
         must contain the items "ALAT", PLAT" and "SITE".
 
         Valid dictionary items are:
             ALAT: the a-lattice parameter
             PLAT: (3x3) array for the lattice vectors
-            SITE: list of dictionaries: {'ATOM': class label,
-                                         'POS': (3x1) array of fractional
-                                                coordinates}
+            SITE: list of dictionaries: {'ATOM': class label, 'POS': (3x1) array of fractional coordinates}
             CLASS (optional): list of unique atom labels as str
             SPCGRP (optional): space group symbol (str) or number (int)
             HEADER (optional): HEADER text as a str
             VERS (optional): LMTO version as a str
 
         Args:
-            d: The CTRL file as a dictionary.
+            dct: The CTRL file as a dictionary.
 
         Returns:
             An LMTOCtrl object.
         """
-        for cat in ["HEADER", "VERS"]:
-            if cat not in d:
-                d[cat] = None
-        alat = d["ALAT"] * bohr_to_angstrom
-        plat = d["PLAT"] * alat
+        dct.setdefault("HEADER", None)
+        dct.setdefault("VERS", None)
+        alat = dct["ALAT"] * bohr_to_angstrom
+        plat = dct["PLAT"] * alat
         species = []
         positions = []
-        for site in d["SITE"]:
+        for site in dct["SITE"]:
             species.append(re.split("[0-9*]", site["ATOM"])[0])
             positions.append(site["POS"] * alat)
 
         # Only check if the structure is to be generated from the space
         # group if the number of sites is the same as the number of classes.
         # If lattice and the spacegroup don't match, assume it's primitive.
-        if "CLASS" in d and "SPCGRP" in d and len(d["SITE"]) == len(d["CLASS"]):
+        if "CLASS" in dct and "SPCGRP" in dct and len(dct["SITE"]) == len(dct["CLASS"]):
             try:
-                structure = Structure.from_spacegroup(d["SPCGRP"], plat, species, positions, coords_are_cartesian=True)
+                structure = Structure.from_spacegroup(
+                    dct["SPCGRP"], plat, species, positions, coords_are_cartesian=True
+                )
             except ValueError:
                 structure = Structure(
                     plat,
@@ -300,7 +299,7 @@ def from_dict(cls, d):
         else:
             structure = Structure(plat, species, positions, coords_are_cartesian=True, to_unit_cell=True)
 
-        return cls(structure, header=d["HEADER"], version=d["VERS"])
+        return cls(structure, header=dct["HEADER"], version=dct["VERS"])
 
 
 class LMTOCopl:

pymatgen/io/vasp/outputs.py

@@ -607,7 +607,7 @@ def converged_electronic(self):
         """
         final_esteps = self.ionic_steps[-1]["electronic_steps"] if self.incar not in ["CHI"] else 0
         # In a response function run there is no ionic steps, there is no scf step
-        if "LEPSILON" in self.incar and self.incar["LEPSILON"]:
+        if self.incar.get("LEPSILON"):
             i = 1
             to_check = {"e_wo_entrp", "e_fr_energy", "e_0_energy"}
             while set(final_esteps[i]) == to_check:

pymatgen/io/vasp/sets.py

@@ -763,7 +763,7 @@ def calculate_ng(self, max_prime_factor: int = 7, must_inc_2: bool = True) -> tu
         # TODO Only do this for VASP 6 for now. Older version require more advanced logic
 
         # get the ENCUT val
-        if "ENCUT" in self.incar and self.incar["ENCUT"] > 0:
+        if self.incar.get("ENCUT", 0) > 0:
             encut = self.incar["ENCUT"]
         else:
             encut = max(i_species.enmax for i_species in self.get_vasp_input()["POTCAR"])

pymatgen/io/vasp/tests/test_sets.py

@@ -725,17 +725,15 @@ def test_standardize_structure(self):
 
     def test_write_input_zipped(self):
         vis = MPStaticSet(self.get_structure("Si"))
-        vis.write_input(output_dir=".", potcar_spec=True, zip_output=True)
+        vis.write_input(output_dir=self.tmp_path, potcar_spec=True, zip_output=True)
 
-        assert os.path.isfile("MPStaticSet.zip")
-        with ZipFile("MPStaticSet.zip", "r") as zip:
+        assert os.path.isfile(f"{self.tmp_path}/MPStaticSet.zip")
+        with ZipFile(f"{self.tmp_path}/MPStaticSet.zip", "r") as zip:
             contents = zip.namelist()
             assert set(contents).issuperset({"INCAR", "POSCAR", "POTCAR.spec", "KPOINTS"})
             spec = zip.open("POTCAR.spec", "r").read().decode()
             assert spec == "Si"
 
-        os.remove("MPStaticSet.zip")
-
     def test_grid_size_from_struct(self):
         # TODO grab a bunch_of_calculations store as a list of tuples
         # (structure, ngx, ..., ngxf, ...) where all the grid size values are generated by vasp