fix: precommit check

Author: jharlow-intel

.pylintrc

@@ -0,0 +1,5 @@
+[MASTER]
+extension-pkg-allow-list=numpy,mkl_random.mklrand
+
+[TYPECHECK]
+generated-members=RandomState,min,max

mkl_random/__init__.py

@@ -93,9 +93,17 @@
     test = PytestTester(__name__)
     del PytestTester
 
-from ._patch import monkey_patch, use_in_numpy, restore, is_patched, patched_names, mkl_random
 from mkl_random import interfaces
 
+from ._patch import (
+    is_patched,
+    mkl_random,
+    monkey_patch,
+    patched_names,
+    restore,
+    use_in_numpy,
+)
+
 __all__ = [
     "MKLRandomState",
     "RandomState",

mkl_random/src/_patch.pyx

@@ -35,10 +35,11 @@ replace NumPy's `Generator`/`default_rng()` unless mkl_random provides fully
 compatible replacements.
 """
 
-from threading import Lock, local
 from contextlib import ContextDecorator
+from threading import Lock, local
 
 import numpy as _np
+
 from . import mklrand as _mr
 
 
@@ -106,7 +107,9 @@ class _GlobalPatch:
 
     def _validate_module(self, numpy_module):
         if not hasattr(numpy_module, "random"):
-            raise TypeError("Expected a numpy-like module with a `.random` attribute.")
+            raise TypeError(
+                "Expected a numpy-like module with a `.random` attribute."
+            )
 
     def _apply_patch(self, numpy_module, names, strict):
         np_random = numpy_module.random
@@ -125,7 +128,8 @@ class _GlobalPatch:
             for name, value in originals.items():
                 setattr(np_random, name, value)
             raise AttributeError(
-                "Could not patch these names (missing on numpy.random or mkl_random.mklrand): "
+                "Could not patch these names (missing on numpy.random or "
+                "mkl_random.mklrand): "
                 + ", ".join([str(x) for x in missing])
             )
 
@@ -134,7 +138,13 @@ class _GlobalPatch:
         self._originals = originals
         self._patched = tuple(patched)
 
-    def do_patch(self, numpy_module=None, names=None, strict=False, verbose=False):
+    def do_patch(
+        self,
+        numpy_module=None,
+        names=None,
+        strict=False,
+        verbose=False,
+    ):
         if numpy_module is None:
             numpy_module = _np
         names = self._normalize_names(names)
@@ -148,11 +158,13 @@ class _GlobalPatch:
             else:
                 if self._numpy_module is not numpy_module:
                     raise RuntimeError(
-                        "Already patched a different numpy module; call restore() first."
+                        "Already patched a different numpy module; "
+                        "call restore() first."
                     )
                 if names != self._requested_names:
                     raise RuntimeError(
-                        "Already patched with a different names set; call restore() first."
+                        "Already patched with a different names set; "
+                        "call restore() first."
                     )
             self._patch_count += 1
             self._tls.local_count = local_count + 1
@@ -163,7 +175,8 @@ class _GlobalPatch:
             if local_count <= 0:
                 if verbose:
                     print(
-                        "Warning: restore called more times than monkey_patch in this thread."
+                        "Warning: restore called more times than monkey_patch "
+                        "in this thread."
                     )
                 return
 
@@ -192,7 +205,8 @@ _patch = _GlobalPatch()
 
 def monkey_patch(numpy_module=None, names=None, strict=False, verbose=False):
     """
-    Enables using mkl_random in the given NumPy module by patching `numpy.random`.
+    Enables using mkl_random in the given NumPy module by patching
+    `numpy.random`.
 
     Examples
     --------
@@ -229,7 +243,8 @@ def use_in_numpy(numpy_module=None, names=None, strict=False, verbose=False):
 
 def restore(verbose=False):
     """
-    Disables using mkl_random in NumPy by restoring the original `numpy.random` symbols.
+    Disables using mkl_random in NumPy by restoring the original
+    `numpy.random` symbols.
     """
     _patch.do_restore(verbose=bool(verbose))
 
@@ -265,7 +280,11 @@ class mkl_random(ContextDecorator):
         self._strict = strict
 
     def __enter__(self):
-        monkey_patch(numpy_module=self._numpy_module, names=self._names, strict=self._strict)
+        monkey_patch(
+            numpy_module=self._numpy_module,
+            names=self._names,
+            strict=self._strict,
+        )
         return self
 
     def __exit__(self, *exc):

mkl_random/tests/test_patch.py

@@ -24,23 +24,22 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import numpy as np
-import mkl_random
 import pytest
 
+import mkl_random
+
+
 def test_is_patched():
-    """
-    Test that is_patched() returns correct status.
-    """
+    """Test that is_patched() returns correct status."""
     assert not mkl_random.is_patched()
     mkl_random.monkey_patch(np)
     assert mkl_random.is_patched()
     mkl_random.restore()
     assert not mkl_random.is_patched()
 
+
 def test_monkey_patch_and_restore():
-    """
-    Test that monkey_patch replaces and restore brings back original functions.
-    """
+    """Test monkey_patch replacement and restore of original functions."""
     # Store original functions
     orig_normal = np.random.normal
     orig_randint = np.random.randint
@@ -55,8 +54,8 @@ def test_monkey_patch_and_restore():
         assert np.random.RandomState is not orig_RandomState
 
         # Check that they are from mkl_random
-        assert np.random.normal is mkl_random.mklrand.normal
-        assert np.random.RandomState is mkl_random.mklrand.RandomState
+        assert np.random.normal is mkl_random.normal
+        assert np.random.RandomState is mkl_random.RandomState
 
     finally:
         mkl_random.restore()
@@ -67,10 +66,9 @@ def test_monkey_patch_and_restore():
     assert np.random.randint is orig_randint
     assert np.random.RandomState is orig_RandomState
 
+
 def test_context_manager():
-    """
-    Test that the context manager patches and automatically restores.
-    """
+    """Test context manager patching and automatic restoration."""
     orig_uniform = np.random.uniform
     assert not mkl_random.is_patched()
 
@@ -84,10 +82,9 @@ def test_context_manager():
     assert not mkl_random.is_patched()
     assert np.random.uniform is orig_uniform
 
+
 def test_patched_functions_callable():
-    """
-    Smoke test to ensure some patched functions can be called without error.
-    """
+    """Smoke test that patched functions are callable without errors."""
     mkl_random.monkey_patch(np)
     try:
         # These calls should now be routed to mkl_random's implementations
@@ -105,10 +102,9 @@ def test_patched_functions_callable():
     finally:
         mkl_random.restore()
 
+
 def test_patched_names():
-    """
-    Test that patched_names() returns a list of patched symbols.
-    """
+    """Test that patched_names() returns patched symbol names."""
     try:
         mkl_random.monkey_patch(np)
         names = mkl_random.patched_names()
@@ -119,21 +115,20 @@ def test_patched_names():
     finally:
         mkl_random.restore()
 
+
 def test_monkey_patch_strict_raises_attribute_error():
-    """
-    Test that strict mode raises AttributeError when patching non-existent names.
-    """
+    """Test strict mode raises AttributeError for missing patch names."""
     # Attempt to patch a clearly non-existent symbol in strict mode.
     with pytest.raises(AttributeError):
         mkl_random.monkey_patch(np, strict=True, names=["nonexistent_symbol"])
 
+
 def test_use_in_numpy_is_alias_for_monkey_patch():
-    """
-    Test that use_in_numpy is a backward-compatible alias for monkey_patch.
-    """
+    """Test use_in_numpy remains a backward-compatible alias."""
     assert hasattr(mkl_random, "use_in_numpy")
     assert mkl_random.use_in_numpy is mkl_random.monkey_patch
 
+
 def test_patch_redundant_patching():
     orig_normal = np.random.normal
     assert not mkl_random.is_patched()
@@ -142,11 +137,11 @@ def test_patch_redundant_patching():
     mkl_random.monkey_patch(np)
 
     assert mkl_random.is_patched()
-    assert np.random.normal is mkl_random.mklrand.normal
+    assert np.random.normal is mkl_random.normal
 
     mkl_random.restore()
     assert mkl_random.is_patched()
-    assert np.random.normal is mkl_random.mklrand.normal
+    assert np.random.normal is mkl_random.normal
 
     mkl_random.restore()
     assert not mkl_random.is_patched()

setup.py

@@ -91,16 +91,15 @@ def extensions():
             library_dirs=lib_dirs,
             extra_compile_args=eca,
             define_macros=defs + [("NDEBUG", None)],
-            language="c++"
+            language="c++",
         ),
-
         Extension(
             "mkl_random._patch",
             sources=[join("mkl_random", "src", "_patch.pyx")],
             include_dirs=[np.get_include()],
             define_macros=defs + [("NDEBUG", None)],
             language="c",
-        )
+        ),
     ]
 
     return exts