Make tests more deterministic

.pre-commit-config.yaml

@@ -95,6 +95,18 @@ repos:
         entry: 'pytest\.xfail'
         language: pygrep
         types: [python]
+      - id: no-unseeded-default-rng
+        name: no-unseeded-default-rng
+        description: 'Enforce that no non-seeded default_rng is used'
+        entry: 'default_rng\(\)'
+        language: pygrep
+        types: [python]
+      - id: no-np-random-seed
+        name: no-np-random-seed
+        description: 'Enforce that default_rng is used instead of np.random.seed'
+        entry: 'random.seed\('
+        language: pygrep
+        types: [python]
       - id: cmake-format
         name: cmake-format
         entry: ./cpp/scripts/run-cmake-format.sh cmake-format

pyproject.toml

@@ -90,6 +90,7 @@ select = [
     "UP007",
     # Import from `collections.abc` instead: `Callable`
     "UP035",
+    "NPY002",
 ]
 ignore = [
     # whitespace before :

python/cudf/benchmarks/API/bench_functions.py

@@ -72,12 +72,13 @@ def bench_pivot_table_simple(benchmark, dataframe):
 
 @pytest_cases.parametrize("nr", NUM_ROWS)
 def bench_crosstab_simple(benchmark, nr):
+    rng = np.random.default_rng(seed=0)
     series_a = np.array(["foo", "bar"] * nr)
     series_b = np.array(["one", "two"] * nr)
     series_c = np.array(["dull", "shiny"] * nr)
-    np.random.shuffle(series_a)
-    np.random.shuffle(series_b)
-    np.random.shuffle(series_c)
+    rng.shuffle(series_a)
+    rng.shuffle(series_b)
+    rng.shuffle(series_c)
     series_a = cudf.Series(series_a)
     series_b = cudf.Series(series_b)
     series_c = cudf.Series(series_c)

python/cudf/benchmarks/API/bench_multiindex.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2022, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 
 """Benchmarks of MultiIndex methods."""
 
@@ -11,16 +11,18 @@
 @pytest.fixture
 def pidx():
     num_elements = int(1e3)
-    a = np.random.randint(0, num_elements // 10, num_elements)
-    b = np.random.randint(0, num_elements // 10, num_elements)
+    rng = np.random.default_rng(seed=0)
+    a = rng.integers(0, num_elements // 10, num_elements)
+    b = rng.integers(0, num_elements // 10, num_elements)
     return pd.MultiIndex.from_arrays([a, b], names=("a", "b"))
 
 
 @pytest.fixture
 def midx(pidx):
     num_elements = int(1e3)
-    a = np.random.randint(0, num_elements // 10, num_elements)
-    b = np.random.randint(0, num_elements // 10, num_elements)
+    rng = np.random.default_rng(seed=0)
+    a = rng.integers(0, num_elements // 10, num_elements)
+    b = rng.integers(0, num_elements // 10, num_elements)
     df = cudf.DataFrame({"a": a, "b": b})
     return cudf.MultiIndex.from_frame(df)
 

python/cudf/cudf/_fuzz_testing/avro.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022, NVIDIA CORPORATION.
+# Copyright (c) 2020-2024, NVIDIA CORPORATION.
 
 import copy
 import io
@@ -68,12 +68,12 @@ def generate_input(self):
                 # https://github.com/rapidsai/cudf/issues/6604
                 - cudf.utils.dtypes.TIMEDELTA_TYPES
             )
-
+            seed = random.randint(0, 2**32 - 1)
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
-            seed = random.randint(0, 2**32 - 1)
+
             self._current_params["seed"] = seed
             self._current_params["num_rows"] = num_rows
             self._current_params["num_cols"] = num_cols
@@ -100,17 +100,18 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if values == ALL_POSSIBLE_VALUES:
                 if param == "columns":
                     col_size = self._rand(len(self._df.columns))
                     params_dict[param] = list(
-                        np.unique(np.random.choice(self._df.columns, col_size))
+                        np.unique(rng.choice(self._df.columns, col_size))
                     )
                 elif param in ("skiprows", "num_rows"):
-                    params_dict[param] = np.random.choice(
+                    params_dict[param] = rng.choice(
                         [None, self._rand(len(self._df))]
                     )
             else:
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)

python/cudf/cudf/_fuzz_testing/csv.py

@@ -54,7 +54,7 @@ def generate_input(self):
             random.seed(seed)
             dtypes_list = list(cudf.utils.dtypes.ALL_TYPES)
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
             self._current_params["seed"] = seed
@@ -77,25 +77,22 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if values == ALL_POSSIBLE_VALUES:
                 if param == "usecols":
                     col_size = self._rand(len(self._df.columns))
-                    col_val = np.random.choice(
+                    col_val = rng.choice(
                         [
                             None,
-                            np.unique(
-                                np.random.choice(self._df.columns, col_size)
-                            ),
+                            np.unique(rng.choice(self._df.columns, col_size)),
                         ]
                     )
                     params_dict[param] = (
                         col_val if col_val is None else list(col_val)
                     )
                 elif param == "dtype":
-                    dtype_val = np.random.choice(
-                        [None, self._df.dtypes.to_dict()]
-                    )
+                    dtype_val = rng.choice([None, self._df.dtypes.to_dict()])
                     if dtype_val is not None:
                         dtype_val = {
                             col_name: "category"
@@ -105,25 +102,25 @@ def set_rand_params(self, params):
                         }
                     params_dict[param] = dtype_val
                 elif param == "header":
-                    header_val = np.random.choice(
-                        ["infer", np.random.randint(low=0, high=len(self._df))]
+                    header_val = rng.choice(
+                        ["infer", rng.integers(low=0, high=len(self._df))]
                     )
                     params_dict[param] = header_val
                 elif param == "skiprows":
-                    params_dict[param] = np.random.randint(
+                    params_dict[param] = rng.integers(
                         low=0, high=len(self._df)
                     )
                 elif param == "skipfooter":
-                    params_dict[param] = np.random.randint(
+                    params_dict[param] = rng.integers(
                         low=0, high=len(self._df)
                     )
                 elif param == "nrows":
-                    nrows_val = np.random.choice(
-                        [None, np.random.randint(low=0, high=len(self._df))]
+                    nrows_val = rng.choice(
+                        [None, rng.integers(low=0, high=len(self._df))]
                     )
                     params_dict[param] = nrows_val
             else:
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)
 
 
@@ -159,7 +156,7 @@ def generate_input(self):
             random.seed(seed)
             dtypes_list = list(cudf.utils.dtypes.ALL_TYPES)
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
             self._current_params["seed"] = seed
@@ -182,26 +179,25 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if values == ALL_POSSIBLE_VALUES:
                 if param == "columns":
                     col_size = self._rand(len(self._current_buffer.columns))
                     params_dict[param] = list(
                         np.unique(
-                            np.random.choice(
-                                self._current_buffer.columns, col_size
-                            )
+                            rng.choice(self._current_buffer.columns, col_size)
                         )
                     )
                 elif param == "chunksize":
-                    params_dict[param] = np.random.choice(
+                    params_dict[param] = rng.choice(
                         [
                             None,
-                            np.random.randint(
+                            rng.integers(
                                 low=1, high=max(1, len(self._current_buffer))
                             ),
                         ]
                     )
             else:
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)

python/cudf/cudf/_fuzz_testing/io.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022, NVIDIA CORPORATION.
+# Copyright (c) 2020-2024, NVIDIA CORPORATION.
 
 import copy
 import json
@@ -91,8 +91,9 @@ def get_next_regression_params(self):
         return dtypes_meta, num_rows, num_cols, seed
 
     def set_rand_params(self, params):
+        rng = np.random.default_rng(seed=None)
         params_dict = {
-            param: np.random.choice(values) for param, values in params.items()
+            param: rng.choice(values) for param, values in params.items()
         }
         self._current_params["test_kwargs"] = self.process_kwargs(
             params_dict=params_dict

python/cudf/cudf/_fuzz_testing/json.py

@@ -80,7 +80,7 @@ def generate_input(self):
             # https://github.com/rapidsai/cudf/issues/7086
             # dtypes_list.extend(["list"])
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
             self._current_params["seed"] = seed
@@ -105,14 +105,15 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if param == "dtype" and values == ALL_POSSIBLE_VALUES:
-                dtype_val = np.random.choice(
+                dtype_val = rng.choice(
                     [True, self._current_buffer.dtypes.to_dict()]
                 )
                 params_dict[param] = _get_dtype_param_value(dtype_val)
             else:
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)
 
 
@@ -155,7 +156,7 @@ def generate_input(self):
             # https://github.com/rapidsai/cudf/issues/7086
             # dtypes_list.extend(["list"])
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
             self._current_params["seed"] = seed
@@ -180,12 +181,13 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if param == "dtype" and values == ALL_POSSIBLE_VALUES:
-                dtype_val = np.random.choice(
+                dtype_val = rng.choice(
                     [True, self._current_buffer.dtypes.to_dict()]
                 )
                 params_dict[param] = _get_dtype_param_value(dtype_val)
             else:
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)

python/cudf/cudf/_fuzz_testing/orc.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2023, NVIDIA CORPORATION.
+# Copyright (c) 2020-2024, NVIDIA CORPORATION.
 
 import copy
 import io
@@ -62,13 +62,11 @@ def generate_input(self):
                 - cudf.utils.dtypes.UNSIGNED_TYPES
                 - {"datetime64[ns]"}
             )
-
+            seed = random.randint(0, 2**32 - 1)
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
-
             self._current_params["dtypes_meta"] = dtypes_meta
-            seed = random.randint(0, 2**32 - 1)
             self._current_params["seed"] = seed
             self._current_params["num_rows"] = num_rows
             self._current_params["num_cols"] = num_cols
@@ -94,42 +92,41 @@ def write_data(self, file_name):
 
     def set_rand_params(self, params):
         params_dict = {}
+        rng = np.random.default_rng(seed=None)
         for param, values in params.items():
             if values == ALL_POSSIBLE_VALUES:
                 if param == "columns":
                     col_size = self._rand(len(self._df.columns))
                     params_dict[param] = list(
-                        np.unique(np.random.choice(self._df.columns, col_size))
+                        np.unique(rng.choice(self._df.columns, col_size))
                     )
                 elif param == "stripes":
                     f = io.BytesIO(self._current_buffer)
                     orcFile = pa.orc.ORCFile(f)
                     stripes = list(range(orcFile.nstripes))
-                    params_dict[param] = np.random.choice(
+                    params_dict[param] = rng.choice(
                         [
                             None,
                             list(
                                 map(
                                     int,
                                     np.unique(
-                                        np.random.choice(
-                                            stripes, orcFile.nstripes
-                                        )
+                                        rng.choice(stripes, orcFile.nstripes)
                                     ),
                                 )
                             ),
                         ]
                     )
                 elif param == "use_index":
-                    params_dict[param] = np.random.choice([True, False])
+                    params_dict[param] = rng.choice([True, False])
                 elif param in ("skiprows", "num_rows"):
-                    params_dict[param] = np.random.choice(
+                    params_dict[param] = rng.choice(
                         [None, self._rand(len(self._df))]
                     )
             else:
                 if not isinstance(values, list):
                     raise TypeError("values must be of type list")
-                params_dict[param] = np.random.choice(values)
+                params_dict[param] = rng.choice(values)
         self._current_params["test_kwargs"] = self.process_kwargs(params_dict)
 
 
@@ -177,12 +174,11 @@ def generate_input(self):
                 # https://github.com/rapidsai/cudf/issues/7355
                 - cudf.utils.dtypes.DATETIME_TYPES
             )
-
+            seed = random.randint(0, 2**32 - 1)
             dtypes_meta, num_rows, num_cols = _generate_rand_meta(
-                self, dtypes_list
+                self, dtypes_list, seed
             )
             self._current_params["dtypes_meta"] = dtypes_meta
-            seed = random.randint(0, 2**32 - 1)
             self._current_params["seed"] = seed
             self._current_params["num_rows"] = num_rows
             self._current_params["num_cols"] = num_cols