scipy-doctest 1.4__tar.gz → 1.5__tar.gz

{scipy_doctest-1.4 → scipy_doctest-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: scipy_doctest
-Version: 1.4
+Version: 1.5
 Summary: Configurable, whitespace-insensitive, floating-point-aware doctest helpers.
 Maintainer-email: SciPy developers <scipy-dev@python.org>
 Requires-Python: >=3.8

{scipy_doctest-1.4 → scipy_doctest-1.5}/scipy_doctest/__init__.py

@@ -3,7 +3,7 @@ Configurable, whitespace-insensitive, floating-point-aware doctest helpers.
 """
 
 
-__version__ = "1.4"
+__version__ = "1.5"
 
 try:
     # register internal modules with pytest; obscure errors galore otherwise

{scipy_doctest-1.4 → scipy_doctest-1.5}/scipy_doctest/impl.py

@@ -148,8 +148,12 @@ class DTConfig:
                   'masked_array': np.ma.masked_array,
                   'int64': np.int64,
                   'uint64': np.uint64,
-                  'int8': np.int8,
                   'int32': np.int32,
+                  'uint32': np.uint32,
+                  'int16': np.int16,
+                  'uint16': np.uint16,
+                  'int8': np.int8,
+                  'uint8': np.uint8,
                   'float32': np.float32,
                   'float64': np.float64,
                   'dtype': np.dtype,
@@ -262,6 +266,29 @@ def has_masked(got):
     return 'masked_array' in got and '--' in got
 
 
+def try_split_shape_from_abbrv(s_got):
+    """NumPy 2.2 added shape=(123,) to abbreviated array repr.
+
+    If present, split it off, and return a tuple. `(array, shape)`
+    """
+    if "shape=" in s_got:
+        # handle
+        # array(..., shape=(1000,))
+        # array(..., shape=(100, 100))
+        # array(..., shape=(100, 100), dtype=uint16)
+        match = re.match(r'(.+),\s+shape=\(([\d\s,]+)\)(.+)', s_got, flags=re.DOTALL)
+        if match:
+            grp = match.groups()
+
+            s_got = grp[0] + grp[-1]
+            s_got = s_got.replace(',,', ',')
+            shape_str = f'({grp[1]})'
+
+            return ''.join(s_got.split('...,')), shape_str
+
+    return ''.join(s_got.split('...,')), ''
+
+
 class DTChecker(doctest.OutputChecker):
     obj_pattern = re.compile(r'at 0x[0-9a-fA-F]+>')
     vanilla = doctest.OutputChecker()
@@ -325,11 +352,17 @@ class DTChecker(doctest.OutputChecker):
                 return self.check_output(s_want, s_got, optionflags)
             
             #handle array abbreviation for n-dimensional arrays, n >= 1
-            ndim_array = (s_want.startswith("array([") and s_want.endswith("])") and 
-                          s_got.startswith("array([") and s_got.endswith("])"))
+            ndim_array = (s_want.startswith("array([") and "..." in s_want and 
+                          s_got.startswith("array([") and "..." in s_got)
             if ndim_array:
-                s_want = ''.join(s_want.split('...,'))
-                s_got = ''.join(s_got.split('...,'))
+                s_want, want_shape = try_split_shape_from_abbrv(s_want)
+                s_got, got_shape = try_split_shape_from_abbrv(s_got)
+
+                if got_shape:
+                    # NumPy 2.2 output, `with shape=`, check the shapes, too
+                    s_want = f"{s_want}, {want_shape}"
+                    s_got = f"{s_got}, {got_shape}"
+
                 return self.check_output(s_want, s_got, optionflags)
 
             # maybe we are dealing with masked arrays?

{scipy_doctest-1.4 → scipy_doctest-1.5}/scipy_doctest/tests/module_cases.py

@@ -164,14 +164,25 @@ def array_abbreviation():
     """
     Numpy abbreviates arrays, check that it works.
 
-    NB: the implementation might need to change when
-    numpy finally disallows default-creating ragged arrays.
-    Currently, `...` gets interpreted as an Ellipsis,
-    thus the `a_want/a_got` variables in DTChecker are in fact
-    object arrays.
+    XXX: check if ... creates ragged arrays, avoid if so.
+
+    NumPy 2.2 abbreviations
+    =======================
+
+    NumPy 2.2 adds shape=(...) to abbreviated arrays.
+
+    This is not a valid argument to `array(...), so it cannot be eval-ed,
+    and need to be removed for doctesting.
+
+    The implementation handles both formats, and checks the shapes if present
+    in the actual output. If not present in the output, they are ignored.
+
     >>> import numpy as np
     >>> np.arange(10000)
-    array([0, 1, 2, ..., 9997, 9998, 9999])
+    array([0, 1, 2, ..., 9997, 9998, 9999], shape=(10000,))
+
+    >>> np.arange(10000, dtype=np.uint16)
+    array([   0,    1,    2, ..., 9997, 9998, 9999], shape=(10000,), dtype=uint16)
 
     >>> np.diag(np.arange(33)) / 30
     array([[0., 0., 0., ..., 0., 0.,0.],
@@ -180,19 +191,20 @@ def array_abbreviation():
            ...,
            [0., 0., 0., ..., 1., 0., 0.],
            [0., 0., 0., ..., 0., 1.03333333, 0.],
-           [0., 0., 0., ..., 0., 0., 1.06666667]])
+           [0., 0., 0., ..., 0., 0., 1.06666667]], shape=(33, 33))
 
 
-    >>> np.diag(np.arange(1, 1001, dtype=float))
+    >>> np.diag(np.arange(1, 1001, dtype=np.uint16))
     array([[1,    0,    0, ...,    0,    0,    0],
            [0,    2,    0, ...,    0,    0,    0],
            [0,    0,    3, ...,    0,    0,    0],
             ...,
            [0,    0,    0, ...,  998,    0,    0],
            [0,    0,    0, ...,    0,  999,    0],
-           [0,    0,    0, ...,    0,    0, 1000]])
+           [0,    0,    0, ...,    0,    0, 1000]], shape=(1000, 1000), dtype=uint16)
     """
 
+
 def nan_equal():
     """
     Test that nans are treated as equal.