sonarch 0.1.0.dev0__py3-none-any.whl

sonarch/__init__.py

@@ -0,0 +1,45 @@
+"""sonarch: the one import you need for audio work.
+
+>>> import sonarch as sa
+>>> audio = sa.load("clip.flac")
+>>> audio.sample_rate, audio.channels, audio.duration
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from sonarch.core import (
+    Audio,
+    AudioValidationError,
+    ChannelMismatchError,
+    ClippingError,
+    DecodeError,
+    EncodeError,
+    LengthMismatchError,
+    SampleRateMismatchError,
+    SonarchError,
+    mix,
+)
+from sonarch.io import AudioInfo, info, load, save
+
+try:
+    __version__ = version("sonarch")
+except PackageNotFoundError:  # running from a source tree without installing
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    "Audio",
+    "AudioInfo",
+    "AudioValidationError",
+    "ChannelMismatchError",
+    "ClippingError",
+    "DecodeError",
+    "EncodeError",
+    "LengthMismatchError",
+    "SampleRateMismatchError",
+    "SonarchError",
+    "__version__",
+    "info",
+    "load",
+    "mix",
+    "save",
+]

sonarch/core/__init__.py

@@ -0,0 +1,26 @@
+"""Core types: the Audio object and the error hierarchy."""
+
+from sonarch.core.audio import Audio, mix
+from sonarch.core.errors import (
+    AudioValidationError,
+    ChannelMismatchError,
+    ClippingError,
+    DecodeError,
+    EncodeError,
+    LengthMismatchError,
+    SampleRateMismatchError,
+    SonarchError,
+)
+
+__all__ = [
+    "Audio",
+    "AudioValidationError",
+    "ChannelMismatchError",
+    "ClippingError",
+    "DecodeError",
+    "EncodeError",
+    "LengthMismatchError",
+    "SampleRateMismatchError",
+    "SonarchError",
+    "mix",
+]

sonarch/core/audio.py

@@ -0,0 +1,288 @@
+"""The :class:`Audio` object: a waveform that carries its own metadata."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Literal
+
+import numpy as np
+import torch
+
+from sonarch.core.errors import (
+    AudioValidationError,
+    ChannelMismatchError,
+    LengthMismatchError,
+    SampleRateMismatchError,
+)
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+__all__ = ["Audio", "mix"]
+
+_FLOAT_DTYPES = (torch.float16, torch.bfloat16, torch.float32, torch.float64)
+
+
+def _as_tensor(data: torch.Tensor | NDArray[Any]) -> torch.Tensor:
+    """Convert input to a float tensor of shape (channels, samples), or raise."""
+    if isinstance(data, np.ndarray):
+        if not np.issubdtype(data.dtype, np.floating):
+            raise AudioValidationError(
+                f"audio data must be floating point in [-1, 1], got dtype {data.dtype}. "
+                "Convert integer PCM first, e.g. `data.astype(np.float32) / 32768` for int16."
+            )
+        tensor = torch.from_numpy(np.ascontiguousarray(data))
+    elif isinstance(data, torch.Tensor):
+        tensor = data
+        if tensor.dtype not in _FLOAT_DTYPES:
+            raise AudioValidationError(
+                f"audio data must be floating point in [-1, 1], got dtype {tensor.dtype}. "
+                "Convert integer PCM first, e.g. `x.float() / 32768` for int16."
+            )
+    else:
+        raise AudioValidationError(
+            f"audio data must be a torch.Tensor or numpy.ndarray, got {type(data).__name__}"
+        )
+
+    if tensor.ndim == 1:
+        tensor = tensor.unsqueeze(0)
+    elif tensor.ndim != 2:
+        raise AudioValidationError(
+            f"audio data must have shape (samples,) or (channels, samples), "
+            f"got {tuple(tensor.shape)}"
+        )
+
+    channels, samples = tensor.shape
+    if channels == 0:
+        raise AudioValidationError("audio must have at least one channel")
+    if samples > 0 and channels > samples:
+        raise AudioValidationError(
+            f"got shape {tuple(tensor.shape)}, which looks like (samples, channels). "
+            "sonarch uses (channels, samples): pass `data.T` instead."
+        )
+    return tensor
+
+
+def _check_sample_rate(sample_rate: object) -> int:
+    if isinstance(sample_rate, bool) or not isinstance(sample_rate, (int, np.integer)):
+        raise AudioValidationError(
+            f"sample_rate must be an integer number of Hz, got {sample_rate!r}"
+        )
+    rate = int(sample_rate)
+    if rate <= 0:
+        raise AudioValidationError(f"sample_rate must be positive, got {rate}")
+    return rate
+
+
+class Audio:
+    """A waveform plus the metadata needed to use it correctly.
+
+    The waveform is always a floating-point tensor of shape
+    ``(channels, samples)`` with values nominally in ``[-1, 1]``. Operations
+    that combine audio check sample rate, channels and length, and raise
+    instead of silently producing wrong results.
+
+    Args:
+        data: Waveform as a ``torch.Tensor`` or ``numpy.ndarray``, shape
+            ``(samples,)`` or ``(channels, samples)``. NumPy input is wrapped
+            without copying when possible.
+        sample_rate: Sample rate in Hz.
+
+    Example:
+        >>> audio = Audio(torch.zeros(2, 16_000), sample_rate=16_000)
+        >>> audio.duration
+        1.0
+    """
+
+    __slots__ = ("_sample_rate", "_tensor")
+
+    def __init__(self, data: torch.Tensor | NDArray[Any], sample_rate: int) -> None:
+        self._tensor = _as_tensor(data)
+        self._sample_rate = _check_sample_rate(sample_rate)
+
+    # ------------------------------------------------------------------ metadata
+
+    @property
+    def tensor(self) -> torch.Tensor:
+        """The waveform, shape ``(channels, samples)``."""
+        return self._tensor
+
+    @property
+    def sample_rate(self) -> int:
+        """Sample rate in Hz."""
+        return self._sample_rate
+
+    @property
+    def channels(self) -> int:
+        """Number of channels."""
+        return int(self._tensor.shape[0])
+
+    @property
+    def num_samples(self) -> int:
+        """Number of samples per channel."""
+        return int(self._tensor.shape[1])
+
+    @property
+    def duration(self) -> float:
+        """Duration in seconds."""
+        return self.num_samples / self._sample_rate
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        """Shape of the waveform, ``(channels, samples)``."""
+        return (self.channels, self.num_samples)
+
+    @property
+    def device(self) -> torch.device:
+        """Device the waveform lives on."""
+        return self._tensor.device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """Floating-point dtype of the waveform."""
+        return self._tensor.dtype
+
+    # --------------------------------------------------------------- conversion
+
+    def replace(
+        self,
+        *,
+        tensor: torch.Tensor | NDArray[Any] | None = None,
+        sample_rate: int | None = None,
+    ) -> Audio:
+        """Return a new ``Audio`` with some fields replaced.
+
+        Only use ``sample_rate=`` when relabelling audio whose rate was wrong;
+        to change the rate of real audio, resample it.
+        """
+        return Audio(
+            self._tensor if tensor is None else tensor,
+            self._sample_rate if sample_rate is None else sample_rate,
+        )
+
+    def to(
+        self,
+        device: str | torch.device | None = None,
+        dtype: torch.dtype | None = None,
+    ) -> Audio:
+        """Move to a device and/or cast to another floating-point dtype."""
+        if dtype is not None and dtype not in _FLOAT_DTYPES:
+            raise AudioValidationError(f"dtype must be a floating-point dtype, got {dtype}")
+        return self.replace(tensor=self._tensor.to(device=device, dtype=dtype))
+
+    def cpu(self) -> Audio:
+        """Shortcut for ``audio.to("cpu")``."""
+        return self.to("cpu")
+
+    def numpy(self) -> NDArray[Any]:
+        """Return the waveform as a NumPy array of shape ``(channels, samples)``.
+
+        bfloat16 audio is returned as float32, since NumPy has no bfloat16.
+        """
+        tensor = self._tensor.detach().cpu()
+        if tensor.dtype == torch.bfloat16:
+            tensor = tensor.float()
+        return tensor.numpy()
+
+    def to_mono(self) -> Audio:
+        """Average all channels into one. Mono audio is returned unchanged."""
+        if self.channels == 1:
+            return self
+        return self.replace(tensor=self._tensor.mean(dim=0, keepdim=True))
+
+    def to_stereo(self) -> Audio:
+        """Duplicate mono audio into two channels. Stereo audio is returned unchanged."""
+        if self.channels == 2:
+            return self
+        if self.channels != 1:
+            raise ChannelMismatchError(
+                1, self.channels, hint="to_stereo() only converts mono audio; downmix first"
+            )
+        return self.replace(tensor=self._tensor.expand(2, -1).clone())
+
+    def save(self, path: str | os.PathLike[str], **kwargs: Any) -> None:
+        """Write to a file. See :func:`sonarch.save` for options."""
+        from sonarch.io import save
+
+        save(self, path, **kwargs)
+
+    # ------------------------------------------------------------------ dunders
+
+    def __len__(self) -> int:
+        return self.num_samples
+
+    def __repr__(self) -> str:
+        device = "" if self.device.type == "cpu" else f", device={self.device}"
+        return (
+            f"Audio(channels={self.channels}, sample_rate={self._sample_rate}, "
+            f"duration={self.duration:.3f}s, dtype={str(self.dtype).removeprefix('torch.')}"
+            f"{device})"
+        )
+
+    def __add__(self, other: object) -> Audio:
+        if not isinstance(other, Audio):
+            return NotImplemented
+        _check_compatible(self, other, check_length=True)
+        return self.replace(tensor=self._tensor + other._tensor)
+
+    __hash__ = None  # type: ignore[assignment]  # mutable tensor inside: not hashable
+
+
+def _check_compatible(a: Audio, b: Audio, *, check_length: bool) -> None:
+    if a.sample_rate != b.sample_rate:
+        raise SampleRateMismatchError(
+            a.sample_rate, b.sample_rate, hint="Resample one clip to match the other"
+        )
+    if a.channels != b.channels:
+        raise ChannelMismatchError(
+            a.channels, b.channels, hint="Use to_mono() or to_stereo() to match channels"
+        )
+    if check_length and a.num_samples != b.num_samples:
+        raise LengthMismatchError(
+            a.num_samples,
+            b.num_samples,
+            hint="Use sa.mix(..., align='pad') or align='crop' to combine clips of "
+            "different lengths",
+        )
+
+
+def mix(
+    *clips: Audio,
+    align: Literal["error", "pad", "crop"] = "error",
+    weights: list[float] | None = None,
+) -> Audio:
+    """Sum several clips into one.
+
+    All clips must share sample rate, channel count and device.
+
+    Args:
+        *clips: Two or more ``Audio`` objects.
+        align: What to do when lengths differ. ``"error"`` (default) raises,
+            ``"pad"`` zero-pads shorter clips to the longest, ``"crop"`` cuts
+            every clip to the shortest.
+        weights: Optional gain for each clip, e.g. ``[1.0, 0.3]``.
+
+    Note:
+        The result is a plain sum, so it can exceed ``[-1, 1]``. Normalize
+        afterwards if needed.
+    """
+    if len(clips) < 2:
+        raise ValueError(f"mix() needs at least two clips, got {len(clips)}")
+    if align not in ("error", "pad", "crop"):
+        raise ValueError(f"align must be 'error', 'pad' or 'crop', got {align!r}")
+    if weights is not None and len(weights) != len(clips):
+        raise ValueError(f"got {len(weights)} weights for {len(clips)} clips")
+
+    first = clips[0]
+    for clip in clips[1:]:
+        _check_compatible(first, clip, check_length=align == "error")
+
+    lengths = [clip.num_samples for clip in clips]
+    target = max(lengths) if align == "pad" else min(lengths)
+    gains = weights if weights is not None else [1.0] * len(clips)
+
+    out = torch.zeros((first.channels, target), dtype=first.dtype, device=first.device)
+    for clip, gain in zip(clips, gains, strict=True):
+        n = min(clip.num_samples, target)
+        out[:, :n] += gain * clip.tensor[:, :n]
+    return first.replace(tensor=out)

sonarch/core/errors.py

@@ -0,0 +1,76 @@
+"""Exception hierarchy for sonarch.
+
+Every error sonarch raises on purpose derives from :class:`SonarchError`, so
+callers can catch everything from this library with a single ``except``.
+Validation errors also derive from :class:`ValueError` so generic handlers
+keep working.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "AudioValidationError",
+    "ChannelMismatchError",
+    "ClippingError",
+    "DecodeError",
+    "EncodeError",
+    "LengthMismatchError",
+    "SampleRateMismatchError",
+    "SonarchError",
+]
+
+
+class SonarchError(Exception):
+    """Base class for all errors raised by sonarch."""
+
+
+class AudioValidationError(SonarchError, ValueError):
+    """Audio data or metadata is invalid (bad shape, dtype, sample rate...)."""
+
+
+class SampleRateMismatchError(AudioValidationError):
+    """Two pieces of audio, or audio and a consumer, disagree on sample rate."""
+
+    def __init__(self, expected: int, got: int, hint: str | None = None) -> None:
+        self.expected = expected
+        self.got = got
+        message = f"sample rate mismatch: expected {expected} Hz, got {got} Hz"
+        if hint:
+            message = f"{message}. {hint}"
+        super().__init__(message)
+
+
+class ChannelMismatchError(AudioValidationError):
+    """Two pieces of audio disagree on channel count."""
+
+    def __init__(self, expected: int, got: int, hint: str | None = None) -> None:
+        self.expected = expected
+        self.got = got
+        message = f"channel mismatch: expected {expected} channel(s), got {got}"
+        if hint:
+            message = f"{message}. {hint}"
+        super().__init__(message)
+
+
+class LengthMismatchError(AudioValidationError):
+    """Two pieces of audio disagree on length (in samples)."""
+
+    def __init__(self, expected: int, got: int, hint: str | None = None) -> None:
+        self.expected = expected
+        self.got = got
+        message = f"length mismatch: expected {expected} samples, got {got}"
+        if hint:
+            message = f"{message}. {hint}"
+        super().__init__(message)
+
+
+class ClippingError(AudioValidationError):
+    """Audio exceeds [-1, 1] and would be clipped by an integer encoding."""
+
+
+class DecodeError(SonarchError):
+    """A file or stream could not be decoded as audio."""
+
+
+class EncodeError(SonarchError):
+    """Audio could not be encoded or written."""

sonarch/io/__init__.py

@@ -0,0 +1,7 @@
+"""Loading, saving and probing audio files."""
+
+from sonarch.io.info import AudioInfo, info
+from sonarch.io.load import load
+from sonarch.io.save import save
+
+__all__ = ["AudioInfo", "info", "load", "save"]

sonarch/io/_source.py

@@ -0,0 +1,53 @@
+"""Opening audio sources with PyAV, with sonarch's error handling."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import IO, Any, Union, cast
+
+import av
+import av.container
+
+from sonarch.core.errors import DecodeError
+
+Source = Union[str, "os.PathLike[str]", IO[bytes]]
+
+
+def describe(source: Source) -> str:
+    if isinstance(source, (str, os.PathLike)):
+        return os.fspath(source)
+    return getattr(source, "name", None) or type(source).__name__
+
+
+def _is_url(path: str) -> bool:
+    return "://" in path
+
+
+def open_input(source: Source) -> av.container.InputContainer:
+    """Open a path, URL or binary file object for reading.
+
+    Raises:
+        FileNotFoundError: A local path does not exist.
+        DecodeError: FFmpeg cannot open or understand the input.
+    """
+    target: Any
+    if isinstance(source, (str, os.PathLike)):
+        target = os.fspath(source)
+        if not _is_url(target) and not Path(target).exists():
+            raise FileNotFoundError(f"no such file: {target!r}")
+    else:
+        target = source
+
+    try:
+        return cast(av.container.InputContainer, av.open(target, mode="r"))
+    except av.error.FFmpegError as exc:
+        raise DecodeError(f"could not open {describe(source)!r} as audio: {exc}") from exc
+
+
+def first_audio_stream(
+    container: av.container.InputContainer, source: Source
+) -> av.audio.stream.AudioStream:
+    if not container.streams.audio:
+        raise DecodeError(f"{describe(source)!r} has no audio stream")
+    return container.streams.audio[0]

sonarch/io/info.py

@@ -0,0 +1,68 @@
+"""Fast metadata probing without decoding."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import av
+
+from sonarch.io._source import Source, first_audio_stream, open_input
+
+__all__ = ["AudioInfo", "info"]
+
+
+@dataclass(frozen=True)
+class AudioInfo:
+    """Metadata about an audio file, read from its headers.
+
+    Attributes:
+        sample_rate: Sample rate in Hz.
+        channels: Number of channels.
+        duration: Duration in seconds, or ``None`` if the container does not
+            say. For compressed formats (MP3, AAC...) this is an estimate from
+            the headers and can differ slightly from the decoded length.
+        num_samples: ``duration * sample_rate`` rounded, or ``None``.
+        codec: Codec name, e.g. ``"pcm_s16le"``, ``"flac"``, ``"mp3"``.
+        format: Container format, e.g. ``"wav"``, ``"flac"``, ``"mp3"``.
+        bit_rate: Bit rate in bits/s, or ``None`` if unknown.
+    """
+
+    sample_rate: int
+    channels: int
+    duration: float | None
+    num_samples: int | None
+    codec: str
+    format: str
+    bit_rate: int | None
+
+
+def info(source: Source) -> AudioInfo:
+    """Read metadata from an audio file without decoding it.
+
+    Args:
+        source: Local path, URL, or binary file object.
+
+    Example:
+        >>> sa.info("clip.flac")
+        AudioInfo(sample_rate=44100, channels=2, duration=12.4, ...)
+    """
+    with open_input(source) as container:
+        stream = first_audio_stream(container, source)
+        codec = stream.codec_context
+        sample_rate = int(codec.sample_rate)
+
+        duration: float | None = None
+        if stream.duration is not None and stream.time_base is not None:
+            duration = float(stream.duration * stream.time_base)
+        elif container.duration is not None:
+            duration = container.duration / av.time_base
+
+        return AudioInfo(
+            sample_rate=sample_rate,
+            channels=int(codec.channels),
+            duration=duration,
+            num_samples=None if duration is None else round(duration * sample_rate),
+            codec=codec.name,
+            format=container.format.name.split(",")[0],
+            bit_rate=(codec.bit_rate or container.bit_rate) or None,
+        )

sonarch/io/load.py

@@ -0,0 +1,161 @@
+"""Decoding audio files into :class:`~sonarch.Audio` objects."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING, Any
+
+import av
+import numpy as np
+import torch
+
+from sonarch.core.audio import Audio
+from sonarch.core.errors import DecodeError
+from sonarch.io._source import Source, describe, first_audio_stream, open_input
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+__all__ = ["load"]
+
+
+def load(
+    source: Source,
+    *,
+    offset: float = 0.0,
+    duration: float | None = None,
+) -> Audio:
+    """Decode an audio file into an :class:`~sonarch.Audio` object.
+
+    Audio keeps its original sample rate and channels; nothing is converted
+    behind your back. Use ``.resample()`` / ``.to_mono()`` explicitly.
+
+    Args:
+        source: Local path, URL (``http(s)://``...), or binary file object.
+            Any format FFmpeg can decode works, including the audio track of
+            video files.
+        offset: Start reading this many seconds into the file.
+        duration: Read at most this many seconds. ``None`` reads to the end.
+
+    Returns:
+        Float32 ``Audio`` with shape ``(channels, samples)``.
+
+    Raises:
+        FileNotFoundError: A local path does not exist.
+        DecodeError: The input is not decodable audio.
+        ValueError: ``offset`` / ``duration`` are invalid, or ``offset`` is
+            past the end of the file.
+
+    Example:
+        >>> audio = sa.load("speech.mp3", offset=1.5, duration=3.0)
+    """
+    if not math.isfinite(offset) or offset < 0:
+        raise ValueError(f"offset must be a finite number >= 0, got {offset}")
+    if duration is not None and (not math.isfinite(duration) or duration <= 0):
+        raise ValueError(f"duration must be a finite number > 0 or None, got {duration}")
+
+    with open_input(source) as container:
+        stream = first_audio_stream(container, source)
+        sample_rate = int(stream.codec_context.sample_rate)
+        if sample_rate <= 0:
+            raise DecodeError(f"{describe(source)!r} reports an invalid sample rate")
+
+        start = round(offset * sample_rate)
+        stop = None if duration is None else start + round(duration * sample_rate)
+        # Lossy decoders (MP3, AAC, Opus...) produce wrong samples for a short
+        # while after a seek, so seek earlier and discard the warm-up audio.
+        preroll = 0 if _is_lossless(stream.codec_context.name) else sample_rate // 2
+        seek_to = max(start - preroll, 0)
+
+        try:
+            first, data = _decode(container, stream, sample_rate, seek_to, stop)
+        except av.error.FFmpegError as exc:
+            raise DecodeError(f"failed to decode {describe(source)!r}: {exc}") from exc
+
+    lo = max(start - first, 0)
+    hi = data.shape[1] if stop is None else max(stop - first, 0)
+    if start > 0 and lo >= data.shape[1]:
+        total = (first + data.shape[1]) / sample_rate
+        raise ValueError(
+            f"offset {offset}s is past the end of {describe(source)!r} ({total:.3f}s long)"
+        )
+    return Audio(torch.from_numpy(np.ascontiguousarray(data[:, lo:hi])), sample_rate)
+
+
+_LOSSLESS_CODECS = frozenset({"flac", "alac", "wavpack", "tta", "ape", "mlp", "truehd"})
+
+
+def _is_lossless(codec_name: str) -> bool:
+    return codec_name.startswith("pcm_") or codec_name in _LOSSLESS_CODECS
+
+
+def _decode(
+    container: av.container.InputContainer,
+    stream: av.audio.stream.AudioStream,
+    sample_rate: int,
+    start: int,
+    stop: int | None,
+) -> tuple[int, NDArray[Any]]:
+    """Decode samples covering ``[start, stop)``.
+
+    Returns the index of the first decoded sample and a float32 array of shape
+    ``(channels, n)`` that begins at that index.
+    """
+    seeked = start > 0 and _seek(container, stream, start / sample_rate)
+    resampler = av.AudioResampler(format="fltp")  # keep rate & layout, convert to float32
+    stream_start = stream.start_time or 0
+
+    chunks: list[NDArray[Any]] = []
+    first: int | None = None
+    position = 0
+    for frame in container.decode(stream):
+        if first is None:
+            if seeked and frame.pts is None:
+                # Can't tell where the seek landed; restart from the beginning.
+                return _decode_from_start(container, stream, sample_rate, start, stop)
+            first = (
+                round(float((frame.pts - stream_start) * frame.time_base) * sample_rate)
+                if seeked and frame.pts is not None
+                else 0
+            )
+            first = max(first, 0)
+            position = first
+        for out in resampler.resample(frame):
+            chunks.append(out.to_ndarray())
+        position += frame.samples
+        if stop is not None and position >= stop:
+            break
+    for out in resampler.resample(None):
+        chunks.append(out.to_ndarray())
+
+    channels = stream.codec_context.channels or 1
+    if not chunks:
+        return (first or 0), np.zeros((channels, 0), dtype=np.float32)
+    return (first or 0), np.concatenate(chunks, axis=1)
+
+
+def _decode_from_start(
+    container: av.container.InputContainer,
+    stream: av.audio.stream.AudioStream,
+    sample_rate: int,
+    start: int,
+    stop: int | None,
+) -> tuple[int, NDArray[Any]]:
+    container.seek(0, stream=stream)
+    return _decode(container, stream, sample_rate, 0, stop)
+
+
+def _seek(
+    container: av.container.InputContainer,
+    stream: av.audio.stream.AudioStream,
+    seconds: float,
+) -> bool:
+    """Seek to (at or before) ``seconds``. Returns False if the input can't seek."""
+    if stream.time_base is None:
+        return False
+    target = int(seconds / stream.time_base) + (stream.start_time or 0)
+    try:
+        container.seek(target, stream=stream, backward=True, any_frame=False)
+    except av.error.FFmpegError:
+        return False  # nothing decoded yet, so we're still at the start
+    return True

sonarch/io/save.py

@@ -0,0 +1,168 @@
+"""Encoding :class:`~sonarch.Audio` objects to files."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Literal
+
+import av
+import numpy as np
+import torch
+
+from sonarch.core.audio import Audio
+from sonarch.core.errors import AudioValidationError, ClippingError, EncodeError
+
+__all__ = ["save"]
+
+Encoding = Literal["pcm16", "pcm24", "pcm32", "float32"]
+
+# container format, {encoding: (codec, sample_fmt)}
+_WAV = {
+    "pcm16": ("pcm_s16le", "s16"),
+    "pcm24": ("pcm_s24le", "s32"),
+    "pcm32": ("pcm_s32le", "s32"),
+    "float32": ("pcm_f32le", "flt"),
+}
+_FLAC = {
+    "pcm16": ("flac", "s16"),
+    "pcm24": ("flac", "s32"),
+}
+_OPUS_RATES = (8_000, 12_000, 16_000, 24_000, 48_000)
+
+
+def save(
+    audio: Audio,
+    path: str | os.PathLike[str],
+    *,
+    format: Literal["wav", "flac", "opus"] | None = None,
+    encoding: Encoding | None = None,
+    bitrate: str | int | None = None,
+    clip: bool = False,
+) -> None:
+    """Write audio to a file.
+
+    Args:
+        audio: The audio to write.
+        path: Destination path. The format is inferred from the extension
+            (``.wav``, ``.flac``, ``.opus``) unless ``format`` is given.
+        format: ``"wav"``, ``"flac"`` or ``"opus"``.
+        encoding: Sample encoding for WAV (``"pcm16"`` default, ``"pcm24"``,
+            ``"pcm32"``, ``"float32"``) or FLAC (``"pcm16"`` default,
+            ``"pcm24"``). Not used for Opus.
+        bitrate: Opus bitrate, e.g. ``"64kbps"`` or ``64000``. Default 64 kbps.
+        clip: Integer encodings and Opus can't store values outside
+            ``[-1, 1]``. By default sonarch raises :class:`ClippingError`
+            instead of silently clipping; pass ``clip=True`` to allow it.
+
+    Raises:
+        ClippingError: Audio exceeds ``[-1, 1]`` and ``clip`` is False.
+        SampleRateMismatchError: Opus was requested at an unsupported rate.
+        EncodeError: FFmpeg failed to write the file.
+    """
+    if not isinstance(audio, Audio):
+        raise TypeError(f"save() expects an Audio object, got {type(audio).__name__}")
+
+    path = Path(path)
+    fmt = format or _format_from_suffix(path)
+    codec_name, sample_fmt, options = _codec_for(fmt, encoding, bitrate, audio.sample_rate)
+
+    data = audio.tensor.detach().to(device="cpu", dtype=torch.float32)
+    if not torch.isfinite(data).all():
+        raise AudioValidationError("audio contains NaN or infinite values; refusing to write")
+    peak = float(data.abs().max()) if data.numel() else 0.0
+    if peak > 1.0 and not (fmt == "wav" and encoding == "float32"):
+        if not clip:
+            raise ClippingError(
+                f"audio peak is {peak:.3f}, outside [-1, 1]; {fmt} "
+                f"({encoding or 'default encoding'}) would clip it. Normalize first, "
+                "save with encoding='float32' (WAV), or pass clip=True to clip on purpose."
+            )
+        data = data.clamp(-1.0, 1.0)
+
+    layout = {1: "mono", 2: "stereo"}.get(audio.channels, f"{audio.channels}c")
+    array = np.ascontiguousarray(data.numpy())
+
+    try:
+        with av.open(str(path), mode="w", format=_CONTAINERS[fmt]) as container:
+            stream = container.add_stream(
+                codec_name, rate=audio.sample_rate, options=options, layout=layout
+            )
+            stream.format = sample_fmt
+            container.start_encoding()  # write the header even if there are no samples
+
+            if array.shape[1] > 0:
+                frame = av.AudioFrame.from_ndarray(array, format="fltp", layout=layout)
+                frame.sample_rate = audio.sample_rate
+                frame.pts = 0
+                for packet in stream.encode(frame):
+                    container.mux(packet)
+            for packet in stream.encode(None):
+                container.mux(packet)
+    except av.error.FFmpegError as exc:
+        raise EncodeError(f"failed to write {str(path)!r}: {exc}") from exc
+
+
+_CONTAINERS = {"wav": "wav", "flac": "flac", "opus": "ogg"}
+
+
+def _format_from_suffix(path: Path) -> Literal["wav", "flac", "opus"]:
+    suffix = path.suffix.lower()
+    if suffix in (".wav", ".wave"):
+        return "wav"
+    if suffix == ".flac":
+        return "flac"
+    if suffix in (".opus", ".ogg"):
+        return "opus"
+    raise ValueError(
+        f"can't infer the format from {path.name!r}; use a .wav, .flac or .opus "
+        "extension or pass format=..."
+    )
+
+
+def _codec_for(
+    fmt: str,
+    encoding: Encoding | None,
+    bitrate: str | int | None,
+    sample_rate: int,
+) -> tuple[str, str, dict[str, str]]:
+    if fmt == "opus":
+        if encoding is not None:
+            raise ValueError("encoding= is not used for Opus; set bitrate= instead")
+        if sample_rate not in _OPUS_RATES:
+            from sonarch.core.errors import SampleRateMismatchError
+
+            raise SampleRateMismatchError(
+                48_000,
+                sample_rate,
+                hint=f"Opus supports {', '.join(map(str, _OPUS_RATES))} Hz; resample first",
+            )
+        return "libopus", "flt", {"b": str(_parse_bitrate(bitrate))}
+
+    if bitrate is not None:
+        raise ValueError(f"bitrate= only applies to Opus, not {fmt}")
+    table = {"wav": _WAV, "flac": _FLAC}.get(fmt)
+    if table is None:
+        raise ValueError(f"unsupported format {fmt!r}; choose 'wav', 'flac' or 'opus'")
+    key = encoding or "pcm16"
+    if key not in table:
+        raise ValueError(f"{fmt} supports encodings {sorted(table)}, got {key!r}")
+    codec_name, sample_fmt = table[key]
+    return codec_name, sample_fmt, {}
+
+
+def _parse_bitrate(bitrate: str | int | None) -> int:
+    if bitrate is None:
+        return 64_000
+    if isinstance(bitrate, int):
+        value = bitrate
+    else:
+        match = re.fullmatch(r"\s*(\d+(?:\.\d+)?)\s*(k|kbps|kb/s|bps)?\s*", bitrate.lower())
+        if not match:
+            raise ValueError(f"can't parse bitrate {bitrate!r}; use e.g. '64kbps' or 64000")
+        number, unit = float(match.group(1)), match.group(2)
+        value = int(number * 1000) if unit in ("k", "kbps", "kb/s") else int(number)
+    if not 6_000 <= value <= 510_000:
+        raise ValueError(f"Opus bitrate must be between 6 and 510 kbps, got {value} bps")
+    return value

sonarch-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,368 @@
+Metadata-Version: 2.5
+Name: sonarch
+Version: 0.1.0.dev0
+Summary: The one import you need for audio work: loading, preprocessing, features, codecs and datasets, ready for ML.
+Project-URL: Homepage, https://github.com/trivedi-aman/sonarch
+Project-URL: Issues, https://github.com/trivedi-aman/sonarch/issues
+Author: Aman Trivedi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: audio,codec,machine-learning,preprocessing,pytorch,spectrogram
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: av>=12.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: torch>=2.1
+Provides-Extra: dev
+Requires-Dist: librosa>=0.10; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: soundfile>=0.12; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sonarch
+
+**The one import you need for audio work: loading, preprocessing, features, codecs and datasets, ready for ML.**
+
+```python
+import sonarch as sa
+
+audio = sa.load("anything.mp3")              # any format, any source; no system FFmpeg needed
+audio = audio.resample(16_000).to_mono()
+mel   = sa.MelSpectrogram(n_mels=80)(audio)  # CPU or GPU, matches librosa within tolerance
+```
+
+> ⚠️ **Status: early development.** This README describes the design target. Every feature section is tagged:
+> ✅ available · 🚧 in progress · 📋 planned. See the [Roadmap](#roadmap).
+
+---
+
+## Why sonarch?
+
+Working with audio today means juggling several libraries:
+
+- `librosa` for features (CPU-only, slow at scale)
+- `torchaudio` for loading and transforms (loading is being deprecated in favour of `torchcodec`)
+- `audiomentations` / `torch-audiomentations` for augmentation
+- `ffmpeg` / `sox` for format conversion
+- A separate repo for every neural codec (EnCodec, DAC, Mimi, SNAC…)
+
+The glue code between them is where bugs live: **silent sample-rate mismatches**, **preprocessing that differs between training and inference**, and **data pipelines stuck on the CPU**.
+
+sonarch gives you **one consistent API** for all of it. Where a great tool already exists, sonarch wraps it behind that API instead of reinventing it, so you get one `Audio` object, one style and one install.
+
+| Problem | sonarch's answer |
+|---|---|
+| "Which library do I even use to load audio now?" | `sa.load()`: every common format, local or remote, with bundled decoders |
+| Sample-rate / channel mismatch bugs | `Audio` objects carry their own metadata and check it at every step |
+| Train/inference preprocessing drift | Pipelines save to YAML, so you ship the exact same steps with your model |
+| Slow CPU preprocessing | Core ops run on CPU, CUDA or MPS, on single clips or batches |
+| Fragmented neural codecs | One `Codec` interface over EnCodec, DAC, Mimi, SNAC |
+| Huge raw datasets | Pack audio into compressed (FLAC / Opus) shards and stream them |
+| "How much did compression hurt?" | Quality metrics: PESQ, STOI, SI-SDR, mel distance |
+
+---
+
+## Design principles
+
+1. **Easy by default, powerful on demand.** One-liners and presets for common cases; every setting is exposed for advanced users.
+2. **Metadata travels with data.** Sample rate, channels and loudness are never "assumed".
+3. **Reproducible.** A saved pipeline reloads with exactly the same configuration. Outputs match across CPU, CUDA and MPS within a tested numerical tolerance.
+4. **Device-agnostic.** The same code runs on CPU, CUDA or MPS. NumPy arrays and PyTorch tensors are both accepted.
+5. **Small core, optional extras.** The core needs only PyTorch, NumPy and a bundled decoder. Codecs, augmentation and metrics are opt-in extras.
+6. **Fail loudly.** Invalid shapes, sample rates or configs raise clear errors, never silent corruption.
+7. **Wrap first, replace later.** sonarch builds on proven libraries where they exist and only reimplements where it can be clearly faster or more correct.
+
+---
+
+## Installation
+
+```bash
+pip install sonarch                 # core: load/save, resample, normalize, trim, features
+pip install sonarch[augment]        # augmentation ops
+pip install sonarch[codecs]         # neural codecs (EnCodec, DAC, Mimi, SNAC)
+pip install sonarch[metrics]        # PESQ, STOI, SI-SDR
+pip install sonarch[cloud]          # S3 / GCS / HTTP reading via fsspec
+pip install sonarch[all]            # everything
+```
+
+Requires Python 3.10+ and PyTorch 2.x. Decoding uses bundled FFmpeg libraries (via PyAV), so **no system FFmpeg install is needed** on Linux, macOS or Windows.
+
+---
+
+## Quickstart
+
+### Load, inspect, convert 🚧
+
+```python
+import sonarch as sa
+
+audio = sa.load("clip.flac")
+audio.sample_rate     # 44100
+audio.channels        # 2
+audio.duration        # 12.4 (seconds)
+audio.loudness        # -18.2 (LUFS, computed on first access)
+
+audio = audio.resample(16_000).to_mono().to("cuda")
+audio.tensor          # torch.Tensor, shape (channels, samples)
+audio.numpy()         # np.ndarray
+
+sa.info("clip.flac")  # fast metadata probe, no decoding
+audio.save("clip_16k.wav")
+```
+
+Mismatches fail loudly:
+
+```python
+a, b = sa.load("a.wav"), sa.load("b_48k.wav")
+a + b                 # ❌ SampleRateMismatchError: 16000 Hz vs 48000 Hz
+sa.mix(a, b.resample(16_000), align="pad")   # ✅ explicit, pads the shorter clip
+```
+
+### Build a pipeline 🚧
+
+```python
+pipe = sa.Pipeline([
+    sa.Resample(16_000),
+    sa.ToMono(),
+    sa.LoudnessNorm(target_lufs=-23),
+    sa.TrimSilence(top_db=30),
+    sa.FixLength(seconds=10, mode="pad_or_crop"),
+    sa.MelSpectrogram(n_mels=80, n_fft=400, hop_length=160),
+])
+
+mel = pipe("clip.wav")                 # path, Audio, tensor or array
+
+pipe.save("preprocess.yaml")           # ship this with your model
+pipe = sa.Pipeline.load("preprocess.yaml")
+```
+
+### Batches on GPU 📋
+
+```python
+pipe = pipe.to("cuda")
+batch = pipe(["a.wav", "b.flac", "c.mp3"])
+batch.tensor          # (batch, n_mels, frames), padded to the longest item
+batch.lengths         # true length of each item, in frames
+batch.mask            # bool mask, True where values are real
+```
+
+If the pipeline ends in `FixLength`, every item has the same length and no padding is added.
+
+### Presets 📋
+
+```python
+pipe = sa.preset("whisper")       # 16 kHz mono, 80-bin log-mel, 30 s (Whisper up to large-v2)
+pipe = sa.preset("whisper-v3")    # same, but 128 bins (Whisper large-v3)
+features = pipe("speech.mp3")
+```
+
+---
+
+## Coming from another library?
+
+| You used to write | In sonarch |
+|---|---|
+| `librosa.load(path, sr=16000, mono=True)` | `sa.load(path).resample(16_000).to_mono()` |
+| `librosa.feature.melspectrogram(y=y, sr=sr, n_mels=80)` | `sa.MelSpectrogram(n_mels=80)(audio)` |
+| `librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)` | `sa.MFCC(n_mfcc=13)(audio)` |
+| `librosa.effects.trim(y, top_db=30)` | `audio.trim_silence(top_db=30)` |
+| `torchaudio.load(path)` | `sa.load(path)` |
+| `torchaudio.functional.resample(x, 44100, 16000)` | `audio.resample(16_000)` |
+| `torchaudio.compliance.kaldi.fbank(x, ...)` | `sa.Fbank(...)(audio)` |
+| `WhisperFeatureExtractor(...)(x)` | `sa.preset("whisper")(audio)` |
+
+Numerical ops are tested against librosa / torchaudio so outputs match within tolerance. Full migration guides: 📋 `docs/migrate-librosa.md`, `docs/migrate-torchaudio.md`.
+
+---
+
+## Features
+
+### 1. Loading & I/O 🚧
+- Decode WAV, FLAC, MP3, OGG/Opus, M4A/AAC, and audio tracks from video files
+- Save to WAV, FLAC and Opus
+- Fast metadata probing without decoding
+- Streaming / chunked reads for long files 📋
+- Read from URLs, S3 and GCS via `fsspec` (`sonarch[cloud]`) 📋
+
+### 2. Preprocessing ops
+| Category | Ops | Status |
+|---|---|---|
+| Format | `Resample`, `ToMono`, `ToStereo`, `ChangeDtype` | 🚧 |
+| Level | `PeakNorm`, `RMSNorm`, `LoudnessNorm` (EBU R128 / LUFS), `DCRemove` | 🚧 |
+| Time | `TrimSilence`, `FixLength`, `Pad`, `Crop`, `Chunk` | 🚧 |
+| Time | `VAD` | 📋 |
+| Filters | `HighPass`, `LowPass`, `BandPass`, `PreEmphasis` | 📋 |
+| Features | `STFT`, `MelSpectrogram`, `LogMel`, `MFCC` | 🚧 |
+| Features | `Fbank` (Kaldi-compatible), `CQT`, `Chroma` | 📋 |
+
+### 3. Neural codecs and tokenization (`sonarch[codecs]`) 📋
+One interface for discrete audio tokens, for audio language models and compression.
+
+```python
+codec = sa.Codec("dac", bitrate="6kbps", device="cuda")
+codec.sample_rate                   # 44100: the rate the model expects
+
+tokens = codec.encode(audio)        # (codebooks, frames) int tensor
+recon  = codec.decode(tokens)       # Audio object
+
+codec.encode(audio_16k)             # ❌ SampleRateMismatchError: codec expects 44100 Hz
+codec.encode(audio_16k, resample=True)   # ✅ explicit
+
+sa.Codec.available()                # ["encodec", "dac", "mimi", "snac", ...]
+```
+
+> **Model licenses:** sonarch is MIT, but pretrained codec weights come from their original authors and may carry different licenses. `sa.Codec.info("dac")` shows the license for each model; check it before commercial use.
+
+### 4. Datasets: compressed shards and streaming 📋
+Turn large folders of WAV files into compact, streamable shards. Built on WebDataset-style tar shards, so they also work with existing tooling.
+
+```python
+sa.dataset.pack(
+    source="raw_wavs/",
+    dest="shards/",
+    format="flac",           # lossless; or "opus" with bitrate="64kbps"
+    shard_size="1GB",
+    preprocess=pipe,         # optionally store preprocessed audio
+)
+
+ds = sa.dataset.stream("shards/", pipeline=pipe)   # PyTorch IterableDataset
+```
+
+Also reads Hugging Face `datasets` audio columns directly.
+
+### 5. Augmentation (`sonarch[augment]`) 📋
+`AddNoise`, `AddReverb` (RIR), `GainJitter`, `PitchShift`, `TimeStretch`, `SpecAugment`, `Mixup`, `CodecAugment` (simulate MP3/Opus artifacts). All are probabilistic and seedable. Most run batched on GPU. `CodecAugment` and high-quality `PitchShift` / `TimeStretch` run on CPU.
+
+```python
+train_pipe = pipe.with_augment([
+    sa.AddNoise(snr_db=(5, 20), p=0.5),         # waveform op: placed before MelSpectrogram
+    sa.SpecAugment(time_masks=2, freq_masks=2), # spectrogram op: placed after it
+], seed=42)
+```
+
+Each op declares whether it works on waveforms or spectrograms, and `with_augment` puts it in the right place automatically. `train_pipe.describe()` prints the final order.
+
+### 6. Quality evaluation (`sonarch[metrics]`) 📋
+Know what a compression setting costs *before* you train on it.
+
+```python
+report = sa.evaluate(original, recon, metrics=["pesq", "stoi", "si_sdr", "mel_distance"])
+print(report)
+
+sa.compare_codecs(
+    "eval_clips/",
+    codecs=[("opus", "24kbps"), ("dac", "6kbps"), ("encodec", "3kbps")],
+)   # → table of bitrate vs. quality
+```
+
+PESQ only supports 8 kHz and 16 kHz audio; sonarch resamples for it and says so in the report.
+
+### 7. Feature caching 📋
+Compute features once and store them compactly.
+
+```python
+sa.cache.build(dataset="shards/", pipeline=pipe, dest="mel_cache/", dtype="float16")
+```
+
+---
+
+## Writing a custom op
+
+Every op subclasses `sa.Op` and declares what kind of data it takes and returns. sonarch uses this to validate pipelines and place augmentations.
+
+```python
+class Invert(sa.Op):
+    input = "wave"           # "wave" or "spec"
+    output = "wave"
+
+    def __call__(self, audio: sa.Audio) -> sa.Audio:
+        return audio.replace(tensor=-audio.tensor)
+```
+
+Ops are automatically saved to YAML if their constructor arguments are plain types (numbers, strings, lists, dicts).
+
+---
+
+## Roadmap
+
+| Milestone | Scope | Status |
+|---|---|---|
+| **v0.1: Core** | `sa.load` / `save` / `info`, `Audio` object, resample, mono/stereo, normalization, trim, pad/crop, STFT / mel / MFCC matched to librosa, migration guides | 🚧 In progress |
+| **v0.2: ML-ready** | `Pipeline` + YAML, batched GPU execution with padding and masks, `whisper` / `wav2vec2` presets matched to Hugging Face feature extractors, benchmarks vs. librosa / torchaudio | 📋 Planned |
+| **v0.3: Codecs** | Unified `Codec` API: EnCodec, DAC, Mimi, SNAC | 📋 Planned |
+| **v0.4: Data** | `dataset.pack` / `stream`, FLAC/Opus shards, HF `datasets` support, cloud reading | 📋 Planned |
+| **v0.5: Augment & metrics** | Augmentation suite, `evaluate`, `compare_codecs` | 📋 Planned |
+| **v1.0** | Remaining features (filters, VAD, Fbank, CQT, caching), full docs, stable API | 📋 Planned |
+
+---
+
+## Project structure
+
+```
+sonarch/
+├── src/sonarch/
+│   ├── __init__.py
+│   ├── core/
+│   │   ├── audio.py          # Audio object + metadata validation
+│   │   ├── pipeline.py       # Pipeline, YAML save/load
+│   │   ├── op.py             # Base class for all ops
+│   │   └── errors.py
+│   ├── io/                   # load, save, info, decoding backends
+│   ├── ops/
+│   │   ├── format.py         # resample, channels, dtype
+│   │   ├── level.py          # normalization, loudness
+│   │   ├── time.py           # trim, pad/crop, chunk
+│   │   ├── filters.py
+│   │   └── features.py       # STFT, mel, MFCC
+│   ├── codecs/               # Codec interface + backends
+│   ├── dataset/              # pack, stream, shards
+│   ├── augment/
+│   ├── metrics/
+│   ├── cache/
+│   └── presets/              # YAML preset definitions
+├── tests/
+├── benchmarks/               # speed vs. librosa / torchaudio
+├── docs/
+├── examples/
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/trivedi-aman/sonarch.git
+cd sonarch
+pip install -e ".[dev,all]"
+pytest
+```
+
+Conventions:
+- Type hints everywhere; `mypy --strict` on `sonarch/core`
+- Formatting and linting with `ruff`
+- Every op needs: a unit test, a CPU/GPU parity test, and a YAML save/load round-trip test
+- Numerical ops are tested against a reference (librosa / torchaudio) within tolerance
+
+---
+
+## Contributing
+
+Contributions are welcome. Open an issue to discuss new ops, codecs or presets before sending a large PR.
+
+## License
+
+MIT for the sonarch code. Pretrained model weights used by `sonarch[codecs]` keep their original licenses.

sonarch-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sonarch/__init__.py,sha256=oiwrs9HNKjkRiBAIvoTpzSdfHPBJq3UKcZAh1JyOE7o,968
+sonarch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonarch/core/__init__.py,sha256=rOO1OCPauiQi0MNGJCJY0pZQ5Lji0pG8-Kbhi3e7tAM,548
+sonarch/core/audio.py,sha256=4klwWIaDSLm81qEGXi5eXKzJ-clD32ipLmzM_xYd_uA,10249
+sonarch/core/errors.py,sha256=LxHIB2Nf0KMQaojy0YHniGl2cKwaEktrS2HXdnpTDtY,2343
+sonarch/io/__init__.py,sha256=yQBOLe_NZ_a48-c657fyWwq3dsPTbIb0diVgfDsFiLA,207
+sonarch/io/_source.py,sha256=Xrq6uiHmIVd0xD_SZV-zlEwsWQd1wI8m80NvA5S5Hco,1560
+sonarch/io/info.py,sha256=QMJnMBerZzvghjbV0xdnbDAr5Wzv6jT295XPkSAp5wQ,2233
+sonarch/io/load.py,sha256=FF15PtpfT2QHzuRCUg9M5S-EJucrRmWlk6Fc5Z4Pbus,5848
+sonarch/io/save.py,sha256=VJojEya6AKEaeBUa7z0oyVd6pevzqxQgth5j9W0NL68,6227
+sonarch-0.1.0.dev0.dist-info/METADATA,sha256=HXKM4hskng2XTX26MKfJC8hE8JXC6ScgTpH2KmIo_w8,14663
+sonarch-0.1.0.dev0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+sonarch-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=d9CMrNZPd8-E7_fJnCy2BnjqPf0pjpy7OHItMmfb_LE,1069
+sonarch-0.1.0.dev0.dist-info/RECORD,,

sonarch-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sonarch-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Trivedi
+
+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.