phonometry 3.0.0__py3-none-any.whl

phonometry/parametric_filters.py

@@ -0,0 +1,370 @@
+#  Copyright (c) 2026. Jose M. Requena-Plens
+"""
+Weighting filters (A, C, Z) and time weighting utilities for audio analysis.
+Implementation according to IEC 61672-1:2013.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import List, Tuple, cast
+
+import numpy as np
+from scipy import signal
+
+from .utils import _typesignal
+
+try:
+    from numba import jit as _numba_jit
+except ImportError:  # pragma: no cover - depends on install extras
+    # unused-ignore: with numba absent its import is Any and the ignore is
+    # unnecessary; with numba installed the assignment needs it.
+    _numba_jit = None  # type: ignore[assignment, unused-ignore]
+
+
+class WeightingFilter:
+    """
+    Class-based frequency weighting filter (A, C, Z).
+    Allows pre-calculating and reusing filter coefficients.
+    """
+
+    def __init__(self, fs: int, curve: str = "A",
+                 stateful: bool = False, steady_ic: bool = False,
+                 high_accuracy: bool | None = None) -> None:
+        """
+        Initialize the weighting filter.
+
+        :param fs: Sample rate in Hz.
+        :param curve: 'A', 'C' or 'Z'.
+        :param stateful: If True, the weighting filter is stateful. Useful for block processing.
+        :param steady_ic: If True, calculate steady state initial conditions for filter.
+        :param high_accuracy: If True, design and run the filter at an internal
+            oversampled rate (>= 96 kHz) so the response stays within
+            IEC 61672-1 class 1 tolerances up to 16 kHz. The plain bilinear
+            design exceeds class 1 limits at 12.5 kHz for fs <= 48 kHz.
+            Defaults to True except in stateful mode (the internal FIR
+            resampling is incompatible with block processing).
+        """
+        if fs <= 0:
+            raise ValueError("Sample rate 'fs' must be positive.")
+        if high_accuracy is None:
+            high_accuracy = not stateful
+        if high_accuracy and stateful:
+            raise ValueError("high_accuracy is not compatible with stateful processing.")
+
+        self.fs = fs
+        self.curve = curve.upper()
+        self.stateful = stateful
+        self.high_accuracy = high_accuracy
+        self._oversample = min(8, max(1, math.ceil(96000 / fs))) if high_accuracy else 1
+
+        if self.curve == "Z":
+            self.sos = np.array([])
+            if self.stateful:
+                self.zi = np.array([])
+            return
+
+        if self.curve not in ["A", "C"]:
+            raise ValueError("Weighting curve must be 'A', 'C' or 'Z'")
+
+        # Analog ZPK for A and C weighting
+        # f1, f2, f3, f4 constants as per IEC 61672-1
+        f1 = 20.598997
+        f4 = 12194.217
+
+        if self.curve == "A":
+            f2 = 107.65265
+            f3 = 737.86223
+            # Zeros at 0 Hz
+            z = np.array([0, 0, 0, 0])
+            # Poles
+            p = np.array(
+                [
+                    -2 * np.pi * f1,
+                    -2 * np.pi * f1,
+                    -2 * np.pi * f4,
+                    -2 * np.pi * f4,
+                    -2 * np.pi * f2,
+                    -2 * np.pi * f3,
+                ]
+            )
+            # k chosen to give 0 dB at 1000 Hz
+            k = 3.5174303309e13
+
+        else:  # C weighting
+            z = np.array([0, 0])
+            p = np.array([-2 * np.pi * f1, -2 * np.pi * f1, -2 * np.pi * f4, -2 * np.pi * f4])
+            k = 5.91797e8
+
+        # Recalculate k to ensure 0dB at 1kHz
+        w = 2 * np.pi * 1000
+        h = k * np.prod(1j * w - z) / np.prod(1j * w - p)
+        k = k / np.abs(h)
+
+        design_fs = self.fs * self._oversample
+        zd, pd, kd = signal.bilinear_zpk(z, p, k, design_fs)
+        self.sos = signal.zpk2sos(zd, pd, kd)
+
+        # Initialize filter state for stateful block-wise processing.
+        # Uses lazy allocation: zi is sized on first filter() call so that
+        # the channel dimension matches the actual input shape.
+        if self.stateful:
+            self.zi = np.array([])
+            self._steady_ic = steady_ic
+
+    def _init_filter_state(self, x_proc: np.ndarray) -> None:
+        """Allocate or reallocate ``zi`` to match the input shape."""
+        n_sections = self.sos.shape[0]
+        if x_proc.ndim == 1:
+            if self._steady_ic:
+                self.zi = signal.sosfilt_zi(self.sos)
+            else:
+                self.zi = np.zeros((n_sections, 2))
+        else:
+            n_channels = x_proc.shape[0]
+            if self._steady_ic:
+                zi_base = signal.sosfilt_zi(self.sos)
+                self.zi = np.tile(zi_base[:, np.newaxis, :], (1, n_channels, 1))
+            else:
+                self.zi = np.zeros((n_sections, n_channels, 2))
+
+    def _needs_zi_reinit(self, x_proc: np.ndarray) -> bool:
+        """Check whether ``zi`` must be (re)allocated for *x_proc*."""
+        if self.zi.size == 0:
+            return True
+        if x_proc.ndim == 1:
+            return self.zi.ndim != 2
+        return self.zi.ndim != 3 or self.zi.shape[1] != x_proc.shape[0]
+
+    def filter(self, x: List[float] | np.ndarray) -> np.ndarray:
+        """
+        Apply the weighting filter to a signal.
+
+        :param x: Input signal (1D or 2D [channels, samples]).
+        :return: Weighted signal.
+        """
+        x_proc = _typesignal(x)
+        if self.curve == "Z":
+            return x_proc
+
+        if self.stateful:
+            if self._needs_zi_reinit(x_proc):
+                self._init_filter_state(x_proc)
+            y, self.zi = signal.sosfilt(self.sos, x_proc, axis=-1, zi=self.zi)
+        elif self._oversample > 1:
+            if x_proc.shape[-1] == 0:
+                return x_proc  # resample_poly rejects empty input
+            up = signal.resample_poly(x_proc, self._oversample, 1, axis=-1)
+            y_up = signal.sosfilt(self.sos, up, axis=-1)
+            y = signal.resample_poly(y_up, 1, self._oversample, axis=-1)
+        else:
+            y = signal.sosfilt(self.sos, x_proc, axis=-1)
+
+        return cast(np.ndarray, y)
+
+
+def weighting_filter(
+    x: List[float] | np.ndarray, fs: int, curve: str = "A", high_accuracy: bool = True
+) -> np.ndarray:
+    """
+    Apply frequency weighting (A or C) to a signal.
+
+    :param x: Input signal.
+    :param fs: Sample rate.
+    :param curve: 'A', 'C' or 'Z' (Z is zero weighting/bypass).
+    :param high_accuracy: Use internal oversampling for IEC 61672-1 class 1
+        accuracy at high frequencies (default True).
+    :return: Weighted signal.
+    """
+    wf = WeightingFilter(fs, curve, high_accuracy=high_accuracy)
+    return wf.filter(x)
+
+
+def _prepare_time_weighting_initial_state(
+    x_sq: np.ndarray,
+    initial_state: str | float | np.ndarray | None,
+) -> np.ndarray:
+    """Return the previous output state ``y[-1]`` for time weighting."""
+    invalid_initial_state_message = "initial_state must be None, 'zero', 'first', a scalar, or an array"
+    state_shape = x_sq.shape[:-1]
+
+    if initial_state is None:
+        return np.zeros(state_shape, dtype=x_sq.dtype)
+
+    if isinstance(initial_state, str):
+        state_name = initial_state.lower()
+        if state_name == "zero":
+            return np.zeros(state_shape, dtype=x_sq.dtype)
+        if state_name == "first":
+            if x_sq.shape[-1] == 0:
+                raise ValueError(invalid_initial_state_message)
+            return np.asarray(np.take(x_sq, 0, axis=-1), dtype=x_sq.dtype).copy()
+        raise ValueError(invalid_initial_state_message)
+
+    state = np.asarray(initial_state, dtype=x_sq.dtype)
+    if state.shape == ():
+        return np.full(state_shape, state.item(), dtype=x_sq.dtype)
+
+    try:
+        return np.broadcast_to(state, state_shape).astype(x_sq.dtype, copy=True)
+    except ValueError as exc:
+        raise ValueError(
+            "initial_state must be scalar or broadcastable to the input shape without the time axis"
+        ) from exc
+
+
+def _impulse_kernel_py(
+    x_t: np.ndarray,
+    alpha_rise: float,
+    alpha_fall: float,
+    initial_state: np.ndarray,
+) -> np.ndarray:
+    """Asymmetric time-weighting kernel (pure Python; jitted when numba is present)."""
+    y_t = np.zeros_like(x_t)
+    curr_y = initial_state.copy()
+
+    for i in range(x_t.shape[0]):
+        val = x_t[i]
+        rising = val > curr_y
+
+        diff = val - curr_y
+        factor = np.where(rising, alpha_rise, alpha_fall)
+        curr_y += factor * diff
+        y_t[i] = curr_y
+
+    return y_t
+
+
+if _numba_jit is not None:
+    _apply_impulse_kernel = _numba_jit(nopython=True, cache=True)(_impulse_kernel_py)
+else:  # pragma: no cover - exercised only without numba installed
+    _apply_impulse_kernel = _impulse_kernel_py
+
+def time_weighting(
+    x: List[float] | np.ndarray,
+    fs: int,
+    mode: str = "fast",
+    initial_state: str | float | np.ndarray | None = None,
+) -> np.ndarray:
+    """
+    Apply time weighting to a signal (Exponential averaging).
+    
+    :param x: Input signal (raw pressure/voltage). The function squares it internally.
+    :param fs: Sample rate.
+    :param mode: 'fast' (125ms), 'slow' (1000ms), 'impulse' (35ms rise, 1500ms fall).
+    :param initial_state: Previous mean-square output state ``y[-1]``. Use None/'zero' for
+        zero initialization (default), 'first' to initialize from the first input energy,
+        or a scalar/array broadcastable to the input shape without the time axis.
+    :return: Time-weighted squared signal (sound pressure level envelope).
+    """
+    x_proc = _typesignal(x)
+    if fs <= 0:
+        raise ValueError("Sample rate 'fs' must be positive.")
+    x_sq = x_proc**2
+    initial = _prepare_time_weighting_initial_state(x_sq, initial_state)
+    
+    mode_lower = mode.lower()
+    
+    if mode_lower in ["fast", "slow"]:
+        tau = 0.125 if mode_lower == "fast" else 1.0
+        alpha = 1 - np.exp(-1 / (fs * tau))
+        b = [alpha]
+        a = [1, -(1 - alpha)]
+        # We apply the weighting to the squared signal to get the Mean Square value
+        zi = np.expand_dims((1 - alpha) * initial, axis=-1)
+        y, _ = signal.lfilter(b, a, x_sq, axis=-1, zi=zi)
+        return cast(np.ndarray, y)
+        
+    elif mode_lower == "impulse":
+        # IEC 61672-1: 35ms for rising, 1500ms for falling
+        tau_rise = 0.035
+        tau_fall = 1.5
+        
+        alpha_rise = 1 - np.exp(-1 / (fs * tau_rise))
+        alpha_fall = 1 - np.exp(-1 / (fs * tau_fall))
+        
+        # Move time axis to front for iteration
+        x_t = np.moveaxis(x_sq, -1, 0)
+        
+        # Ensure contiguous array for Numba
+        x_t = np.ascontiguousarray(x_t)
+        initial_kernel = initial if initial.ndim == 0 else np.ascontiguousarray(initial)
+        y_t = _apply_impulse_kernel(x_t, alpha_rise, alpha_fall, initial_kernel)
+            
+        # Move time axis back
+        return np.moveaxis(y_t, 0, -1)
+
+    else:
+        raise ValueError("Invalid time weighting mode. Use ['fast', 'slow', 'impulse']")
+
+
+class TimeWeighting:
+    """
+    Stateful time weighting for block processing.
+
+    Wraps :func:`time_weighting` carrying the exponential integrator state
+    across blocks, so concatenated block outputs equal a single continuous call.
+    """
+
+    def __init__(self, fs: int, mode: str = "fast") -> None:
+        """
+        :param fs: Sample rate in Hz.
+        :param mode: 'fast' (125 ms), 'slow' (1000 ms) or 'impulse' (35 ms / 1.5 s).
+        """
+        if fs <= 0:
+            raise ValueError("Sample rate 'fs' must be positive.")
+        if mode.lower() not in ("fast", "slow", "impulse"):
+            raise ValueError("Invalid time weighting mode. Use ['fast', 'slow', 'impulse']")
+        self.fs = fs
+        self.mode = mode.lower()
+        self._state: np.ndarray | None = None
+
+    def process(self, x: List[float] | np.ndarray) -> np.ndarray:
+        """Apply time weighting to a block, continuing from the previous block."""
+        x_proc = _typesignal(x)
+        if x_proc.shape[-1] == 0:
+            return x_proc  # nothing to process; keep the carried state
+        env = time_weighting(x_proc, self.fs, mode=self.mode, initial_state=self._state)
+        self._state = np.asarray(env[..., -1]).copy()
+        return env
+
+    def reset(self) -> None:
+        """Forget the carried state (the next block starts from rest)."""
+        self._state = None
+
+
+def linkwitz_riley(
+    x: List[float] | np.ndarray, 
+    fs: int, 
+    freq: float, 
+    order: int = 4
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Linkwitz-Riley crossover filter (Butterworth squared).
+    Splits signal into low and high bands with flat sum response.
+    
+    :param x: Input signal.
+    :param fs: Sample rate.
+    :param freq: Crossover frequency.
+    :param order: Total order (must be even, typically 2 or 4).
+    :return: (low_pass_signal, high_pass_signal)
+    """
+    x_proc = _typesignal(x)
+    if order % 2 != 0:
+        raise ValueError("Linkwitz-Riley order must be even (typically 2 or 4).")
+    
+    # A Linkwitz-Riley filter of order N is two Butterworth filters of order N/2 in series
+    half_order = order // 2
+    wn = freq / (fs / 2)
+    
+    sos_lp = signal.butter(half_order, wn, btype='low', output='sos')
+    sos_hp = signal.butter(half_order, wn, btype='high', output='sos')
+    
+    # Pass twice
+    lp = signal.sosfilt(sos_lp, x_proc)
+    lp = signal.sosfilt(sos_lp, lp)
+    
+    hp = signal.sosfilt(sos_hp, x_proc)
+    hp = signal.sosfilt(sos_hp, hp)
+    
+    return lp, hp

phonometry/utils.py

@@ -0,0 +1,74 @@
+#  Copyright (c) 2026. Jose M. Requena-Plens
+"""
+Signal processing utilities for phonometry.
+"""
+
+from __future__ import annotations
+
+from typing import List, Tuple, cast
+
+import numpy as np
+from scipy import signal
+
+
+def _typesignal(x: List[float] | np.ndarray | Tuple[float, ...]) -> np.ndarray:
+    """
+    Ensure signal is a float64 numpy array.
+
+    Integer inputs (e.g. int16 audio from ``scipy.io.wavfile.read``) are
+    converted to float64 to prevent silent overflow when the signal is
+    squared internally. Float64 arrays are passed through without copying.
+
+    :param x: Input signal.
+    :return: Numpy float64 array.
+    """
+    return np.atleast_1d(np.asarray(x, dtype=np.float64))
+
+
+def _resample_to_length(y: np.ndarray, factor: int, target_length: int) -> np.ndarray:
+    """
+    Resample signal and ensure the output matches target_length exactly.
+    Handles both 1D and 2D (channels, samples) arrays.
+
+    :param y: Input signal.
+    :param factor: Resampling factor.
+    :param target_length: Target length.
+    :return: Resampled signal.
+    """
+    if factor == 1:
+        # Nothing to resample: fall through to the slice/pad logic only.
+        y_resampled = y
+    else:
+        y_resampled = cast(np.ndarray, signal.resample_poly(y, factor, 1, axis=-1))
+    current_length = y_resampled.shape[-1]
+    
+    if current_length > target_length:
+        # Slice along the last axis (works for both 1D and 2D)
+        y_resampled = y_resampled[..., :target_length]
+            
+    elif current_length < target_length:
+        diff = target_length - current_length
+        # Pad only the last axis. This works for both 1D and 2D arrays.
+        # For 1D, pad_width becomes `[(0, diff)]`.
+        # For 2D, pad_width becomes `[(0, 0), (0, diff)]`.
+        pad_width: List[Tuple[int, int]] = [(0, 0)] * (y_resampled.ndim - 1) + [(0, diff)]
+            
+        y_resampled = np.pad(y_resampled, pad_width, mode='constant')
+        
+    return y_resampled
+
+
+def _downsamplingfactor(freq: List[float], fs: int, headroom: float = 1.25) -> np.ndarray:
+    """
+    Compute optimal downsampling factors for filter stability.
+
+    :param freq: Band upper-edge frequencies.
+    :param fs: Sample rate.
+    :param headroom: Required ratio between the decimated Nyquist and the
+        band's upper edge. 1.25 reproduces the classic ``fs / (2 + 0.5)``
+        guard; filter types whose design extends above the upper edge
+        (cheby2 stopband) need more.
+    :return: Array of factors.
+    """
+    factor = (np.floor((fs / 2) / (headroom * np.array(freq)))).astype("int")
+    return cast(np.ndarray, np.clip(factor, 1, 500))

phonometry-3.0.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: phonometry
+Version: 3.0.0
+Summary: Acoustic measurement toolkit: fractional octave-band filters, A/C/Z and time weighting, and sound level metrology per IEC 61260-1 and IEC 61672-1.
+Author-email: Jose Manuel Requena Plens <jmrplens@gmail.com>
+Project-URL: Homepage, https://github.com/jmrplens/phonometry
+Project-URL: Bug Tracker, https://github.com/jmrplens/phonometry/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: scipy>=1.17.1
+Provides-Extra: perf
+Requires-Dist: numba>=0.65.1; extra == "perf"
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.10.9; extra == "plot"
+Provides-Extra: full
+Requires-Dist: numba>=0.65.1; extra == "full"
+Requires-Dist: matplotlib>=3.10.9; extra == "full"
+Dynamic: license-file
+
+<!-- Package -->
+[![PyPI version](https://img.shields.io/pypi/v/phonometry?logo=pypi&logoColor=white)](https://pypi.org/project/phonometry/)
+[![Python versions](https://img.shields.io/pypi/pyversions/phonometry?logo=python&logoColor=white)](https://pypi.org/project/phonometry/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/jmrplens/phonometry/blob/main/LICENSE)
+
+<!-- Quality -->
+[![CI](https://github.com/jmrplens/phonometry/actions/workflows/python-app.yml/badge.svg)](https://github.com/jmrplens/phonometry/actions/workflows/python-app.yml)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=jmrplens_PyOctaveBand&metric=alert_status)](https://sonarcloud.io/summary/overall?id=jmrplens_PyOctaveBand)
+[![codecov](https://codecov.io/gh/jmrplens/phonometry/branch/main/graph/badge.svg)](https://codecov.io/gh/jmrplens/phonometry)
+
+<!-- Citation & support -->
+[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.21215280-blue?logo=doi&logoColor=white)](https://doi.org/10.5281/zenodo.21215280)
+
+# phonometry
+
+> *phonometry* — the measurement of sound. Formerly published as **PyOctaveBand**.
+
+Acoustic measurement toolkit for Python: fractional octave-band filter banks, frequency and time weighting, and sound level metrology — conformance-tested against **IEC 61260-1:2014 / ANSI S1.11-2004** (filters) and **IEC 61672-1:2013** (weighting and levels) class 1 tolerance limits.
+
+<img src="https://raw.githubusercontent.com/jmrplens/phonometry/main/.github/images/filter_type_comparison.png" alt="Magnitude response comparison of the five filter architectures for the 1 kHz octave band, with a zoom at the -3 dB crossover" width="80%">
+
+## ✨ Highlights
+
+- 🎛️ 1/1, 1/3 and arbitrary fractional octave filter banks (stable SOS + multirate decimation)
+- 🏗️ Five architectures: Butterworth, Chebyshev I/II, Elliptic, Bessel — all with −3 dB points on the ANSI band edges
+- 🔊 A/C/Z frequency weighting within IEC 61672-1 class 1 tolerances
+- ⏱️ Fast/Slow/Impulse time ballistics, `Leq`, `LAeq` and `L10/L50/L90` statistical levels
+- 🗺️ Octave spectrogram (band levels over time) and zero-phase offline filtering
+- 📏 Physical SPL calibration and dBFS modes
+- ⚡ Vectorized multichannel processing and stateful block (real-time) workflows
+
+## 🚀 Installation
+
+```bash
+pip install phonometry
+```
+
+Optional extras: `phonometry[plot]` (matplotlib for response plots), `phonometry[perf]` (numba for faster impulse ballistics), `phonometry[full]` (both).
+
+## 📚 Documentation
+
+**Full documentation website: https://jmrplens.github.io/phonometry/** (English / Español)
+
+Or browse the Markdown docs on GitHub:
+
+| Page | Contents |
+| :--- | :--- |
+| [Getting Started](https://github.com/jmrplens/phonometry/blob/main/docs/getting-started.md) | Installation, first analysis, WAV files |
+| [Filter Banks](https://github.com/jmrplens/phonometry/blob/main/docs/filter-banks.md) | Architectures, response gallery, band decomposition, zero-phase |
+| [Frequency Weighting](https://github.com/jmrplens/phonometry/blob/main/docs/weighting.md) | A/C/Z curves, class 1 high-accuracy mode |
+| [Time Weighting](https://github.com/jmrplens/phonometry/blob/main/docs/time-weighting.md) | Fast/Slow/Impulse ballistics, initial state |
+| [Levels](https://github.com/jmrplens/phonometry/blob/main/docs/levels.md) | Leq, LAeq, L10/L50/L90, octave spectrogram |
+| [Calibration and dBFS](https://github.com/jmrplens/phonometry/blob/main/docs/calibration.md) | Physical SPL, digital full-scale, RMS vs peak |
+| [Block Processing](https://github.com/jmrplens/phonometry/blob/main/docs/block-processing.md) | Stateful streaming workflows |
+| [Multichannel](https://github.com/jmrplens/phonometry/blob/main/docs/multichannel.md) | Vectorized multichannel analysis, performance |
+| [API Reference](https://github.com/jmrplens/phonometry/blob/main/docs/api-reference.md) | Every public function and class |
+| [Theory](https://github.com/jmrplens/phonometry/blob/main/docs/theory.md) | Standards, math, design decisions |
+| [Why phonometry](https://github.com/jmrplens/phonometry/blob/main/docs/why-phonometry.md) | IEC compliance verification vs other libraries |
+
+## ⚡ Quick start
+
+```python
+import numpy as np
+from phonometry import octavefilter
+
+fs = 48000
+t = np.linspace(0, 1, fs, endpoint=False)
+# Composite signal: 100Hz + 1000Hz
+signal = np.sin(2 * np.pi * 100 * t) + np.sin(2 * np.pi * 1000 * t)
+
+# Apply 1/3 octave filter bank
+spl, freq = octavefilter(signal, fs=fs, fraction=3)
+
+print(f"Bands: {freq}")
+print(f"SPL [dB]: {spl}")
+```
+
+<img src="https://raw.githubusercontent.com/jmrplens/phonometry/main/.github/images/signal_response_fraction_3.png" alt="One-third-octave spectrum analysis of a multi-tone signal with the raw PSD in the background" width="80%">
+
+*1/3 Octave Band spectrum analysis of a complex signal. More examples in the
+[documentation](https://jmrplens.github.io/phonometry/).*
+
+## 🧪 Development
+
+```bash
+make install   # dependencies + editable install
+make check     # ruff + mypy + bandit + tests
+make graphs    # regenerate documentation images
+```
+
+See https://github.com/jmrplens/phonometry/blob/main/CONTRIBUTING.md and the
+https://github.com/jmrplens/phonometry/blob/main/CHANGELOG.md
+
+## 📄 License
+
+[MIT](https://github.com/jmrplens/phonometry/blob/main/LICENSE)

phonometry-3.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+phonometry/__init__.py,sha256=jFIpT1TzUSkVztO-LiFNpkA0Nqmiwh1SdgKTI-0qoTE,8160
+phonometry/_version.py,sha256=GbetSl2f2RooDvKeN_2ANFqlVg6x_TSQZme_To4_N3M,626
+phonometry/calibration.py,sha256=wxDu4jGMqEo9nWigsAlWlpc_r7KzCreecq_cU2LMxvE,4079
+phonometry/compliance.py,sha256=VuAOWkJAnkAI7YKX9-fQK7AG9U4D3hmDEfrUXhRMFjo,8161
+phonometry/core.py,sha256=1TDW7KWsE9v1S5-CJcw6kjfjeLgmq0dzZa1v4Zcs_9I,18684
+phonometry/filter_design.py,sha256=T7mYPCCVaIW62eO3cVkVNOlnwX3_rAwH1co73fHri-M,7587
+phonometry/frequencies.py,sha256=9Wk7NILiN8VTu68qc5NdKKOqOMuGaH8JzvQ1bxkPlNo,5871
+phonometry/levels.py,sha256=RlNlZGg3Cd1NMtEdus1ulgY75JxPfu5je1h8xT-pKGM,9808
+phonometry/parametric_filters.py,sha256=WJ863nmO1Rye3RFDPSLsfoIbA2rVncL_UlsKbq_YxGI,13393
+phonometry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+phonometry/utils.py,sha256=ZWdWSjCSmYHCl749cH0MuGYhKZ4A5GOf8aYrboJAwoo,2639
+phonometry-3.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+phonometry-3.0.0.dist-info/METADATA,sha256=GQRPDiJj_fuUuGpPCWcXCf2_hkJRr96o4u18WiZQrgs,6652
+phonometry-3.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+phonometry-3.0.0.dist-info/top_level.txt,sha256=ditjBTAq4gCoEFT8KPKY0PMNts0TlNu3uuzpcjQQtiM,11
+phonometry-3.0.0.dist-info/RECORD,,

phonometry-3.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+