Enable Ruff rule family "N" and "S"

dev_scripts/potcar_scrambler.py

@@ -48,20 +48,23 @@ def __init__(self, potcars: Potcar | PotcarSingle) -> None:
     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)))  # ensure we don't get 0
-        return round(bd * np.random.rand(1)[0], n_prec)
+        rng = np.random.default_rng()
+        return round(bd * rng.random(), 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"}:
-            return bool(np.random.randint(2))
+            rng = np.random.default_rng()
+            return rng.choice((True, False))
 
         if input_str.upper() == input_str.lower() and input_str[0].isnumeric():
             if "." in input_str:
                 return self._rand_float_from_str_with_prec(input_str, bloat=bloat)
             integer = int(input_str)
             fac = int(np.sign(integer))  # return int of same sign
-            return fac * np.random.randint(abs(max(1, int(np.ceil(bloat * integer)))))
+            rng = np.random.default_rng()
+            return fac * rng.integers(abs(max(1, int(np.ceil(bloat * integer)))))
         try:
             float(input_str)
             return self._rand_float_from_str_with_prec(input_str, bloat=bloat)

pymatgen/analysis/chemenv/coordination_environments/coordination_geometry_finder.py

@@ -993,15 +993,17 @@ def setup_test_perfect_environment(
             raise ValueError("Wrong mp_symbol to setup coordination geometry")
         neighb_coords = []
         _points = points if points is not None else cg.points
+        rng = np.random.default_rng()
+
         if randomness:
-            rv = np.random.random_sample(3)
+            rv = rng.random(3)
             while norm(rv) > 1.0:
-                rv = np.random.random_sample(3)
+                rv = rng.random(3)
             coords = [np.zeros(3, float) + max_random_dist * rv]
             for pp in _points:
-                rv = np.random.random_sample(3)
+                rv = rng.random(3)
                 while norm(rv) > 1.0:
-                    rv = np.random.random_sample(3)
+                    rv = rng.random(3)
                 neighb_coords.append(np.array(pp) + max_random_dist * rv)
         else:
             coords = [np.zeros(3, float)]
@@ -1016,7 +1018,7 @@ def setup_test_perfect_environment(
 
         # Scaling the test environment
         if random_scale == "RANDOM":
-            scale = 0.1 * np.random.random_sample() + 0.95
+            scale = 0.1 * rng.random() + 0.95
         elif random_scale == "NONE":
             scale = 1.0
         else:
@@ -1026,9 +1028,9 @@ def setup_test_perfect_environment(
 
         # Rotating the test environment
         if random_rotation == "RANDOM":
-            uu = np.random.random_sample(3) + 0.1
+            uu = rng.random(3) + 0.1
             uu = uu / norm(uu)
-            theta = np.pi * np.random.random_sample()
+            theta = np.pi * rng.random()
             cos_theta = np.cos(theta)
             sin_theta = np.sin(theta)
             ux = uu[0]
@@ -1068,7 +1070,7 @@ def setup_test_perfect_environment(
 
         # Translating the test environment
         if random_translation == "RANDOM":
-            translation = 10.0 * (2.0 * np.random.random_sample(3) - 1.0)
+            translation = 10.0 * (2.0 * rng.random(3) - 1.0)
         elif random_translation == "NONE":
             translation = np.zeros(3, float)
         else:
@@ -1112,8 +1114,9 @@ def setup_random_structure(self, coordination):
         aa = 0.4
         bb = -0.2
         coords = []
+        rng = np.random.default_rng()
         for _ in range(coordination + 1):
-            coords.append(aa * np.random.random_sample(3) + bb)
+            coords.append(aa * rng.random(3) + bb)
         self.set_structure(
             lattice=np.array(np.eye(3) * 10, float),
             species=["Si"] * (coordination + 1),
@@ -1130,7 +1133,8 @@ def setup_random_indices_local_geometry(self, coordination):
         """
         self.icentral_site = 0
         self.indices = list(range(1, coordination + 1))
-        np.random.shuffle(self.indices)
+        rng = np.random.default_rng()
+        rng.shuffle(self.indices)
 
     def setup_ordered_indices_local_geometry(self, coordination):
         """Set up ordered indices for the local geometry, for testing purposes
@@ -2049,8 +2053,9 @@ def coordination_geometry_symmetry_measures_fallback_random(
         algos = []
         perfect2local_maps = []
         local2perfect_maps = []
+        rng = np.random.default_rng()
         for idx in range(n_random):
-            perm = np.random.permutation(coordination_geometry.coordination_number)
+            perm = rng.permutation(coordination_geometry.coordination_number)
             permutations.append(perm)
             p2l = {}
             l2p = {}

pymatgen/analysis/piezo_sensitivity.py

@@ -122,7 +122,8 @@ def get_rand_BEC(self, max_charge=1):
         BEC = np.zeros((n_atoms, 3, 3))
         for atom, ops in enumerate(self.BEC_operations):
             if ops[0] == ops[1]:
-                temp_tensor = Tensor(np.random.rand(3, 3) - 0.5)
+                rng = np.random.default_rng()
+                temp_tensor = Tensor(rng.random((3, 3)) - 0.5)
                 temp_tensor = sum(temp_tensor.transform(symm_op) for symm_op in self.pointops[atom]) / len(
                     self.pointops[atom]
                 )
@@ -238,7 +239,8 @@ def get_rand_IST(self, max_force=1):
                 temp_tensor += op[1].transform_tensor(IST[op[0]])
 
             if len(ops) == 0:
-                temp_tensor = Tensor(np.random.rand(3, 3, 3) - 0.5)
+                rng = np.random.default_rng()
+                temp_tensor = Tensor(rng.random((3, 3, 3)) - 0.5)
                 for dim in range(3):
                     temp_tensor[dim] = (temp_tensor[dim] + temp_tensor[dim].T) / 2
                 temp_tensor = sum(temp_tensor.transform(symm_op) for symm_op in self.pointops[atom]) / len(
@@ -385,7 +387,8 @@ def get_unstable_FCM(self, max_force=1):
                 ].T
                 continue
 
-            temp_tensor = Tensor(np.random.rand(3, 3) - 0.5) * max_force
+            rng = np.random.default_rng()
+            temp_tensor = Tensor(rng.random((3, 3)) - 0.5) * max_force
 
             temp_tensor_sum = sum(temp_tensor.transform(symm_op) for symm_op in self.sharedops[op[0]][op[1]])
             temp_tensor_sum = temp_tensor_sum / (len(self.sharedops[op[0]][op[1]]))
@@ -484,9 +487,10 @@ def get_stable_FCM(self, fcm, fcmasum=10):
 
             max_eig = np.max(-1 * eigs)
             eig_sort = np.argsort(np.abs(eigs))
+            rng = np.random.default_rng()
             for idx in range(3, len(eigs)):
                 if eigs[eig_sort[idx]] > 1e-6:
-                    eigs[eig_sort[idx]] = -1 * max_eig * np.random.rand()
+                    eigs[eig_sort[idx]] = -1 * max_eig * rng.random()
             diag = np.real(np.eye(len(fcm)) * eigs)
 
             fcm = np.real(np.matmul(np.matmul(vecs, diag), vecs.T))

pymatgen/analysis/surface_analysis.py

@@ -36,7 +36,6 @@
 
 import copy
 import itertools
-import random
 import warnings
 from typing import TYPE_CHECKING
 
@@ -804,11 +803,12 @@ def color_palette_dict(self, alpha=0.35):
         for hkl in self.all_slab_entries:
             rgb_indices = [0, 1, 2]
             color = [0, 0, 0, 1]
-            random.shuffle(rgb_indices)
+            rng = np.random.default_rng()
+            rng.shuffle(rgb_indices)
             for idx, ind in enumerate(rgb_indices):
                 if idx == 2:
                     break
-                color[ind] = np.random.uniform(0, 1)
+                color[ind] = rng.uniform(0, 1)
 
             # Get the clean (solid) colors first
             clean_list = np.linspace(0, 1, len(self.all_slab_entries[hkl]))

pymatgen/core/structure.py

@@ -14,7 +14,6 @@
 import json
 import math
 import os
-import random
 import re
 import sys
 import warnings
@@ -3642,11 +3641,12 @@ def get_boxed_structure(
         ):
             box_center = [(i + 0.5) * a, (j + 0.5) * b, (k + 0.5) * c]
             if random_rotation:
+                rng = np.random.default_rng()
                 while True:
                     op = SymmOp.from_origin_axis_angle(
                         (0, 0, 0),
-                        axis=np.random.rand(3),
-                        angle=random.uniform(-180, 180),
+                        axis=rng.random(3),
+                        angle=rng.uniform(-180, 180),
                     )
                     rot_mat = op.rotation_matrix
                     new_coords = np.dot(rot_mat, centered_coords.T).T + box_center
@@ -4467,11 +4467,12 @@ def perturb(self, distance: float, min_distance: float | None = None) -> Self:
 
         def get_rand_vec():
             # Deal with zero vectors
-            vector = np.random.randn(3)
+            rng = np.random.default_rng()
+            vector = rng.random(3)
             vnorm = np.linalg.norm(vector)
             dist = distance
             if isinstance(min_distance, (float, int)):
-                dist = np.random.uniform(min_distance, dist)
+                dist = rng.uniform(min_distance, dist)
             return vector / vnorm * dist if vnorm != 0 else get_rand_vec()
 
         for idx in range(len(self._sites)):
@@ -5018,7 +5019,8 @@ def perturb(self, distance: float) -> Self:
 
         def get_rand_vec():
             # Deal with zero vectors
-            vector = np.random.randn(3)
+            rng = np.random.default_rng()
+            vector = rng.random(3)
             vnorm = np.linalg.norm(vector)
             return vector / vnorm * distance if vnorm != 0 else get_rand_vec()
 

pymatgen/io/lammps/utils.py

@@ -121,9 +121,10 @@ def _create(self, monomer: Molecule, mon_vector: ArrayLike) -> None:
     def _next_move_direction(self) -> np.ndarray:
         """Pick a move at random from the list of moves."""
         n_moves = len(self.moves)
-        move = np.random.randint(1, n_moves + 1)
+        rng = np.random.default_rng()
+        move = rng.integers(1, n_moves + 1)
         while self.prev_move == (move + 3) % n_moves:
-            move = np.random.randint(1, n_moves + 1)
+            move = rng.integers(1, n_moves + 1)
         self.prev_move = move
         return np.array(self.moves[move])
 

pymatgen/io/vasp/inputs.py

@@ -659,7 +659,7 @@ def from_dict(cls, dct: dict) -> Self:
     def set_temperature(self, temperature: float) -> None:
         """
         Initialize the velocities based on Maxwell-Boltzmann distribution.
-        Removes linear, but not angular drift (same as VASP).
+        Remove linear, but not angular drift (same as VASP).
 
         Scale the energies to the exact temperature (microcanonical ensemble)
         Velocities are given in A/fs. This is the VASP default when
@@ -672,9 +672,10 @@ def set_temperature(self, temperature: float) -> None:
             temperature (float): Temperature in Kelvin.
         """
         # mean 0 variance 1
-        velocities = np.random.randn(len(self.structure), 3)
+        rng = np.random.default_rng()
+        velocities = rng.random((len(self.structure), 3))
 
-        # In AMU, (N,1) array
+        # In AMU, (N, 1) array
         atomic_masses = np.array([site.specie.atomic_mass.to("kg") for site in self.structure])
         dof = 3 * len(self.structure) - 3
 

pymatgen/transformations/advanced_transformations.py

@@ -1684,7 +1684,8 @@ def round_away_from_zero(x):
             col_idx_to_fix = np.where(matches)[0]
 
             # Break ties for the largest absolute magnitude
-            r_idx = np.random.randint(len(col_idx_to_fix))
+            rng = np.random.default_rng()
+            r_idx = rng.integers(len(col_idx_to_fix))
             col_idx_to_fix = col_idx_to_fix[r_idx]
 
             # Round the chosen element away from zero
@@ -2103,7 +2104,8 @@ def __init__(self, rattle_std: float, min_distance: float, seed: int | None = No
         if not seed:
             # if seed is None, use a random RandomState seed but make sure
             # we store that the original seed was None
-            seed = np.random.randint(1, 1000000000)
+            rng = np.random.default_rng()
+            seed = rng.integers(1, 1000000000)
 
         self.random_state = np.random.RandomState(seed)
         self.kwargs = kwargs

pyproject.toml

@@ -204,7 +204,6 @@ ignore = [
   "G",    # validate logging format strings
   "INP",  # Ban PEP-420 implicit namespace packages
   "N",    # pep8-naming (many var/arg names are intended)
-  "NPY",  # NumPy-specific rules (TODO: enable this)
   "PTH",  # Prefer pathlib over os.path
   "S",    # flake8-bandit (TODO: enable this)
   "SLF",  # Access "private" class members