scipy 1.15.3__cp311-cp311-win_amd64.whl → 1.16.0rc2__cp311-cp311-win_amd64.whl

scipy/io/matlab/tests/test_mio.py

@@ -22,14 +22,13 @@ from scipy.sparse import issparse, eye_array, coo_array, csc_array
 import scipy.io
 from scipy.io.matlab import MatlabOpaque, MatlabFunction, MatlabObject
 import scipy.io.matlab._byteordercodes as boc
-from scipy.io.matlab._miobase import (
-    matdims, MatWriteError, MatReadError, matfile_version)
+from scipy.io.matlab._miobase import (matdims, MatWriteError, MatReadError,
+                                      matfile_version, MatWriteWarning)
 from scipy.io.matlab._mio import mat_reader_factory, loadmat, savemat, whosmat
 from scipy.io.matlab._mio5 import (
     MatFile5Writer, MatFile5Reader, varmats_from_mat, to_writeable,
     EmptyStructMarker)
 import scipy.io.matlab._mio5_params as mio5p
-from scipy._lib._util import VisibleDeprecationWarning
 
 
 test_data_path = pjoin(dirname(__file__), 'data')
@@ -270,7 +269,7 @@ def _check_level(label, expected, actual):
         if isinstance(expected, MatlabObject):
             assert_equal(expected.classname, actual.classname)
         for i, ev in enumerate(expected):
-            level_label = "%s, [%d], " % (label, i)
+            level_label = f"{label}, [{i}], "
             _check_level(level_label, ev, actual[i])
         return
     if ex_dtype.fields:  # probably recarray
@@ -713,12 +712,14 @@ def test_to_writeable():
     expected2 = np.array([(2, 1)], dtype=[('b', '|O8'), ('a', '|O8')])
     alternatives = (expected1, expected2)
     assert_any_equal(to_writeable({'a':1,'b':2}), alternatives)
-    # Fields with underscores discarded
-    assert_any_equal(to_writeable({'a':1,'b':2, '_c':3}), alternatives)
+    # Fields with underscores discarded with a warning message.
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_any_equal(to_writeable({'a':1, 'b':2, '_c':3}), alternatives)
     # Not-string fields discarded
     assert_any_equal(to_writeable({'a':1,'b':2, 100:3}), alternatives)
     # String fields that are valid Python identifiers discarded
-    assert_any_equal(to_writeable({'a':1,'b':2, '99':3}), alternatives)
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_any_equal(to_writeable({'a':1, 'b':2, '99':3}), alternatives)
     # Object with field names is equivalent
 
     class klass:
@@ -759,10 +760,14 @@ def test_to_writeable():
     assert_equal(res.shape, (1,))
     assert_equal(res.dtype.type, np.object_)
     # Only fields with illegal characters, falls back to EmptyStruct
-    assert_(to_writeable({'1':1}) is EmptyStructMarker)
-    assert_(to_writeable({'_a':1}) is EmptyStructMarker)
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_(to_writeable({'1':1}) is EmptyStructMarker)
+
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_(to_writeable({'_a':1}) is EmptyStructMarker)
     # Unless there are valid fields, in which case structured array
-    assert_equal(to_writeable({'1':1, 'f': 2}),
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_equal(to_writeable({'1':1, 'f': 2}),
                  np.array([(2,)], dtype=[('f', '|O8')]))
 
 
@@ -975,7 +980,9 @@ def test_func_read():
     assert isinstance(d['testfunc'], MatlabFunction)
     stream = BytesIO()
     wtr = MatFile5Writer(stream)
-    assert_raises(MatWriteError, wtr.put_variables, d)
+    # This test mat file has `__header__` field.
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        assert_raises(MatWriteError, wtr.put_variables, d)
 
 
 def test_mat_dtype():
@@ -1316,13 +1323,10 @@ def test_gh_17992(tmp_path):
     array_one = rng.random((5,3))
     array_two = rng.random((6,3))
     list_of_arrays = [array_one, array_two]
-    # warning suppression only needed for NumPy < 1.24.0
-    with np.testing.suppress_warnings() as sup:
-        sup.filter(VisibleDeprecationWarning)
-        savemat(outfile,
-                {'data': list_of_arrays},
-                long_field_names=True,
-                do_compression=True)
+    savemat(outfile,
+            {'data': list_of_arrays},
+            long_field_names=True,
+            do_compression=True)
     # round trip check
     new_dict = {}
     loadmat(outfile,
@@ -1360,6 +1364,30 @@ def test_large_m4():
 def test_gh_19223():
     from scipy.io.matlab import varmats_from_mat  # noqa: F401
 
+
+def test_invalid_field_name_warning():
+    names_vars = (
+        ('_1', mlarr(np.arange(10))),
+        ('mystr', mlarr('a string')))
+    check_mat_write_warning(names_vars)
+
+    names_vars = (('mymap', {"a": 1, "_b": 2}),)
+    check_mat_write_warning(names_vars)
+
+    names_vars = (('mymap', {"a": 1, "1a": 2}),)
+    check_mat_write_warning(names_vars)
+
+
+def check_mat_write_warning(names_vars):
+    class C:
+        def items(self):
+            return names_vars
+
+    stream = BytesIO()
+    with pytest.warns(MatWriteWarning, match='Starting field name with'):
+        savemat(stream, C())
+
+
 def test_corrupt_files():
     # Test we can detect truncated or corrupt (all zero) files.
     for n in (2, 4, 10, 19):

scipy/io/matlab/tests/test_mio_funcs.py

@@ -18,7 +18,7 @@ def read_minimat_vars(rdr):
         hdr, next_position = rdr.read_var_header()
         name = 'None' if hdr.name is None else hdr.name.decode('latin1')
         if name == '':
-            name = 'var_%d' % i
+            name = f'var_{i}'
             i += 1
         res = rdr.read_var_array(hdr, process=False)
         rdr.mat_stream.seek(next_position)

scipy/io/tests/test_mmio.py

@@ -759,7 +759,7 @@ class TestMMIOCoordinate:
                 # check for right entries in matrix
                 assert_array_equal(A.row, [n-1])
                 assert_array_equal(A.col, [n-1])
-                assert_allclose(A.data, [float('%%.%dg' % precision % value)])
+                assert_allclose(A.data, [float(f'{value:.{precision}g}')])
 
     def test_bad_number_of_coordinate_header_fields(self):
         s = """\
@@ -823,3 +823,9 @@ def test_threadpoolctl():
 
     with threadpoolctl.threadpool_limits(limits=2, user_api='scipy'):
         assert_equal(fmm.PARALLELISM, 2)
+
+
+def test_gh21999_file_not_exist():
+    tmpdir = mkdtemp(suffix=str(threading.get_native_id()))
+    wrong_fn = os.path.join(tmpdir, 'not_exist_test_file.mtx')
+    assert_raises(FileNotFoundError, mmread, wrong_fn)

scipy/io/tests/test_wavfile.py

@@ -334,6 +334,47 @@ def test_write_roundtrip_rf64(tmpdir):
     data2[0] = 0
 
 
+# Fake a non-seekable file-like object without resorting to subprocesses.
+class Nonseekable:
+    def __init__(self, fp):
+        self.fp = fp
+
+    def seekable(self):
+        return False
+    
+    def read(self, size=-1, /):
+        return self.fp.read(size)
+    
+    def close(self):
+        self.fp.close()
+
+
+def test_streams():
+    for filename in ['test-44100Hz-le-1ch-4bytes.wav',
+                     'test-8000Hz-le-2ch-1byteu.wav',
+                     'test-44100Hz-2ch-32bit-float-le.wav',
+                     'test-44100Hz-2ch-32bit-float-be.wav',
+                     'test-8000Hz-le-5ch-9S-5bit.wav',
+                     'test-8000Hz-le-4ch-9S-12bit.wav',
+                     'test-8000Hz-le-3ch-5S-24bit.wav',
+                     'test-1234Hz-le-1ch-10S-20bit-extra.wav',
+                     'test-8000Hz-le-3ch-5S-36bit.wav',
+                     'test-8000Hz-le-3ch-5S-45bit.wav',
+                     'test-8000Hz-le-3ch-5S-53bit.wav',
+                     'test-8000Hz-le-3ch-5S-64bit.wav',
+                     'test-44100Hz-be-1ch-4bytes.wav', # RIFX
+                     'test-44100Hz-le-1ch-4bytes-rf64.wav']:
+        dfname = datafile(filename)
+        with open(dfname, 'rb') as fp1, open(dfname, 'rb') as fp2:
+            rate1, data1 = wavfile.read(fp1)
+            rate2, data2 = wavfile.read(Nonseekable(fp2))
+            rate3, data3 = wavfile.read(dfname, mmap=False)
+            assert_equal(rate1, rate3)
+            assert_equal(rate2, rate3)
+            assert_equal(data1, data3)
+            assert_equal(data2, data3)
+
+
 def test_read_unknown_filetype_fail():
     # Not an RIFF
     for mmap in [False, True]:

scipy/io/wavfile.py

@@ -9,6 +9,7 @@ Functions
 
 """
 import io
+import os
 import sys
 import numpy as np
 import struct
@@ -27,6 +28,47 @@ class WavFileWarning(UserWarning):
     pass
 
 
+class SeekEmulatingReader:
+    """
+    Tracks stream position, provides tell(), and emulates only those
+    seeks that can be supported by reading forward. Other seeks raise
+    io.UnsupportedOperation. Note that this class implements only the
+    minimum necessary to keep wavfile.read() happy.
+    """
+    def __init__(self, reader):
+        self.reader = reader
+        self.pos = 0
+
+    def read(self, size=-1, /):
+        data = self.reader.read(size)
+        self.pos += len(data)
+        return data
+    
+    def seek(self, offset, whence=os.SEEK_SET, /):
+        match whence:
+            case os.SEEK_SET if offset >= self.pos:
+                self.read(offset - self.pos) # convert to relative
+            case os.SEEK_CUR if offset >= 0:
+                self.read(offset) # advance by offset
+            case os.SEEK_END if offset == 0:
+                self.read() # advance to end of stream
+            case _:
+                raise io.UnsupportedOperation("SeekEmulatingReader was asked to emulate"
+                                              " a seek operation it does not support.")
+        return self.pos
+    
+    def tell(self):
+        return self.pos
+    
+    def close(self):
+        self.reader.close()
+    
+    # np.fromfile expects to be able to call flush(), and _read_data_chunk
+    # expects to catch io.UnsupportedOperation if np.fromfile fails.
+    def flush(self):
+        raise io.UnsupportedOperation("SeekEmulatingReader can't flush.")
+
+
 class WAVE_FORMAT(IntEnum):
     """
     WAVE form wFormatTag IDs
@@ -397,7 +439,7 @@ def _read_fmt_chunk(fid, is_big_endian):
 
 
 def _read_data_chunk(fid, format_tag, channels, bit_depth, is_big_endian, is_rf64,
-                     block_align, mmap=False):
+                     block_align, mmap=False, rf64_chunk_size=None):
     """
     Notes
     -----
@@ -431,11 +473,8 @@ def _read_data_chunk(fid, format_tag, channels, bit_depth, is_big_endian, is_rf6
     if not is_rf64:
         size = struct.unpack(fmt+'I', fid.read(4))[0]
     else:
-        pos = fid.tell()
         # chunk size is stored in global file header for RF64
-        fid.seek(28)
-        size = struct.unpack('<Q', fid.read(8))[0]
-        fid.seek(pos)
+        size = rf64_chunk_size
         # skip data chunk size as it is 0xFFFFFFF
         fid.read(4)
 
@@ -538,6 +577,7 @@ def _read_riff_chunk(fid):
     # Size of entire file
     if not is_rf64:
         file_size = struct.unpack(fmt, fid.read(4))[0] + 8
+        rf64_chunk_size = None
         str2 = fid.read(4)
     else:
         # Skip 0xFFFFFFFF (-1) bytes
@@ -548,14 +588,15 @@ def _read_riff_chunk(fid):
             raise ValueError("Invalid RF64 file: ds64 chunk not found.")
         ds64_size = struct.unpack("<I", fid.read(4))[0]
         file_size = struct.unpack(fmt, fid.read(8))[0] + 8
+        rf64_chunk_size = struct.unpack('<Q', fid.read(8))[0]
         # Ignore additional attributes of ds64 chunk like sample count, tables, etc.
         # and just skip to the next chunk
-        fid.seek(ds64_size - 8, 1)
+        fid.seek(ds64_size - 16, 1)
 
     if str2 != b'WAVE':
         raise ValueError(f"Not a WAV file. RIFF form type is {repr(str2)}.")
 
-    return file_size, is_big_endian, is_rf64
+    return file_size, is_big_endian, is_rf64, rf64_chunk_size
 
 
 def _handle_pad_byte(fid, size):
@@ -672,9 +713,12 @@ def read(filename, mmap=False):
         mmap = False
     else:
         fid = open(filename, 'rb')
+    
+    if not (was_seekable := fid.seekable()):
+        fid = SeekEmulatingReader(fid)
 
     try:
-        file_size, is_big_endian, is_rf64 = _read_riff_chunk(fid)
+        file_size, is_big_endian, is_rf64, rf64_chunk_size = _read_riff_chunk(fid)
         fmt_chunk_received = False
         data_chunk_received = False
         while fid.tell() < file_size:
@@ -713,7 +757,8 @@ def read(filename, mmap=False):
                 if not fmt_chunk_received:
                     raise ValueError("No fmt chunk before data")
                 data = _read_data_chunk(fid, format_tag, channels, bit_depth,
-                                        is_big_endian, is_rf64, block_align, mmap)
+                                        is_big_endian, is_rf64, block_align,
+                                        mmap, rf64_chunk_size)
             elif chunk_id == b'LIST':
                 # Someday this could be handled properly but for now skip it
                 _skip_unknown_chunk(fid, is_big_endian)
@@ -727,7 +772,9 @@ def read(filename, mmap=False):
     finally:
         if not hasattr(filename, 'read'):
             fid.close()
-        else:
+        elif was_seekable:
+            # Rewind, if we are able, so that caller can do something
+            # else with the raw WAV stream.
             fid.seek(0)
 
     return fs, data