wavemap 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

wavemap/__init__.py

@@ -26,31 +26,34 @@ Typical usage:
     wm /= 2
     # Each sample in the file is scaled by half.
 """
+
+from typing import Optional, Union
+from collections.abc import Callable
+
+import numpy as np
+import xmod
+
 from . import docs
 from .convert import convert
 from .raw import RawMap, warn
 from .read import ReadMap as ReadMap
 from .write import WriteMap as WriteMap
-from typing import Callable, Optional, Union
-import numpy as np
-import xmod
 
 __all__ = (
-    'wavemap',
-    'RawMap',
-    'ReadMap',
-    'WriteMap',
-    'copy_to',
-    'new_like',
-    'convert',
+    "wavemap",
+    "RawMap",
+    "ReadMap",
+    "WriteMap",
+    "copy_to",
+    "new_like",
+    "convert",
 )
-__version__ = '2.0.1'
 
 copy_to = WriteMap.copy_to
 new_like = WriteMap.new_like
-_DOKS = {warn: '<function warn: print to stderr>'}
-_WRITE_PARAMETERS = 'dtype', 'shape', 'sample_rate'
-_READ_PARAMETERS = 'order', 'always_2d'
+_DOKS = {warn: "<function warn: print to stderr>"}
+_WRITE_PARAMETERS = "dtype", "shape", "sample_rate"
+_READ_PARAMETERS = "order", "always_2d"
 
 
 @xmod(mutable=True)
@@ -60,20 +63,20 @@ def wavemap(
     #
     # Read parameters
     #
-    mode: str = 'r',
-    order: Optional[str] = None,
+    mode: str = "r",
+    order: str | None = None,
     always_2d: bool = False,
     #
     # Write parameters
     #
-    dtype: Optional[np.dtype] = None,
-    shape: Union[None, int, tuple] = None,
+    dtype: np.dtype | None = None,
+    shape: None | int | tuple = None,
     sample_rate: int = 0,
     roffset: int = 0,
     #
     # Read and write parameters
     #
-    warn: Optional[Callable] = warn,
+    warn: Callable | None = warn,
 ):
     """
     Memory map a WAVE file to a `numpy` array
@@ -81,18 +84,18 @@ def wavemap(
     Return an instance of `ReadMap` or `WriteMap`, depending on
     `mode`.
     """
-    if mode.startswith('w'):
+    if mode.startswith("w"):
         if not dtype:
-            raise ValueError('dtype must be set for write')
+            raise ValueError("dtype must be set for write")
         if not shape:
-            raise ValueError('shape must be set for write')
+            raise ValueError("shape must be set for write")
         if not sample_rate:
-            raise ValueError('sample_rate must be set for write')
+            raise ValueError("sample_rate must be set for write")
 
         if order:
-            raise ValueError('order cannot be set for write')
+            raise ValueError("order cannot be set for write")
         if always_2d:
-            raise ValueError('always_2d cannot be set for write')
+            raise ValueError("always_2d cannot be set for write")
 
         return WriteMap(
             filename=filename,
@@ -104,9 +107,9 @@ def wavemap(
         )
     else:
         if shape:
-            raise ValueError('shape cannot be set for write')
+            raise ValueError("shape cannot be set for write")
         if sample_rate:
-            raise ValueError('sample_rate cannot be set for write')
+            raise ValueError("sample_rate cannot be set for write")
 
         result = ReadMap(
             filename=filename,

wavemap/convert.py

@@ -1,11 +1,10 @@
-from numpy.lib.stride_tricks import as_strided
 from typing import Optional
+
 import numpy as np
+from numpy.lib.stride_tricks import as_strided
 
 
-def convert(
-    arr: np.ndarray, dtype: Optional[np.dtype], must_copy: bool = False
-):
+def convert(arr: np.ndarray, dtype: np.dtype | None, must_copy: bool = False):
     """
     Returns a copy of a numpy array or matrix that represents audio data in
     another type, scaling and shifting as necessary.
@@ -27,8 +26,8 @@ def convert(
             arr = np.copy(arr)
         return arr
 
-    old_int = 'int' in str(old_t)
-    new_int = 'int' in str(new_t)
+    old_int = "int" in str(old_t)
+    new_int = "int" in str(new_t)
 
     if not (new_int or old_int):
         # Convert between floats
@@ -96,8 +95,15 @@ def _twenty_four_bit(shape, new, raw, itemsize):
     assert not (frames % 4)
 
     # https://stackoverflow.com/a/34128171/4383
-    raw = new(shape=(itemsize * frames // 4,), dtype='int32')
-    strided = as_strided(raw, strides=(12, 3,), shape=(frames, 4))
+    raw = new(shape=(itemsize * frames // 4,), dtype="int32")
+    strided = as_strided(
+        raw,
+        strides=(
+            12,
+            3,
+        ),
+        shape=(frames, 4),
+    )
     reshaped = np.reshape(strided, shape=shape)
 
     result = reshaped & 0x00FFFFFF

wavemap/docs.py

@@ -15,9 +15,9 @@ Think of this as `self`.  (This is because you need to implement `__new__`
 and not `__init__` when deriving from `np.darray`.)
 """
 
-DTYPE = 'The numpy datatype of the samples in the file.'
+DTYPE = "The numpy datatype of the samples in the file."
 
-FILENAME = 'The name of the file being mapped'
+FILENAME = "The name of the file being mapped"
 
 ORDER = """
 Samples usually get laid out in into a `numpy.darray` with`
@@ -63,9 +63,9 @@ In mode `'w+'`, "write", the file is opened for write, and overwrites
 whatever else is there.
 """
 
-OFFSET = 'How many bytes in the file before the WAV data'
-ROFFSET = 'How many bytes in the file after the WAV data'
-SAMPLE_RATE = 'The sample rate in Hz (cycles per second)'
+OFFSET = "How many bytes in the file before the WAV data"
+ROFFSET = "How many bytes in the file after the WAV data"
+SAMPLE_RATE = "The sample rate in Hz (cycles per second)"
 
 SHAPE = """
 The shape of the resulting numpy.darray. Can be a tuple, or a positive
@@ -87,19 +87,19 @@ def arguments(*names, subs=None):
     names = [(i, subs.get(i, i).upper()) for i in names]
     missing = [n for (n, a) in names if a not in globals()]
     if missing:
-        raise ValueError(f'Cannot document arguments {missing}')
+        raise ValueError(f"Cannot document arguments {missing}")
 
-    yield 'ARGUMENTS'
+    yield "ARGUMENTS"
     for name, attr in names:
-        yield f'  {name}'
+        yield f"  {name}"
         for line in globals()[attr].strip().splitlines():
-            yield line and f'    {line}'
-        yield ''
+            yield line and f"    {line}"
+        yield ""
 
 
 def add_arguments(func, names, subs=None):
     params = arguments(*names, subs=subs)
-    func.__doc__ = func.__doc__.rstrip() + '\n\n' + '\n'.join(params)
+    func.__doc__ = func.__doc__.rstrip() + "\n\n" + "\n".join(params)
     return func
 
 

wavemap/memmap.py

@@ -1,9 +1,9 @@
-from numpy.compat import os_fspath, contextlib_nullcontext, is_pathlib_path
-from numpy.core.numeric import uint8, ndarray, dtype
-from numpy.core.overrides import set_module
 import numpy as np
+from numpy.compat import contextlib_nullcontext, is_pathlib_path, os_fspath
+from numpy.core.numeric import dtype, ndarray, uint8
+from numpy.core.overrides import set_module
 
-__all__ = ['memmap']
+__all__ = ["memmap"]
 
 dtypedescr = dtype
 valid_filemodes = ["r", "c", "r+", "w+"]
@@ -17,7 +17,7 @@ mode_equivalents = {
 }
 
 
-@set_module('numpy')
+@set_module("numpy")
 class memmap(ndarray):
     """Create a memory-map to an array stored in a *binary* file on disk.
 
@@ -204,10 +204,10 @@ class memmap(ndarray):
         subtype,
         filename,
         dtype=uint8,
-        mode='r+',
+        mode="r+",
         offset=0,
         shape=None,
-        order='C',
+        order="C",
         roffset=0,
     ):
         # Import here to minimize 'import numpy' overhead
@@ -224,15 +224,13 @@ class memmap(ndarray):
                     )
                 ) from None
 
-        if mode == 'w+' and shape is None:
+        if mode == "w+" and shape is None:
             raise ValueError("shape must be given")
 
-        if hasattr(filename, 'read'):
+        if hasattr(filename, "read"):
             f_ctx = contextlib_nullcontext(filename)
         else:
-            f_ctx = open(
-                os_fspath(filename), ('r' if mode == 'c' else mode) + 'b'
-            )
+            f_ctx = open(os_fspath(filename), ("r" if mode == "c" else mode) + "b")
 
         with f_ctx as fid:
             fid.seek(0, 2)
@@ -260,14 +258,14 @@ class memmap(ndarray):
 
             bytes = int(offset + size * _dbytes + roffset)
 
-            if mode in ('w+', 'r+') and flen < bytes:
+            if mode in ("w+", "r+") and flen < bytes:
                 fid.seek(bytes - 1, 0)
-                fid.write(b'\0')
+                fid.write(b"\0")
                 fid.flush()
 
-            if mode == 'c':
+            if mode == "c":
                 acc = mmap.ACCESS_COPY
-            elif mode == 'r':
+            elif mode == "r":
                 acc = mmap.ACCESS_READ
             else:
                 acc = mmap.ACCESS_WRITE
@@ -304,7 +302,7 @@ class memmap(ndarray):
         return self
 
     def __array_finalize__(self, obj):
-        if hasattr(obj, '_mmap') and np.may_share_memory(self, obj):
+        if hasattr(obj, "_mmap") and np.may_share_memory(self, obj):
             self._mmap = obj._mmap
             self.filename = obj.filename
             self.offset = obj.offset
@@ -330,11 +328,11 @@ class memmap(ndarray):
         memmap
 
         """
-        if self.base is not None and hasattr(self.base, 'flush'):
+        if self.base is not None and hasattr(self.base, "flush"):
             self.base.flush()
 
     def __array_wrap__(self, arr, context=None):
-        arr = super(memmap, self).__array_wrap__(arr, context)
+        arr = super().__array_wrap__(arr, context)
 
         # Return a memmap if a memmap was given as the output of the
         # ufunc. Leave the arr class unchanged if self is not a memmap
@@ -349,7 +347,7 @@ class memmap(ndarray):
         return arr.view(np.ndarray)
 
     def __getitem__(self, index):
-        res = super(memmap, self).__getitem__(index)
+        res = super().__getitem__(index)
         if type(res) is memmap and res._mmap is None:
             return res.view(type=ndarray)
         return res

wavemap/raw.py

@@ -1,10 +1,13 @@
+import sys
+from typing import Optional, Union
+from collections.abc import Callable
+
+import numpy as np
+
 from . import docs
 from .memmap import memmap
-from typing import Callable, Optional, Union
-import numpy as np
-import sys
 
-int24 = 'int24'
+int24 = "int24"
 
 
 def warn(msg):
@@ -12,20 +15,20 @@ def warn(msg):
 
 
 class RawMap(memmap):
-    """"Memory map raw audio data from a disk file into a numpy matrix"""
+    """ "Memory map raw audio data from a disk file into a numpy matrix"""
 
     @docs.update
     def __new__(
         cls,
         filename: str,
         dtype: np.dtype,
-        shape: Union[tuple, int, None] = None,
-        mode: str = 'r',
+        shape: tuple | int | None = None,
+        mode: str = "r",
         offset: int = 0,
         roffset: int = 0,
-        order: Optional[str] = None,
+        order: str | None = None,
         always_2d: bool = False,
-        warn: Optional[Callable] = warn,
+        warn: Callable | None = warn,
     ):
         """Memory map raw audio data from a disk file into a numpy matrix"""
         # Documentation for parameters is in docs.py
@@ -36,22 +39,22 @@ class RawMap(memmap):
             )
 
         if offset < 0 or roffset < 0:
-            raise ValueError('offset and roffset must be non-negative')
+            raise ValueError("offset and roffset must be non-negative")
 
-        if order not in ('C', 'F', None):
+        if order not in ("C", "F", None):
             raise ValueError(f'Bad order "{order}"')
 
         if isinstance(shape, int):
             shape = (shape,)
 
         if not (shape is None or 1 <= len(shape) <= 2):
-            raise ValueError('Wave files must have 1 or 2 dimensions')
+            raise ValueError("Wave files must have 1 or 2 dimensions")
 
-        if 'w' in mode:
+        if "w" in mode:
             if not shape:
-                raise ValueError('Must set a shape in write mode')
-            order = order or 'FC'[max(shape) == shape[0]]
-            return new(mode='w+', order=order)
+                raise ValueError("Must set a shape in write mode")
+            order = order or "FC"[max(shape) == shape[0]]
+            return new(mode="w+", order=order)
 
         if str(dtype) == int24:
             itemsize = 3
@@ -62,12 +65,12 @@ class RawMap(memmap):
         audio_size = file_size - offset - roffset
         shape = _get_shape(shape, audio_size, itemsize, order, always_2d, warn)
         if itemsize == 3:
-            raise ValueError('Cannot memory map 24-bit audio')
+            raise ValueError("Cannot memory map 24-bit audio")
         return new(shape=shape)
 
 
 def file_byte_size(filename: str):
-    with open(filename, 'rb') as fp:
+    with open(filename, "rb") as fp:
         return fp.seek(0, 2)
 
 
@@ -78,27 +81,27 @@ def _get_shape(shape, audio_size, itemsize, order, always_2d, warn):
     if itemsize == 3:
         extra = audio_size % 12
         if extra and warn:
-            s = 's' if len(extra) != 1 else ''
-            warn(f'24-bit conversion lost last {extra} byte{s}, sorry')
+            s = "s" if len(extra) != 1 else ""
+            warn(f"24-bit conversion lost last {extra} byte{s}, sorry")
         audio_size -= extra
 
     frame_size = itemsize * channels
     frames = audio_size // frame_size
 
     if frames_requested and frames_requested < frames:
-        warn(f'Requested {frames_requested} frames, got {frames}')
+        warn(f"Requested {frames_requested} frames, got {frames}")
         frames = frames_requested
 
     if warn:
         extra = audio_size % frame_size
         if extra:
-            s = '' if extra == 1 else 's'
-            warn(f'{extra} byte{s} after end-of-frame discarded')
+            s = "" if extra == 1 else "s"
+            warn(f"{extra} byte{s} after end-of-frame discarded")
 
     if channels == 1 and not always_2d:
         return (frames,)
 
-    if not order or order == 'C':
+    if not order or order == "C":
         return frames, channels
 
     return channels, frames

wavemap/read.py

@@ -1,15 +1,18 @@
+import struct
+from typing import Optional, Type
+from collections.abc import Callable
+
+import numpy as np
+
 from . import docs, raw
 from .structure import wave
-from typing import Callable, Optional, Type
-import numpy as np
-import struct
 
 FLOAT_BITS_PER_SAMPLE = {32, 64}
 PCM_BITS_PER_SAMPLE = {8, 16, 24, 32, 64}
 
 BITS_PER_SAMPLE = PCM_BITS_PER_SAMPLE, FLOAT_BITS_PER_SAMPLE
 FMT_BLOCK_LENGTHS = {16, 18, 20, 40}
-MODES = 'r', 'r+', 'c'
+MODES = "r", "r+", "c"
 
 # Deal with a quirk in certain .WAV test files
 BAD_TAG_ADJUSTMENT = True
@@ -18,24 +21,24 @@ BAD_TAG_ADJUSTMENT = True
 class ReadMap(raw.RawMap):
     """Memory-map an existing WAVE file into a numpy vector or matrix"""
 
-    @docs.update(mode='READ_ONLY_MODE')
+    @docs.update(mode="READ_ONLY_MODE")
     def __new__(
-        cls: Type,
+        cls: type,
         filename: str,
-        mode: str = 'r',
-        order: Optional[str] = None,
+        mode: str = "r",
+        order: str | None = None,
         always_2d: bool = False,
-        warn: Optional[Callable] = raw.warn,
+        warn: Callable | None = raw.warn,
     ):
         # Documentation for parameters is in docs.py
         """Memory-map an existing WAVE file into a numpy matrix."""
 
         if mode not in MODES:
-            raise ValueError(f'Mode {mode} not in {MODES}')
+            raise ValueError(f"Mode {mode} not in {MODES}")
 
         file_size = raw.file_byte_size(filename)
 
-        with open(filename, 'rb') as fp:
+        with open(filename, "rb") as fp:
             begin, end, fmt = _metadata(fp, warn, file_size)
             offset = begin + wave.CHUNK.size
             roffset = file_size - end
@@ -47,23 +50,21 @@ class ReadMap(raw.RawMap):
             f.wFormatTag = g.wFormatTag
 
         if f.wFormatTag not in wave.WAVE_FORMATS:
-            raise ValueError(f'Do not understand f.wFormatTag={f.wFormatTag}')
+            raise ValueError(f"Do not understand f.wFormatTag={f.wFormatTag}")
 
         is_float = f.wFormatTag == wave.WAVE_FORMAT_IEEE_FLOAT
 
         if f.wBitsPerSample == 24:
-            raise ValueError('Reading 24-bit WAVEs is not quite supported')
+            raise ValueError("Reading 24-bit WAVEs is not quite supported")
 
         if f.wBitsPerSample not in BITS_PER_SAMPLE[is_float]:
-            raise ValueError(
-                f'Cannot mmap f.wBitsPerSample={f.wBitsPerSample}'
-            )
+            raise ValueError(f"Cannot mmap f.wBitsPerSample={f.wBitsPerSample}")
 
         if f.wBitsPerSample == 8:
-            dtype = 'uint8'
+            dtype = "uint8"
         else:
-            type_name = ('int', 'float')[is_float]
-            dtype = f'{type_name}{f.wBitsPerSample}'
+            type_name = ("int", "float")[is_float]
+            dtype = f"{type_name}{f.wBitsPerSample}"
 
         assert np.dtype(dtype).itemsize == f.wBitsPerSample // 8
         self = raw.RawMap.__new__(
@@ -85,35 +86,35 @@ class ReadMap(raw.RawMap):
 
 def _metadata(fp, warn, file_size):
     (tag, b, e), *chunks = _chunks(fp, warn, file_size)
-    if tag != b'WAVE':
-        raise ValueError(f'Not a WAVE file: {tag}')
+    if tag != b"WAVE":
+        raise ValueError(f"Not a WAVE file: {tag}")
 
     assert b == 0
     if e != file_size - 8:
-        warn(f'WAVE cksize is wrong: {e} != {file_size - 8}')
+        warn(f"WAVE cksize is wrong: {e} != {file_size - 8}")
 
     begin = end = fmt = None
     for tag, b, e in chunks:
-        if tag == b'fmt ':
+        if tag == b"fmt ":
             if not fmt:
                 fp.seek(b)
                 fmt = fp.read(e - b)
             else:
-                warn('fmt chunk after first ignored')
-        elif tag == b'data':
+                warn("fmt chunk after first ignored")
+        elif tag == b"data":
             if not (begin or end):
                 begin, end = b, e
             else:
-                warn('data chunk after first ignored')
+                warn("data chunk after first ignored")
 
     if begin is None:
-        raise ValueError('No data chunk found')
+        raise ValueError("No data chunk found")
 
     if fmt is None:
-        raise ValueError('No fmt chunk found')
+        raise ValueError("No fmt chunk found")
 
     if (len(fmt) - wave.CHUNK.size) not in FMT_BLOCK_LENGTHS:
-        warn(f'Weird fmt block length {len(fmt)}')
+        warn(f"Weird fmt block length {len(fmt)}")
 
     return begin, end, fmt
 
@@ -128,26 +129,26 @@ def _chunks(fp, warn, file_size):
         if len(s) < size:
             raise IncompleteChunk()
 
-        return struct.unpack('<' + format, s)[0]
+        return struct.unpack("<" + format, s)[0]
 
     def read_tag():
-        tag = read_one('4s')
+        tag = read_one("4s")
         if tag and not tag.rstrip().isalnum():
             if BAD_TAG_ADJUSTMENT and tag[0] == 0:
                 tag = tag[1:] + fp.read(1)
                 if tag.rstrip().isalnum():
                     return tag
 
-            warn(f'Dubious tag {tag}')
+            warn(f"Dubious tag {tag}")
 
         return tag
 
     def read_int():
-        return read_one('I')
+        return read_one("I")
 
     tag = read_tag()
-    if tag != b'RIFF':
-        raise ValueError('Not a RIFF file')
+    if tag != b"RIFF":
+        raise ValueError("Not a RIFF file")
 
     size = read_int()
     yield read_tag(), 0, size
@@ -158,19 +159,19 @@ def _chunks(fp, warn, file_size):
         try:
             tag = read_tag()
         except IncompleteChunk:
-            warn('Incomplete chunk: no tag')
+            warn("Incomplete chunk: no tag")
             break
 
         try:
             chunk_size = read_int()
         except IncompleteChunk:
-            warn('Incomplete chunk: no size')
+            warn("Incomplete chunk: no size")
             break
 
         fp.seek(chunk_size, 1)
         end = fp.tell()
         if end > file_size:
             if end > file_size + 1:
-                warn(f'Incomplete chunk: {end} > {file_size + 1}')
+                warn(f"Incomplete chunk: {end} > {file_size + 1}")
             end = file_size
         yield tag, begin, end

wavemap/structure/structure.py

@@ -1,9 +1,10 @@
 """Better struct"""
-from argparse import Namespace
+
 import struct
+from argparse import Namespace
 
-INT16 = 'H'
-INT32 = 'I'
+INT16 = "H"
+INT32 = "I"
 
 INT = INT16, INT32
 
@@ -11,7 +12,7 @@ INT = INT16, INT32
 class Structure:
     def __init__(self, **formats):
         self.formats = formats
-        self.struct = struct.Struct('<' + ''.join(formats.values()))
+        self.struct = struct.Struct("<" + "".join(formats.values()))
         self.size = self.struct.size
 
     def pack(self, **kwargs):
@@ -33,28 +34,26 @@ class Structure:
             try:
                 v = kw[name]
             except KeyError:
-                errors.append(f'Unknown param {name}')
+                errors.append(f"Unknown param {name}")
             else:
                 if fmt in INT and not isinstance(v, int):
-                    errors.append(f'Integer {name} had value {v!r}')
-                elif fmt.endswith('s') and not isinstance(v, bytes):
-                    errors.append(f'Bytes {name} had value {v!r}')
+                    errors.append(f"Integer {name} had value {v!r}")
+                elif fmt.endswith("s") and not isinstance(v, bytes):
+                    errors.append(f"Bytes {name} had value {v!r}")
                 else:
                     args.append(v)
 
         # We accept the unknown
         unknown = False and set(kw).difference(self.names)
         if unknown:
-            s = '' if len(unknown) == 1 else 's'
-            unknown = ', '.join(sorted(unknown))
-            errors.append(f'Unknown argument{s}: {unknown}')
+            s = "" if len(unknown) == 1 else "s"
+            unknown = ", ".join(sorted(unknown))
+            errors.append(f"Unknown argument{s}: {unknown}")
             raise ValueError(errors[-1])
 
-        msg = '. '.join(errors)
+        msg = ". ".join(errors)
         if msg:
             raise ValueError(msg)
 
-        assert len(args) == len(
-            self.formats
-        ), f'{len(args)} == {len(self.formats)}'
+        assert len(args) == len(self.formats), f"{len(args)} == {len(self.formats)}"
         return args

wavemap/structure/wave.py

@@ -1,4 +1,4 @@
-from .structure import Structure, INT16, INT32
+from .structure import INT16, INT32, Structure
 
 WAVE_FORMAT_PCM = 0x0001
 WAVE_FORMAT_IEEE_FLOAT = 0x0003
@@ -14,8 +14,8 @@ WAVE_FORMATS = (
     WAVE_FORMAT_EXTENSIBLE,
 )
 
-TAG = '4s'
-SUBFORMAT = '14s'
+TAG = "4s"
+SUBFORMAT = "14s"
 
 CHUNK = Structure(ckID=TAG, cksize=INT32)
 RIFF = Structure(ckIDRiff=TAG, cksizeRiff=INT32, WAVEID=TAG)
@@ -58,8 +58,8 @@ NON_PCM = RIFF + FMT_NON_PCM + FACT + DATA
 assert PCM.size == 44
 assert NON_PCM.size == 58
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     d = list(locals().items())
     for k, v in d:
         if isinstance(v, Structure):
-            print(f'assert {k}.size == {v.size}')
+            print(f"assert {k}.size == {v.size}")

wavemap/write.py

@@ -1,26 +1,28 @@
-from . import docs
-from . import raw
-from .structure import wave
-from .structure.wave import PCM, NON_PCM, FMT_PCM, FMT_NON_PCM
-from typing import Callable, Optional, Type, Union
+from typing import Optional, Type, Union
+from collections.abc import Callable
+
 import numpy as np
 
+from . import docs, raw
+from .structure import wave
+from .structure.wave import FMT_NON_PCM, FMT_PCM, NON_PCM, PCM
+
 CHUNK_HEADER = 8
 DEFAULT_SAMPLE_RATE = 44100
 
 
 class WriteMap(raw.RawMap):
-    """"Memory-map a new wave file into a new numpy vector or matrix"""
+    """ "Memory-map a new wave file into a new numpy vector or matrix"""
 
     @docs.update
     def __new__(
-        cls: Type,
+        cls: type,
         filename: str,
         dtype: np.dtype,
-        shape: Union[None, int, tuple],
+        shape: None | int | tuple,
         sample_rate: int,
         roffset: int = 0,
-        warn: Optional[Callable] = raw.warn,
+        warn: Callable | None = raw.warn,
     ):
         """
         Open a memory-mapped WAVE file in write mode and overwrite any existing
@@ -50,7 +52,7 @@ class WriteMap(raw.RawMap):
             cls,
             filename=filename,
             dtype=dtype,
-            mode='w+',
+            mode="w+",
             shape=shape,
             offset=structure.size,
             roffset=roffset + pad,
@@ -62,10 +64,10 @@ class WriteMap(raw.RawMap):
 
         structure.pack_into(
             self._mmap,
-            ckIDRiff=b'RIFF',
+            ckIDRiff=b"RIFF",
             cksizeRiff=self.file_size - CHUNK_HEADER,
-            WAVEID=b'WAVE',
-            ckIDFmt=b'fmt ',
+            WAVEID=b"WAVE",
+            ckIDFmt=b"fmt ",
             cksizeFmt=fmt_structure.size - CHUNK_HEADER,
             wFormatTag=wFormatTag,
             nChannels=channel_count,
@@ -74,10 +76,10 @@ class WriteMap(raw.RawMap):
             nBlockAlign=frame_bytes,
             wBitsPerSample=sample_bytes * 8,
             cbSize=0,  # Non PCM
-            ckIDFact=b'fact',
+            ckIDFact=b"fact",
             cksizeFact=4,
             dwSampleLength=channel_count * frame_count,
-            ckIDData=b'data',
+            ckIDData=b"data",
             cksizeData=total_frame_bytes,
         )
 
@@ -85,30 +87,30 @@ class WriteMap(raw.RawMap):
 
     @classmethod
     def new_like(
-        cls: Type,
+        cls: type,
         arr: np.ndarray,
         filename: str,
-        sample_rate: Optional[int] = None,
-        roffset: Optional[int] = None,
-        warn: Optional[Callable] = raw.warn,
+        sample_rate: int | None = None,
+        roffset: int | None = None,
+        warn: Callable | None = raw.warn,
     ):
         if sample_rate is None:
-            sample_rate = getattr(arr, 'sample_rate', DEFAULT_SAMPLE_RATE)
+            sample_rate = getattr(arr, "sample_rate", DEFAULT_SAMPLE_RATE)
 
         if roffset is None:
-            roffset = getattr(arr, 'roffset', 0)
+            roffset = getattr(arr, "roffset", 0)
 
         return cls(filename, arr.dtype, arr.shape, sample_rate, roffset, warn)
 
     @classmethod
     def copy_to(
-        cls: Type,
+        cls: type,
         arr: np.ndarray,
         filename: str,
-        sample_rate: Optional[int] = None,
-        roffset: Optional[int] = None,
-        warn: Optional[Callable] = raw.warn,
+        sample_rate: int | None = None,
+        roffset: int | None = None,
+        warn: Callable | None = raw.warn,
     ):
         wm = cls.new_like(arr, filename, sample_rate, roffset, warn)
-        np.copyto(src=arr, dst=wm, casting='no')
+        np.copyto(src=arr, dst=wm, casting="no")
         return wm

{wavemap-2.0.1.dist-info → wavemap-2.1.0.dist-info}/METADATA

@@ -1,25 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wavemap
-Version: 2.0.1
-Summary: Memory map WAVE or raw audio files
-Home-page: https://github.com/rec/wavemap
+Version: 2.1.0
+Summary: 🌊 Memory map WAVE or raw audio files 🌊
 Author: Tom Ritchford
-Author-email: tom@swirly.com
-License: MIT
-Keywords: testing,modules
-Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Utilities
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: xmod
+Author-email: Tom Ritchford <tom@swirly.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy>=1.24.1,<2
+Requires-Dist: xmod>=1.3.2,<2
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
 
 🌊 Memory map WAVE files into numpy arrays 🌊
 ----------------------------------------------
@@ -381,5 +376,3 @@ ARGUMENTS
     If true, ``arr`` is copied even if it is already the requested type
 
 (automatically generated by `doks <https://github.com/rec/doks/>`_ on 2021-02-23T14:37:02.652534)
-
-

wavemap-2.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+wavemap/.DS_Store,sha256=uGGhkWaTZaKSqiGr6XGHeFWLCFzn9KHjY8US4dk2k2E,6148
+wavemap/__init__.py,sha256=UpU6uAIKQVOJebgxCgr5FP5krAmTwhQeBNWQbxCnBMs,3171
+wavemap/convert.py,sha256=uqa3xz51Gd-6lfxj4l0ZJ4ITqTbNRk9-PUKlwaMdfUY,2853
+wavemap/docs.py,sha256=3-ulKnCbYzfHw12pS8u3JoHJArSTzx6tjx5g5ft4JTY,3532
+wavemap/memmap.py,sha256=8CT6Wwnn7lhDeUMBJ7e2dRdxAt4EH6Maa2e5Yu4wab0,11839
+wavemap/raw.py,sha256=QCOdPCf6PmTsZgmTltjwIjqGvSeWxCuLLWQb7deYZJc,3069
+wavemap/read.py,sha256=YvKACeT3EW7lwPeK2giXXILogGKhyKk-VNc7hx4cKp0,4883
+wavemap/structure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wavemap/structure/structure.py,sha256=V6WHT341WM9ghr9LWkuN5VBJcOa6N_00--y3malnHBQ,1844
+wavemap/structure/wave.py,sha256=-IvgbYdUjzDmP-j-X9aRQ9__-94IrTWJmr-Qp8xZ_OY,1462
+wavemap/write.py,sha256=wzQShFzAp6ON_DTyC1qn8YI8tplDzH9d-s4q6j3p9qQ,3347
+wavemap-2.1.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+wavemap-2.1.0.dist-info/METADATA,sha256=WJUW-Kj_Ry-ot9RriGD8WF-S6rS7mlnS9UBkxQWFJI0,11949
+wavemap-2.1.0.dist-info/RECORD,,

{wavemap-2.0.1.dist-info → wavemap-2.1.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: uv 0.9.28
 Root-Is-Purelib: true
 Tag: py3-none-any
-

wavemap-2.0.1.dist-info/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Tom Ritchford
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

wavemap-2.0.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-wavemap/__init__.py,sha256=B6Z-VKW6E9qdm6RPYhDrv28_AmYdqgZHqht1pOnRGoU,3177
-wavemap/convert.py,sha256=_UMqZHoZxye2currVAJI9dnZ_pBgYMxnpgqSj_F8Av0,2796
-wavemap/docs.py,sha256=nS3xRn8CXaxFf-cBromvzYlqWDzO0dSbnPfZ5q2IkY4,3532
-wavemap/memmap.py,sha256=IYPZOZIkXBuxKbOQiHWzBt4u05Le7tvdeUHjjHHpL40,11893
-wavemap/raw.py,sha256=TbIOLA0sJ1pEiKECK9lvQo8yZCQ1tuMqb24sCehrL4U,3050
-wavemap/read.py,sha256=I5aVUHUF2cdWTNlD3eRK4OxPRMq5x-E4BOd06pFbH-A,4890
-wavemap/write.py,sha256=-6IJsf6feiux0QlZl97Jat61JN5hB5Y-ghpwzVTbKLE,3356
-wavemap/structure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wavemap/structure/structure.py,sha256=gzQN-rCV_tsjV-LxOOdbGFlhuun6tixTgTbpcUL1weU,1865
-wavemap/structure/wave.py,sha256=uawYz0olhIzn4HSQu3l7gAAh_gxgPKqKS2zu2nKyq1s,1462
-wavemap-2.0.1.dist-info/LICENSE,sha256=2H3TTsBJEVDu73RHBbYDXTPRFsypRLOplkjh_AwfOi8,1070
-wavemap-2.0.1.dist-info/METADATA,sha256=-LpuSwdamJCvTEjuhQer1SBe3T9QZT9mcQLD73QTehk,12061
-wavemap-2.0.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-wavemap-2.0.1.dist-info/top_level.txt,sha256=c-q4GFil8vegM_d7zFxRbPqt-wCNCz-6RuVchjFPFL0,8
-wavemap-2.0.1.dist-info/RECORD,,

wavemap-2.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-wavemap