pyright fixes for ext/io/phonon/symmetry/transformations/util/vis/dev_scripts and improve io.lobster

.github/workflows/lint.yml

@@ -22,7 +22,7 @@ jobs:
 
       - name: Install dependencies
         run: |
-          pip install --upgrade ruff mypy
+          pip install --upgrade ruff mypy pyright
 
       - name: ruff
         run: |
@@ -35,3 +35,7 @@ jobs:
           mypy --version
           rm -rf .mypy_cache
           mypy ${{ github.event.repository.name }}
+
+      - name: pyright
+        run: |
+          pyright

.pre-commit-config.yaml

@@ -62,3 +62,8 @@ repos:
     hooks:
       - id: nbstripout
         args: [--drop-empty-cells, --keep-output]
+
+  - repo: https://github.com/RobertCraigie/pyright-python
+    rev: v1.1.358
+    hooks:
+    - id: pyright

pymatgen/io/pwscf.py

@@ -279,14 +279,17 @@ def input_mode(line):
         structure = None
         site_properties: dict[str, list] = {"pseudo": []}
         mode = None
+        kpoints_mode = None
+        kpoints_grid = (1, 1, 1)
+        kpoints_shift = (0, 0, 0)
+
         for line in lines:
             mode = input_mode(line)
             if mode is None:
                 pass
             elif mode[0] == "sections":
                 section = mode[1]
-                m = re.match(r"(\w+)\(?(\d*?)\)?\s*=\s*(.*)", line)
-                if m:
+                if m := re.match(r"(\w+)\(?(\d*?)\)?\s*=\s*(.*)", line):
                     key = m.group(1).strip()
                     key_ = m.group(2).strip()
                     val = m.group(3).strip()
@@ -303,18 +306,15 @@ def input_mode(line):
                         sections[section][key] = PWInput.proc_val(key, val)
 
             elif mode[0] == "pseudo":
-                m = re.match(r"(\w+)\s+(\d*.\d*)\s+(.*)", line)
-                if m:
+                if m := re.match(r"(\w+)\s+(\d*.\d*)\s+(.*)", line):
                     pseudo[m.group(1).strip()] = m.group(3).strip()
+
             elif mode[0] == "kpoints":
-                m = re.match(r"(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)", line)
-                if m:
+                if m := re.match(r"(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)", line):
                     kpoints_grid = (int(m.group(1)), int(m.group(2)), int(m.group(3)))
                     kpoints_shift = (int(m.group(4)), int(m.group(5)), int(m.group(6)))
                 else:
                     kpoints_mode = mode[1]
-                    kpoints_grid = (1, 1, 1)
-                    kpoints_shift = (0, 0, 0)
 
             elif mode[0] == "structure":
                 m_l = re.match(r"(-?\d+\.?\d*)\s+(-?\d+\.?\d*)\s+(-?\d+\.?\d*)", line)
@@ -325,6 +325,7 @@ def input_mode(line):
                         float(m_l.group(2)),
                         float(m_l.group(3)),
                     ]
+
                 elif m_p:
                     site_properties["pseudo"].append(pseudo[m_p.group(1)])
                     species.append(m_p.group(1))
@@ -334,10 +335,12 @@ def input_mode(line):
                         coords_are_cartesian = True
                     elif mode[1] == "crystal":
                         coords_are_cartesian = False
+
         structure = Structure(
             Lattice(lattice),
             species,
             coords,
+            # DEBUG (@DanielYang59): need input on coords_are_cartesian
             coords_are_cartesian=coords_are_cartesian,
             site_properties=site_properties,
         )

pymatgen/io/qchem/outputs.py

@@ -677,15 +677,12 @@ def _read_eigenvalues(self):
         if spin_unrestricted:
             header_pattern = r"Final Beta MO Eigenvalues"
             footer_pattern = r"Final Alpha MO Coefficients+\s*"
-            beta_eigenvalues = read_matrix_pattern(
+            self.data["beta_eigenvalues"] = read_matrix_pattern(
                 header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
             )
 
         self.data["alpha_eigenvalues"] = alpha_eigenvalues
 
-        if spin_unrestricted:
-            self.data["beta_eigenvalues"] = beta_eigenvalues
-
     def _read_fock_matrix(self):
         """Parses the Fock matrix. The matrix is read in whole
         from the output file and then transformed into the right dimensions.
@@ -705,13 +702,6 @@ def _read_fock_matrix(self):
         alpha_fock_matrix = read_matrix_pattern(
             header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
         )
-        # The beta Fock matrix is only present if this is a spin-unrestricted calculation.
-        if spin_unrestricted:
-            header_pattern = r"Final Beta Fock Matrix"
-            footer_pattern = "SCF time:"
-            beta_fock_matrix = read_matrix_pattern(
-                header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
-            )
 
         # Convert the matrices to the right dimension. Right now they are simply
         # one massive list of numbers, but we need to split them into a matrix. The
@@ -720,7 +710,14 @@ def _read_fock_matrix(self):
         alpha_fock_matrix = process_parsed_fock_matrix(alpha_fock_matrix)
         self.data["alpha_fock_matrix"] = alpha_fock_matrix
 
+        # The beta Fock matrix is only present if this is a spin-unrestricted calculation.
         if spin_unrestricted:
+            header_pattern = r"Final Beta Fock Matrix"
+            footer_pattern = "SCF time:"
+            beta_fock_matrix = read_matrix_pattern(
+                header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
+            )
+
             # Perform the same transformation for the beta Fock matrix.
             beta_fock_matrix = process_parsed_fock_matrix(beta_fock_matrix)
             self.data["beta_fock_matrix"] = beta_fock_matrix
@@ -744,12 +741,6 @@ def _read_coefficient_matrix(self):
         alpha_coeff_matrix = read_matrix_pattern(
             header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
         )
-        if spin_unrestricted:
-            header_pattern = r"Final Beta MO Coefficients"
-            footer_pattern = "Final Alpha Density Matrix"
-            beta_coeff_matrix = read_matrix_pattern(
-                header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
-            )
 
         # Convert the matrices to the right dimension. Right now they are simply
         # one massive list of numbers, but we need to split them into a matrix. The
@@ -759,6 +750,12 @@ def _read_coefficient_matrix(self):
         self.data["alpha_coeff_matrix"] = alpha_coeff_matrix
 
         if spin_unrestricted:
+            header_pattern = r"Final Beta MO Coefficients"
+            footer_pattern = "Final Alpha Density Matrix"
+            beta_coeff_matrix = read_matrix_pattern(
+                header_pattern, footer_pattern, elements_pattern, self.text, postprocess=float
+            )
+
             # Perform the same transformation for the beta Fock matrix.
             beta_coeff_matrix = process_parsed_fock_matrix(beta_coeff_matrix)
             self.data["beta_coeff_matrix"] = beta_coeff_matrix

pymatgen/io/vasp/inputs.py

@@ -328,9 +328,12 @@ def from_str(cls, data, default_names=None, read_velocities=True) -> Self:
             lattice *= scale
 
         vasp5_symbols = False
+        atomic_symbols = []
+
         try:
             n_atoms = [int(i) for i in lines[5].split()]
             ipos = 6
+
         except ValueError:
             vasp5_symbols = True
             symbols = [symbol.split("/")[0] for symbol in lines[5].split()]
@@ -362,7 +365,7 @@ def from_str(cls, data, default_names=None, read_velocities=True) -> Self:
             iline_natoms_start = 5 + n_lines_symbols
             for iline_natoms in range(iline_natoms_start, iline_natoms_start + n_lines_symbols):
                 n_atoms.extend([int(i) for i in lines[iline_natoms].split()])
-            atomic_symbols = []
+
             for i, nat in enumerate(n_atoms):
                 atomic_symbols.extend([symbols[i]] * nat)
             ipos = 5 + 2 * n_lines_symbols
@@ -383,11 +386,13 @@ def from_str(cls, data, default_names=None, read_velocities=True) -> Self:
         # them. This is in line with VASP's parsing order that the POTCAR
         # specified is the default used.
         if default_names:
-            with contextlib.suppress(IndexError):
+            try:
                 atomic_symbols = []
                 for i, nat in enumerate(n_atoms):
                     atomic_symbols.extend([default_names[i]] * nat)
                 vasp5_symbols = True
+            except IndexError:
+                pass
 
         if not vasp5_symbols:
             ind = 6 if has_selective_dynamics else 3
@@ -398,6 +403,7 @@ def from_str(cls, data, default_names=None, read_velocities=True) -> Self:
                 if not all(Element.is_valid_symbol(sym) for sym in atomic_symbols):
                     raise ValueError("Non-valid symbols detected.")
                 vasp5_symbols = True
+
             except (ValueError, IndexError):
                 # Defaulting to false names.
                 atomic_symbols = []
@@ -1389,8 +1395,11 @@ def from_str(cls, string: str) -> Self:
 
             kpts_shift: tuple[float, float, float] = (0, 0, 0)
             if len(lines) > 4 and coord_pattern.match(lines[4]):
-                with contextlib.suppress(ValueError):
+                try:
                     _kpts_shift = tuple(float(i) for i in lines[4].split())
+                except ValueError:
+                    _kpts_shift = (0, 0, 0)
+
                 if len(_kpts_shift) == 3:
                     kpts_shift = _kpts_shift
 
@@ -1400,8 +1409,7 @@ def from_str(cls, string: str) -> Self:
         if num_kpts <= 0:
             _style = cls.supported_modes.Cartesian if style in "ck" else cls.supported_modes.Reciprocal
             _kpts_shift = tuple(float(i) for i in lines[6].split())
-            if len(_kpts_shift) == 3:
-                kpts_shift = _kpts_shift
+            kpts_shift = _kpts_shift if len(_kpts_shift) == 3 else (0, 0, 0)
 
             return cls(
                 comment=comment,