Use Self type in Method Signatures

dev_scripts/potcar_scrambler.py

@@ -4,6 +4,7 @@
 import shutil
 import warnings
 from glob import glob
+from typing import TYPE_CHECKING
 
 import numpy as np
 from monty.os.path import zpath
@@ -14,6 +15,9 @@
 from pymatgen.io.vasp.sets import _load_yaml_config
 from pymatgen.util.testing import VASP_IN_DIR
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 class PotcarScrambler:
     """
@@ -34,26 +38,22 @@ class PotcarScrambler:
     from existing POTCAR `input_filename`
     """
 
-    def __init__(self, potcars: Potcar | PotcarSingle):
-        if isinstance(potcars, PotcarSingle):
-            self.PSP_list = [potcars]
-        else:
-            self.PSP_list = potcars
+    def __init__(self, potcars: Potcar | PotcarSingle) -> None:
+        self.PSP_list = [potcars] if isinstance(potcars, PotcarSingle) else potcars
         self.scrambled_potcars_str = ""
         for psp in self.PSP_list:
             scrambled_potcar_str = self.scramble_single_potcar(psp)
             self.scrambled_potcars_str += scrambled_potcar_str
-        return
 
-    def _rand_float_from_str_with_prec(self, input_str: str, bloat: float = 1.5):
+    def _rand_float_from_str_with_prec(self, input_str: str, bloat: float = 1.5) -> float:
         n_prec = len(input_str.split(".")[1])
         bd = max(1, bloat * abs(float(input_str)))
         return round(bd * np.random.rand(1)[0], n_prec)
 
     def _read_fortran_str_and_scramble(self, input_str: str, bloat: float = 1.5):
         input_str = input_str.strip()
 
-        if input_str.lower() in ("t", "f", "true", "false"):
+        if input_str.lower() in {"t", "f", "true", "false"}:
             return bool(np.random.randint(2))
 
         if input_str.upper() == input_str.lower() and input_str[0].isnumeric():
@@ -68,7 +68,7 @@ def _read_fortran_str_and_scramble(self, input_str: str, bloat: float = 1.5):
         except ValueError:
             return input_str
 
-    def scramble_single_potcar(self, potcar: PotcarSingle):
+    def scramble_single_potcar(self, potcar: PotcarSingle) -> str:
         """
         Scramble the body of a POTCAR, retain the PSCTR header information.
 
@@ -124,20 +124,20 @@ def scramble_single_potcar(self, potcar: PotcarSingle):
             )
         return scrambled_potcar_str
 
-    def to_file(self, filename: str):
+    def to_file(self, filename: str) -> None:
         with zopen(filename, mode="wt") as file:
             file.write(self.scrambled_potcars_str)
 
     @classmethod
-    def from_file(cls, input_filename: str, output_filename: str | None = None):
+    def from_file(cls, input_filename: str, output_filename: str | None = None) -> Self:
         psp = Potcar.from_file(input_filename)
         psp_scrambled = cls(psp)
         if output_filename:
             psp_scrambled.to_file(output_filename)
         return psp_scrambled
 
 
-def generate_fake_potcar_libraries():
+def generate_fake_potcar_libraries() -> None:
     """
     To test the `_gen_potcar_summary_stats` function in `pymatgen.io.vasp.inputs`,
     need a library of fake POTCARs which do not violate copyright
@@ -173,7 +173,7 @@ def generate_fake_potcar_libraries():
                     break
 
 
-def potcar_cleanser():
+def potcar_cleanser() -> None:
     """
     Function to replace copyrighted POTCARs used in io.vasp.sets testing
     with dummy POTCARs that have scrambled PSP and kinetic energy values

dev_scripts/regen_libxcfunc.py

@@ -50,16 +50,16 @@ def write_libxc_docs_json(xc_funcs, json_path):
     xc_funcs = deepcopy(xc_funcs)
 
     # Remove XC_FAMILY from Family and XC_ from Kind to make strings more human-readable.
-    for d in xc_funcs.values():
-        d["Family"] = d["Family"].replace("XC_FAMILY_", "", 1)
-        d["Kind"] = d["Kind"].replace("XC_", "", 1)
+    for dct in xc_funcs.values():
+        dct["Family"] = dct["Family"].replace("XC_FAMILY_", "", 1)
+        dct["Kind"] = dct["Kind"].replace("XC_", "", 1)
 
     # Build lightweight version with a subset of keys.
-    for num, d in xc_funcs.items():
-        xc_funcs[num] = {key: d[key] for key in ("Family", "Kind", "References")}
+    for num, dct in xc_funcs.items():
+        xc_funcs[num] = {key: dct[key] for key in ("Family", "Kind", "References")}
         # Descriptions are optional
         for opt in ("Description 1", "Description 2"):
-            desc = d.get(opt)
+            desc = dct.get(opt)
             if desc is not None:
                 xc_funcs[num][opt] = desc
 

pymatgen/alchemy/filters.py

@@ -94,7 +94,7 @@ def __repr__(self):
             ]
         )
 
-    def as_dict(self):
+    def as_dict(self) -> dict:
         """Returns: MSONable dict."""
         return {
             "@module": type(self).__module__,

pymatgen/alchemy/materials.py

@@ -23,6 +23,8 @@
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
+    from typing_extensions import Self
+
     from pymatgen.alchemy.filters import AbstractStructureFilter
 
 
@@ -212,7 +214,7 @@ def write_vasp_input(
             **kwargs: All keyword args supported by the VASP input set.
         """
         vasp_input_set(self.final_structure, **kwargs).write_input(output_dir, make_dir_if_not_present=create_directory)
-        with open(f"{output_dir}/transformations.json", mode="w") as file:
+        with open(f"{output_dir}/transformations.json", mode="w", encoding="utf-8") as file:
             json.dump(self.as_dict(), file)
 
     def __str__(self) -> str:
@@ -267,7 +269,7 @@ def from_cif_str(
         transformations: list[AbstractTransformation] | None = None,
         primitive: bool = True,
         occupancy_tolerance: float = 1.0,
-    ) -> TransformedStructure:
+    ) -> Self:
         """Generates TransformedStructure from a cif string.
 
         Args:
@@ -311,7 +313,7 @@ def from_poscar_str(
         cls,
         poscar_string: str,
         transformations: list[AbstractTransformation] | None = None,
-    ) -> TransformedStructure:
+    ) -> Self:
         """Generates TransformedStructure from a poscar string.
 
         Args:
@@ -339,12 +341,12 @@ def as_dict(self) -> dict[str, Any]:
         dct["@module"] = type(self).__module__
         dct["@class"] = type(self).__name__
         dct["history"] = jsanitize(self.history)
-        dct["last_modified"] = str(datetime.datetime.utcnow())
+        dct["last_modified"] = str(datetime.datetime.now(datetime.timezone.utc))
         dct["other_parameters"] = jsanitize(self.other_parameters)
         return dct
 
     @classmethod
-    def from_dict(cls, dct: dict) -> TransformedStructure:
+    def from_dict(cls, dct: dict) -> Self:
         """Creates a TransformedStructure from a dict."""
         struct = Structure.from_dict(dct)
         return cls(struct, history=dct["history"], other_parameters=dct.get("other_parameters"))
@@ -376,7 +378,7 @@ def to_snl(self, authors: list[str], **kwargs) -> StructureNL:
         return StructureNL(self.final_structure, authors, history=history, **kwargs)
 
     @classmethod
-    def from_snl(cls, snl: StructureNL) -> TransformedStructure:
+    def from_snl(cls, snl: StructureNL) -> Self:
         """Create TransformedStructure from SNL.
 
         Args:

pymatgen/alchemy/transmuters.py

@@ -20,6 +20,8 @@
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
+    from typing_extensions import Self
+
 __author__ = "Shyue Ping Ong, Will Richards"
 __copyright__ = "Copyright 2012, The Materials Project"
 __version__ = "0.1"
@@ -42,7 +44,7 @@ def __init__(
         transformations=None,
         extend_collection: int = 0,
         ncores: int | None = None,
-    ):
+    ) -> None:
         """Initializes a transmuter from an initial list of
         pymatgen.alchemy.materials.TransformedStructure.
 
@@ -71,7 +73,16 @@ def __getitem__(self, index):
     def __getattr__(self, name):
         return [getattr(x, name) for x in self.transformed_structures]
 
-    def undo_last_change(self):
+    def __len__(self):
+        return len(self.transformed_structures)
+
+    def __str__(self):
+        output = ["Current structures", "------------"]
+        for x in self.transformed_structures:
+            output.append(str(x.final_structure))
+        return "\n".join(output)
+
+    def undo_last_change(self) -> None:
         """Undo the last transformation in the TransformedStructure.
 
         Raises:
@@ -80,7 +91,7 @@ def undo_last_change(self):
         for x in self.transformed_structures:
             x.undo_last_change()
 
-    def redo_next_change(self):
+    def redo_next_change(self) -> None:
         """Redo the last undone transformation in the TransformedStructure.
 
         Raises:
@@ -89,9 +100,6 @@ def redo_next_change(self):
         for x in self.transformed_structures:
             x.redo_next_change()
 
-    def __len__(self):
-        return len(self.transformed_structures)
-
     def append_transformation(self, transformation, extend_collection=False, clear_redo=True):
         """Appends a transformation to all TransformedStructures.
 
@@ -178,12 +186,6 @@ def add_tags(self, tags):
         """
         self.set_parameter("tags", tags)
 
-    def __str__(self):
-        output = ["Current structures", "------------"]
-        for x in self.transformed_structures:
-            output.append(str(x.final_structure))
-        return "\n".join(output)
-
     def append_transformed_structures(self, trafo_structs_or_transmuter):
         """Method is overloaded to accept either a list of transformed structures
         or transmuter, it which case it appends the second transmuter"s
@@ -201,7 +203,7 @@ def append_transformed_structures(self, trafo_structs_or_transmuter):
             self.transformed_structures.extend(trafo_structs_or_transmuter)
 
     @classmethod
-    def from_structures(cls, structures, transformations=None, extend_collection=0):
+    def from_structures(cls, structures, transformations=None, extend_collection=0) -> Self:
         """Alternative constructor from structures rather than
         TransformedStructures.
 
@@ -256,7 +258,7 @@ def __init__(self, cif_string, transformations=None, primitive=True, extend_coll
         super().__init__(transformed_structures, transformations, extend_collection)
 
     @classmethod
-    def from_filenames(cls, filenames, transformations=None, primitive=True, extend_collection=False):
+    def from_filenames(cls, filenames, transformations=None, primitive=True, extend_collection=False) -> Self:
         """Generates a TransformedStructureCollection from a cif, possibly
         containing multiple structures.
 
@@ -269,7 +271,7 @@ def from_filenames(cls, filenames, transformations=None, primitive=True, extend_
         """
         cif_files = []
         for filename in filenames:
-            with open(filename) as file:
+            with open(filename, encoding="utf-8") as file:
                 cif_files.append(file.read())
         return cls(
             "\n".join(cif_files),
@@ -308,7 +310,7 @@ def from_filenames(cls, poscar_filenames, transformations=None, extend_collectio
         """
         trafo_structs = []
         for filename in poscar_filenames:
-            with open(filename) as file:
+            with open(filename, encoding="utf-8") as file:
                 trafo_structs.append(TransformedStructure.from_poscar_str(file.read(), []))
         return StandardTransmuter(trafo_structs, transformations, extend_collection=extend_collection)