hunterHearsPy 1.0.3__py3-none-any.whl

hunterHearsPy/theTypes.py

@@ -0,0 +1,118 @@
+"""Type definitions for audio signal processing and waveform analysis.
+
+(AI generated docstring)
+
+This module defines type aliases and typed dictionaries for NumPy arrays,
+waveforms, spectrograms, and parameter structures used throughout the audio
+signal processing library.
+
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from numpy import complexfloating, dtype, floating, ndarray
+from typing import Any, TYPE_CHECKING, TypeAlias, TypedDict, TypeVar
+
+if TYPE_CHECKING:
+	from scipy.signal._short_time_fft import _FFTMode, _PadType, _ScaleTo
+
+ArrayType = TypeVar('ArrayType', bound=ndarray[tuple[Any, ...], dtype[Any]], covariant=True)
+WindowingFunctionDtype: TypeAlias = floating[Any]
+WindowingFunction: TypeAlias = ndarray[tuple[int], dtype[WindowingFunctionDtype]]
+callableReturnsNDArray = TypeVar('callableReturnsNDArray', bound=Callable[..., WindowingFunction])
+WaveformDtype: TypeAlias = floating[Any]
+Waveform: TypeAlias = ndarray[tuple[int, int], dtype[WaveformDtype]]
+"""Two-axes NumPy `ndarray` representing audio waveforms.
+
+A NumPy `ndarray` of audio waveform data with shape (channels, samples). For mono audio, `channels` = 1.
+
+"""
+
+ArrayWaveforms: TypeAlias = ndarray[tuple[int, int, int], dtype[WaveformDtype]]
+"""Three-axes NumPy `ndarray` representing multiple waveforms.
+
+A NumPy `ndarray` containing `ndarray` of type `Waveform` indexed on the last axis: shape is (channels, samples, `Waveform`).
+
+"""
+
+SpectrogramDtype: TypeAlias = complexfloating[Any, Any]
+Spectrogram: TypeAlias = ndarray[tuple[int, int, int], dtype[SpectrogramDtype]]
+"""Three-axes `ndarray` representing a spectrogram.
+
+A NumPy `ndarray` of spectrogram data with shape (channels, frequency_bins, time_frames). For mono audio, `channels` = 1.
+
+"""
+
+ArraySpectrograms: TypeAlias = ndarray[tuple[int, int, int, int], dtype[SpectrogramDtype]]
+"""Four-axes NumPy `ndarray` representing multiple spectrograms.
+
+A NumPy `ndarray` containing `ndarray` of type `Spectrogram` indexed on the last axis: shape is (channels, frequency_bins, time_frames, `Spectrogram`).
+
+"""
+
+class ParametersSTFT(TypedDict, total=False):
+	"""Optional parameters for Short-Time Fourier Transform operations.
+
+	(AI generated docstring)
+
+	TypedDict defining optional configuration parameters for STFT computations.
+	All fields are optional due to `total=False`.
+
+	"""
+
+	padding: _PadType
+	axis: int
+
+class ParametersShortTimeFFT(TypedDict, total=False):
+	"""Optional parameters for Short-Time FFT operations.
+
+	(AI generated docstring)
+
+	TypedDict defining optional configuration parameters for short-time FFT.
+	All fields are optional due to `total=False`.
+
+	"""
+
+	fft_mode: _FFTMode
+	scale_to: _ScaleTo
+
+class ParametersUniversal(TypedDict):
+	"""Required parameters for universal audio processing operations.
+
+	(AI generated docstring)
+
+	TypedDict defining required configuration parameters used across multiple
+	audio processing functions. All fields must be provided.
+
+	"""
+
+	lengthFFT: int
+	lengthHop: int
+	lengthWindowingFunction: int
+	sampleRate: float
+	windowingFunction: WindowingFunction
+
+class WaveformMetadata(TypedDict):
+	"""Metadata describing waveform file properties and processing state.
+
+	(AI generated docstring)
+
+	TypedDict containing information about a waveform's source file and
+	any padding or trimming applied during processing.
+
+	"""
+
+	pathFilename: str
+	lengthWaveform: int
+	samplesLeading: int
+	samplesTrailing: int
+
+NormalizationReverter: TypeAlias = Callable[[Waveform], Waveform]
+"""Function type for reversing normalization operations.
+
+(AI generated docstring)
+
+Type alias for callable objects that accept a normalized waveform and
+return the waveform restored to its original amplitude scale.
+
+"""

hunterHearsPy/windowingFunctions.py

@@ -0,0 +1,211 @@
+"""Generate windowing functions for signal processing.
+
+Contents
+--------
+Functions
+	cosineWings
+		Generate a cosine-tapered windowing function with a flat center and tapered ends.
+	equalPower
+		Generate an equal-power taper for crossfades.
+	halfsine
+		Generate a half-sine windowing function.
+	tukey
+		Generate a Tukey windowing function with optional taper control.
+"""
+from __future__ import annotations
+
+from numpy import cos, pi, sin
+from typing import TYPE_CHECKING
+import numpy
+import scipy.signal.windows as SciPy
+
+if TYPE_CHECKING:
+	from hunterHearsPy import WindowingFunction
+
+def _getLengthTaper(lengthWindow: int, ratioTaper: float | None) -> int:
+	"""I use this shared subroutine to split a window length into taper sections.
+
+	This function converts a whole window length and a taper ratio into the number of samples in one
+	edge taper. Public window constructors call it so they can share the same taper-length logic.
+
+	Parameters
+	----------
+	lengthWindow : int
+		Total length of the windowing function.
+	ratioTaper : float | None
+		Ratio of taper length to windowing-function length. When `None`, the default taper ratio is
+		used.
+
+	Returns
+	-------
+	lengthTaper : int
+		Number of samples in one taper section.
+	"""  # noqa: DOC501
+	if ratioTaper is None:
+		lengthTaper = int(lengthWindow * 0.1 / 2)
+	elif 0 <= ratioTaper <= 1:
+		lengthTaper = int(lengthWindow * ratioTaper / 2)
+	else:
+		message: str = f"I received `{ratioTaper = }`. If set, `ratioTaper` must be between 0 and 1, inclusive."
+		raise ValueError(message)
+	return lengthTaper
+
+def cosineWings(lengthWindow: int, ratioTaper: float | None = None) -> WindowingFunction:
+	"""Generate a cosine-tapered windowing function with a flat center and tapered ends.
+
+	This function creates a NumPy array [1] of coefficients that rise smoothly from 0 to 1, stay
+	flat in the middle, and mirror the taper at the end. It uses `numpy.linspace` [2] to sample the
+	taper and `numpy.cos` [3] to shape it. It acts on `lengthWindow` and `ratioTaper` and returns
+	the windowing coefficients.
+
+	Parameters
+	----------
+	lengthWindow : int
+		Total length of the windowing function.
+	ratioTaper : float | None = None
+		Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+		inclusive.
+
+	Returns
+	-------
+	windowingFunction : WindowingFunction
+		NumPy array of windowing coefficients with cosine tapers.
+
+	See Also
+	--------
+	`hunterHearsPy.optionalPyTorch.cosineWingsTensor`
+		Tensor version of this windowing function.
+
+	References
+	----------
+	[1] NumPy `ndarray`.
+		https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+	[2] NumPy `linspace`.
+		https://numpy.org/doc/stable/reference/generated/numpy.linspace.html
+	[3] NumPy `cos`.
+		https://numpy.org/doc/stable/reference/generated/numpy.cos.html
+
+	"""
+	lengthTaper: int = _getLengthTaper(lengthWindow, ratioTaper)
+
+	windowingFunction: WindowingFunction = numpy.ones(shape=lengthWindow)
+	if 0 < lengthTaper:
+		taper = 1 - cos(numpy.linspace(start=0, stop=pi / 2, num=lengthTaper, dtype=windowingFunction.dtype))
+		windowingFunction[0:lengthTaper] = taper
+		windowingFunction[-lengthTaper:None] = taper[::-1]
+	return windowingFunction
+
+def equalPower(lengthWindow: int, ratioTaper: float | None = None) -> WindowingFunction:
+	"""Generate an equal-power taper for crossfades.
+
+	This function creates a NumPy array [1] of coefficients that follow a square-root taper at both
+	ends and a flat center. It uses `numpy.linspace` [2] to sample the taper and `numpy.sqrt` [3] to
+	convert it to equal-power scaling. It acts on `lengthWindow` and `ratioTaper` and returns the
+	windowing coefficients.
+
+	Parameters
+	----------
+	lengthWindow : int
+		Total length of the windowing function.
+	ratioTaper : float | None = None
+		Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+		inclusive.
+
+	Returns
+	-------
+	windowingFunction : WindowingFunction
+		NumPy array of windowing coefficients with tapers.
+
+	See Also
+	--------
+	`hunterHearsPy.optionalPyTorch.equalPowerTensor`
+		Tensor version of this windowing function.
+
+	References
+	----------
+	[1] NumPy `ndarray`.
+		https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+	[2] NumPy `linspace`.
+		https://numpy.org/doc/stable/reference/generated/numpy.linspace.html
+	[3] NumPy `sqrt`.
+		https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html
+
+	"""
+	lengthTaper: int = _getLengthTaper(lengthWindow, ratioTaper)
+
+	windowingFunction: WindowingFunction = numpy.ones(shape=lengthWindow)
+	if 0 < lengthTaper:
+		taper = numpy.sqrt(numpy.linspace(start=0, stop=1, num=lengthTaper, dtype=windowingFunction.dtype))
+		windowingFunction[0:lengthTaper] = taper
+		windowingFunction[-lengthTaper:None] = taper[::-1]
+	return windowingFunction
+
+def halfsine(lengthWindow: int) -> WindowingFunction:
+	"""Generate a half-sine windowing function.
+
+	This function creates a NumPy array [1] of coefficients that follow a half-sine profile across
+	the requested length. It uses `numpy.arange` [2] and `numpy.sin` [3] to place the samples. It
+	acts on `lengthWindow` and returns the windowing coefficients.
+
+	Parameters
+	----------
+	lengthWindow : int
+		Total length of the windowing function.
+
+	Returns
+	-------
+	windowingFunction : WindowingFunction
+		NumPy array of windowing coefficients following a half-sine shape.
+
+	See Also
+	--------
+	`hunterHearsPy.optionalPyTorch.halfsineTensor`
+		Tensor version of this windowing function.
+
+	References
+	----------
+	[1] NumPy `ndarray`.
+		https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+	[2] NumPy `arange`.
+		https://numpy.org/doc/stable/reference/generated/numpy.arange.html
+	[3] NumPy `sin`.
+		https://numpy.org/doc/stable/reference/generated/numpy.sin.html
+
+	"""
+	return sin(pi * (numpy.arange(lengthWindow) + 0.5) / lengthWindow, dtype=numpy.float64)
+
+def tukey(lengthWindow: int, ratioTaper: float | None = None, **keywordArguments: float) -> WindowingFunction:
+	"""Generate a Tukey windowing function with optional SciPy keyword overrides.
+
+	This function creates a NumPy array [1] by delegating to SciPy's Tukey window implementation
+	[2]. It accepts `lengthWindow`, `ratioTaper`, and extra keyword arguments, then returns the
+	windowing coefficients.
+
+	Parameters
+	----------
+	lengthWindow : int
+		Total length of the windowing function.
+	ratioTaper : float | None = None
+		Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+		inclusive.
+	**keywordArguments : float
+		Additional keyword arguments. `alpha` overrides `ratioTaper` when provided, matching SciPy's
+		API.
+
+	Returns
+	-------
+	windowingFunction : WindowingFunction
+		NumPy array of Tukey windowing function coefficients.
+
+	References
+	----------
+	[1] NumPy `ndarray`.
+		https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+	[2] SciPy Tukey window.
+		https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.windows.tukey.html
+
+	"""
+	alpha: float | None = keywordArguments.get('alpha', ratioTaper)  # Are you tempted to use `or 0.1`? Don't be: it will override the user's value for `ratioTaper=0`.
+	if alpha is None:
+		alpha = 0.1
+	return SciPy.tukey(lengthWindow, alpha)

hunterHearsPy/windowingFunctionsTensor.py

@@ -0,0 +1,168 @@
+"""Create PyTorch tensor windowing functions."""
+from __future__ import annotations
+
+from hunterHearsPy import callableReturnsNDArray, cosineWings, equalPower, halfsine, tukey
+from typing import Any, TYPE_CHECKING
+import torch
+
+if TYPE_CHECKING:
+    from torch.types import Device
+
+def _convertToTensor(*arguments: Any, callableTarget: callableReturnsNDArray, device: Device, **keywordArguments: Any) -> torch.Tensor:
+    arrayTarget = callableTarget(*arguments, **keywordArguments)
+    return torch.tensor(data=arrayTarget, dtype=torch.float32, device=device)
+
+def cosineWingsTensor(lengthWindow: int, ratioTaper: float | None=None, device: Device | None=None) -> torch.Tensor:
+    """Generate a cosine-tapered windowing function with a flat center and tapered ends.
+
+    This function creates a NumPy array [1] of coefficients that rise smoothly from 0 to 1, stay
+    flat in the middle, and mirror the taper at the end. It uses `numpy.linspace` [2] to sample the
+    taper and `numpy.cos` [3] to shape it. It acts on `lengthWindow` and `ratioTaper` and returns
+    the windowing coefficients.
+
+    Parameters
+    ----------
+    lengthWindow : int
+        Total length of the windowing function.
+    ratioTaper : float | None = None
+        Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+        inclusive.
+    device : Device = torch.device(device='cpu')
+        PyTorch device for `Tensor`.
+
+    Returns
+    -------
+    windowingFunction : WindowingFunction
+        NumPy array of windowing coefficients with cosine tapers.
+
+    See Also
+    --------
+    `hunterHearsPy.optionalPyTorch.cosineWingsTensor`
+        Tensor version of this windowing function.
+
+    References
+    ----------
+    [1] NumPy `ndarray`.
+        https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+    [2] NumPy `linspace`.
+        https://numpy.org/doc/stable/reference/generated/numpy.linspace.html
+    [3] NumPy `cos`.
+        https://numpy.org/doc/stable/reference/generated/numpy.cos.html
+
+    """
+    device = device or torch.device(device='cpu')
+    return _convertToTensor(lengthWindow, ratioTaper, callableTarget=cosineWings, device=device)
+
+def equalPowerTensor(lengthWindow: int, ratioTaper: float | None=None, device: Device | None=None) -> torch.Tensor:
+    """Generate an equal-power taper for crossfades.
+
+    This function creates a NumPy array [1] of coefficients that follow a square-root taper at both
+    ends and a flat center. It uses `numpy.linspace` [2] to sample the taper and `numpy.sqrt` [3] to
+    convert it to equal-power scaling. It acts on `lengthWindow` and `ratioTaper` and returns the
+    windowing coefficients.
+
+    Parameters
+    ----------
+    lengthWindow : int
+        Total length of the windowing function.
+    ratioTaper : float | None = None
+        Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+        inclusive.
+    device : Device = torch.device(device='cpu')
+        PyTorch device for `Tensor`.
+
+    Returns
+    -------
+    windowingFunction : WindowingFunction
+        NumPy array of windowing coefficients with tapers.
+
+    See Also
+    --------
+    `hunterHearsPy.optionalPyTorch.equalPowerTensor`
+        Tensor version of this windowing function.
+
+    References
+    ----------
+    [1] NumPy `ndarray`.
+        https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+    [2] NumPy `linspace`.
+        https://numpy.org/doc/stable/reference/generated/numpy.linspace.html
+    [3] NumPy `sqrt`.
+        https://numpy.org/doc/stable/reference/generated/numpy.sqrt.html
+
+    """
+    device = device or torch.device(device='cpu')
+    return _convertToTensor(lengthWindow, ratioTaper, callableTarget=equalPower, device=device)
+
+def halfsineTensor(lengthWindow: int, device: Device | None=None) -> torch.Tensor:
+    """Generate a half-sine windowing function.
+
+    This function creates a NumPy array [1] of coefficients that follow a half-sine profile across
+    the requested length. It uses `numpy.arange` [2] and `numpy.sin` [3] to place the samples. It
+    acts on `lengthWindow` and returns the windowing coefficients.
+
+    Parameters
+    ----------
+    lengthWindow : int
+        Total length of the windowing function.
+    device : Device = torch.device(device='cpu')
+        PyTorch device for `Tensor`.
+
+    Returns
+    -------
+    windowingFunction : WindowingFunction
+        NumPy array of windowing coefficients following a half-sine shape.
+
+    See Also
+    --------
+    `hunterHearsPy.optionalPyTorch.halfsineTensor`
+        Tensor version of this windowing function.
+
+    References
+    ----------
+    [1] NumPy `ndarray`.
+        https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+    [2] NumPy `arange`.
+        https://numpy.org/doc/stable/reference/generated/numpy.arange.html
+    [3] NumPy `sin`.
+        https://numpy.org/doc/stable/reference/generated/numpy.sin.html
+
+    """
+    device = device or torch.device(device='cpu')
+    return _convertToTensor(lengthWindow, callableTarget=halfsine, device=device)
+
+def tukeyTensor(lengthWindow: int, ratioTaper: float | None=None, device: Device | None=None, **keywordArguments: float) -> torch.Tensor:
+    """Generate a Tukey windowing function with optional SciPy keyword overrides.
+
+    This function creates a NumPy array [1] by delegating to SciPy's Tukey window implementation
+    [2]. It accepts `lengthWindow`, `ratioTaper`, and extra keyword arguments, then returns the
+    windowing coefficients.
+
+    Parameters
+    ----------
+    lengthWindow : int
+        Total length of the windowing function.
+    ratioTaper : float | None = None
+        Ratio of taper length to windowing-function length. The value must be between 0 and 1,
+        inclusive.
+    **keywordArguments : float
+        Additional keyword arguments. `alpha` overrides `ratioTaper` when provided, matching SciPy's
+        API.
+    device : Device = torch.device(device='cpu')
+        PyTorch device for `Tensor`.
+
+    Returns
+    -------
+    windowingFunction : WindowingFunction
+        NumPy array of Tukey windowing function coefficients.
+
+    References
+    ----------
+    [1] NumPy `ndarray`.
+        https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html
+    [2] SciPy Tukey window.
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.windows.tukey.html
+
+    """
+    device = device or torch.device(device='cpu')
+    return _convertToTensor(lengthWindow, ratioTaper, callableTarget=tukey, device=device, **keywordArguments)

hunterhearspy-1.0.3.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: hunterHearsPy
+Version: 1.0.3
+Summary: Audio processing.
+Keywords: 
+Author: Hunter Hogan
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License-Expression: CC-BY-NC-4.0
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: huntermakespy>=0.7.0
+Requires-Dist: numpy
+Requires-Dist: resampy
+Requires-Dist: scipy
+Requires-Dist: soundfile>=0.14.0
+Requires-Dist: tqdm
+Requires-Dist: torch ; extra == 'torch'
+Maintainer: Hunter Hogan
+Maintainer-email: Hunter Hogan <HunterHogan@pm.me>
+Requires-Python: >=3.10
+Project-URL: Context7, https://context7.com/hunterhogan/hunterhearspy
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Download, https://pypi.org/project/hunterHearsPy
+Project-URL: Homepage, https://github.com/hunterhogan/hunterHearsPy
+Project-URL: Issues, https://github.com/hunterhogan/hunterHearsPy/issues
+Project-URL: Repository, https://github.com/hunterhogan/hunterHearsPy.git
+Provides-Extra: torch
+Description-Content-Type: text/markdown
+
+# hunterHearsPy
+
+A comprehensive collection of Python utilities for audio processing.
+
+## Audio Processing Made Simple
+
+### Load and Save Audio Files
+
+Read audio files with automatic stereo conversion and sample rate control:
+
+```python
+from hunterHearsPy import readAudioFile, writeWAV
+
+# Load audio with sample rate conversion
+waveform = readAudioFile('input.wav', sampleRate=44100)
+
+# Save in WAV format (always 32-bit float)
+writeWAV('output.wav', waveform)
+```
+
+### Process Multiple Audio Files at Once
+
+Load and process batches of audio files:
+
+```python
+from hunterHearsPy import loadWaveforms
+
+# Load multiple files with consistent formatting
+array_waveforms = loadWaveforms(['file1.wav', 'file2.wav', 'file3.wav'])
+
+# The result is a unified array with shape (channels, samples, file_count)
+```
+
+### Work with Spectrograms
+
+Convert between waveforms and spectrograms:
+
+```python
+from hunterHearsPy import stft, halfsine
+
+# Create a spectrogram with a half-sine window
+spectrogram = stft(waveform, windowingFunction=halfsine(1024))
+
+# Convert back to a waveform
+reconstructed = stft(spectrogram, inverse=True, lengthWaveform=original_length)
+```
+
+### Process Audio in the Frequency Domain
+
+Create functions that operate on spectrograms:
+
+```python
+from hunterHearsPy import waveformSpectrogramWaveform
+
+def boost_low_frequencies(spectrogram):
+    # Boost frequencies below 500 Hz
+    spectrogram[:, :10, :] *= 2.0
+    return spectrogram
+
+# Create a processor that handles the STFT/ISTFT automatically
+processor = waveformSpectrogramWaveform(boost_low_frequencies)
+
+# Apply the processor to a waveform
+processed_waveform = processor(original_waveform)
+```
+
+## Installation
+
+```bash
+pip install hunterHearsPy
+```
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://raw.githubusercontent.com/hunterhogan/hunterHearsPy/refs/heads/main/.github/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

hunterhearspy-1.0.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+hunterHearsPy/__init__.py,sha256=_-lsnc6iLtdDs_l4WmMso25ClM3kWEXO9CbeLJus5eI,2385
+hunterHearsPy/amplitude.py,sha256=1LhJ1Pp-H5aZb_6oTK4EZ-pHgEXLfWxf5MsmhqtD7t4,6497
+hunterHearsPy/autoRevert.py,sha256=pUv_9PDo-Z2w-9HMmZGGbpKSu-z-lnEIiNlxihdDq9U,2529
+hunterHearsPy/clippingArrays.py,sha256=8LkFZQt-cwR-VCzWJK_Bzm5wp9NsH3xiv4ZSxhu72q0,5194
+hunterHearsPy/ioAudio.py,sha256=Sleh4Kf-MNG0Tdq3kGvmUBZt4RMxPaLj0SbTOWb9Ynw,29581
+hunterHearsPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hunterHearsPy/theTypes.py,sha256=L_4lSLFMYuERU5nYXKomd7UrhXbHVwUcB8MCghPyq0s,3722
+hunterHearsPy/windowingFunctions.py,sha256=cu1arlNIu6fkQ2jbauzQl1aWyKkjjNgx3Ssd-9M7_4g,7195
+hunterHearsPy/windowingFunctionsTensor.py,sha256=2A5NVTdeSejKyu9A7p6A0vy79GdsmLDzwDHUUA-qTKw,6563
+hunterhearspy-1.0.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+hunterhearspy-1.0.3.dist-info/WHEEL,sha256=wXwAVsgVaOZ_pwDFqQm5Rd6PID-Fc74nkLc8X8gHiDo,81
+hunterhearspy-1.0.3.dist-info/METADATA,sha256=sdcQlp0eJZ2Q8GHB2NtIpXNsZpSX9mRvj6F_BYztgPo,3546
+hunterhearspy-1.0.3.dist-info/RECORD,,

hunterhearspy-1.0.3.dist-info/WHEEL

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