analyzeAudio 0.0.12__tar.gz → 0.0.14__tar.gz

analyzeaudio-0.0.14/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.2
+Name: analyzeAudio
+Version: 0.0.14
+Summary: Measure one or more aspects of one or more audio files.
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/analyzeAudio
+Project-URL: Repository, https://github.com/hunterhogan/analyzeAudio.git
+Keywords: audio,analysis,measurement,metrics,torch,spectrum,spectral,waveform,loudness,LUFS,RMS,FFmpeg,FFprobe,SRMR,audio-analysis,signal-processing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Other Audience
+Classifier: License :: Free for non-commercial use
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+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
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cachetools
+Requires-Dist: librosa
+Requires-Dist: numpy
+Requires-Dist: optype[numpy]
+Requires-Dist: standard-aifc; python_version >= "3.13"
+Requires-Dist: standard-sunau; python_version >= "3.13"
+Requires-Dist: torch
+Requires-Dist: torchmetrics[audio]
+Requires-Dist: tqdm
+Requires-Dist: Z0Z_tools
+Provides-Extra: testing
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pyupgrade; extra == "testing"
+
+# analyzeAudio
+
+Measure one or more aspects of one or more audio files.
+
+## Note well: FFmpeg & FFprobe binaries must be in PATH
+
+Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
+
+## Some ways to use this package
+
+### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
+
+```python
+from analyzeAudio import analyzeAudioFile
+listAspectNames = ['LUFS integrated',
+                   'RMS peak',
+                   'SRMR mean',
+                   'Spectral Flatness mean']
+listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
+```
+
+### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
+
+The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
+
+```python
+import analyzeAudio
+analyzeAudio.getListAvailableAudioAspects()
+```
+
+### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
+
+### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
+
+```python
+from analyzeAudio import audioAspects
+SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
+```
+
+Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
+
+```python
+from analyzeAudio import audioAspects
+print(audioAspects['Chromagram']['analyzerParameters'])
+```
+
+### Use `whatMeasurements` command line tool to list available measurements
+
+```sh
+(.venv) C:\apps\analyzeAudio>whatMeasurements
+['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'Power spectral density', 'Power spectral density mean', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral centroid mean', 'Spectral crest', 'Spectral crest mean', 'Spectral decrease', 'Spectral decrease mean', 'Spectral entropy', 'Spectral entropy mean', 'Spectral flatness', 'Spectral flatness mean', 'Spectral flux', 'Spectral flux mean', 'Spectral kurtosis', 'Spectral kurtosis mean', 'Spectral rolloff', 'Spectral rolloff mean', 'Spectral skewness', 'Spectral skewness mean', 'Spectral slope', 'Spectral slope mean', 'Spectral spread', 'Spectral spread mean', 'Spectral variance', 'Spectral variance mean', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
+```
+
+## Some clues about the aspects
+
+```python
+'Abs_Peak_count': float
+'Bit_depth': float
+'Chromagram': NDArray[float64] # shape(..., 12, frames)
+'Chromagram mean': float
+'Crest factor': float
+'DC offset': float
+'Duration-samples': float
+'Dynamic range': float
+'Flat_factor': float
+'LUFS high': float
+'LUFS integrated': float
+'LUFS loudness range': float
+'LUFS low': float
+'Max_difference': float
+'Max_level': float
+'Mean_difference': float
+'Min_difference': float
+'Min_level': float
+'Noise_floor_count': float
+'Noise_floor': float
+'Peak dB': float
+'Peak_count': float
+'Power spectral density': NDArray[float64] # shape(channels, frames)
+'Power spectral density mean': float
+'RMS from waveform': NDArray[float64] # shape(..., 1, frames)
+'RMS from waveform mean': float
+'RMS peak': float
+'RMS total': float
+'RMS_difference': float
+'RMS_trough': float
+'SI-SDR mean': float
+'Signal entropy': float
+'Spectral Bandwidth': NDArray[float64] # shape(..., 1, frames)
+'Spectral Bandwidth mean': float
+'Spectral centroid': NDArray[float64] # shape(channels, frames)
+'Spectral centroid mean': float
+'Spectral Centroid': NDArray[float64] # shape(..., 1, frames)
+'Spectral Centroid mean': float
+'Spectral Contrast': NDArray[float64] # shape(..., 7, frames)
+'Spectral Contrast mean': float
+'Spectral crest': NDArray[float64] # shape(channels, frames)
+'Spectral crest mean': float
+'Spectral decrease': NDArray[float64] # shape(channels, frames)
+'Spectral decrease mean': float
+'Spectral entropy': NDArray[float64] # shape(channels, frames)
+'Spectral entropy mean': float
+'Spectral flatness': NDArray[float64] # shape(channels, frames)
+'Spectral flatness mean': float
+'Spectral Flatness': NDArray[float64] # shape(..., 1, frames)
+'Spectral Flatness mean': float
+'Spectral flux': NDArray[float64] # shape(channels, frames)
+'Spectral flux mean': float
+'Spectral kurtosis': NDArray[float64] # shape(channels, frames)
+'Spectral kurtosis mean': float
+'Spectral rolloff': NDArray[float64] # shape(channels, frames)
+'Spectral rolloff mean': float
+'Spectral skewness': NDArray[float64] # shape(channels, frames)
+'Spectral skewness mean': float
+'Spectral slope': NDArray[float64] # shape(channels, frames)
+'Spectral slope mean': float
+'Spectral spread': NDArray[float64] # shape(channels, frames)
+'Spectral spread mean': float
+'Spectral variance': NDArray[float64] # shape(channels, frames)
+'Spectral variance mean': float
+'SRMR': NDArray[float64] # shape(...)
+'SRMR mean': float
+'Tempo': NDArray[float64] # shape(...)
+'Tempo mean': float
+'Tempogram': NDArray[float64] # shape(..., 384, samples)
+'Tempogram mean': float
+'Zero-crossing rate': NDArray[float64] # shape(..., 1, frames)
+'Zero-crossing rate mean': float
+'Zero-crossings rate': float
+```
+
+## Installation
+
+```sh
+pip install analyzeAudio
+```
+
+## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

analyzeaudio-0.0.14/README.md

@@ -0,0 +1,143 @@
+# analyzeAudio
+
+Measure one or more aspects of one or more audio files.
+
+## Note well: FFmpeg & FFprobe binaries must be in PATH
+
+Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
+
+## Some ways to use this package
+
+### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
+
+```python
+from analyzeAudio import analyzeAudioFile
+listAspectNames = ['LUFS integrated',
+                   'RMS peak',
+                   'SRMR mean',
+                   'Spectral Flatness mean']
+listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
+```
+
+### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
+
+The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
+
+```python
+import analyzeAudio
+analyzeAudio.getListAvailableAudioAspects()
+```
+
+### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
+
+### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
+
+```python
+from analyzeAudio import audioAspects
+SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
+```
+
+Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
+
+```python
+from analyzeAudio import audioAspects
+print(audioAspects['Chromagram']['analyzerParameters'])
+```
+
+### Use `whatMeasurements` command line tool to list available measurements
+
+```sh
+(.venv) C:\apps\analyzeAudio>whatMeasurements
+['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'Power spectral density', 'Power spectral density mean', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral centroid mean', 'Spectral crest', 'Spectral crest mean', 'Spectral decrease', 'Spectral decrease mean', 'Spectral entropy', 'Spectral entropy mean', 'Spectral flatness', 'Spectral flatness mean', 'Spectral flux', 'Spectral flux mean', 'Spectral kurtosis', 'Spectral kurtosis mean', 'Spectral rolloff', 'Spectral rolloff mean', 'Spectral skewness', 'Spectral skewness mean', 'Spectral slope', 'Spectral slope mean', 'Spectral spread', 'Spectral spread mean', 'Spectral variance', 'Spectral variance mean', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
+```
+
+## Some clues about the aspects
+
+```python
+'Abs_Peak_count': float
+'Bit_depth': float
+'Chromagram': NDArray[float64] # shape(..., 12, frames)
+'Chromagram mean': float
+'Crest factor': float
+'DC offset': float
+'Duration-samples': float
+'Dynamic range': float
+'Flat_factor': float
+'LUFS high': float
+'LUFS integrated': float
+'LUFS loudness range': float
+'LUFS low': float
+'Max_difference': float
+'Max_level': float
+'Mean_difference': float
+'Min_difference': float
+'Min_level': float
+'Noise_floor_count': float
+'Noise_floor': float
+'Peak dB': float
+'Peak_count': float
+'Power spectral density': NDArray[float64] # shape(channels, frames)
+'Power spectral density mean': float
+'RMS from waveform': NDArray[float64] # shape(..., 1, frames)
+'RMS from waveform mean': float
+'RMS peak': float
+'RMS total': float
+'RMS_difference': float
+'RMS_trough': float
+'SI-SDR mean': float
+'Signal entropy': float
+'Spectral Bandwidth': NDArray[float64] # shape(..., 1, frames)
+'Spectral Bandwidth mean': float
+'Spectral centroid': NDArray[float64] # shape(channels, frames)
+'Spectral centroid mean': float
+'Spectral Centroid': NDArray[float64] # shape(..., 1, frames)
+'Spectral Centroid mean': float
+'Spectral Contrast': NDArray[float64] # shape(..., 7, frames)
+'Spectral Contrast mean': float
+'Spectral crest': NDArray[float64] # shape(channels, frames)
+'Spectral crest mean': float
+'Spectral decrease': NDArray[float64] # shape(channels, frames)
+'Spectral decrease mean': float
+'Spectral entropy': NDArray[float64] # shape(channels, frames)
+'Spectral entropy mean': float
+'Spectral flatness': NDArray[float64] # shape(channels, frames)
+'Spectral flatness mean': float
+'Spectral Flatness': NDArray[float64] # shape(..., 1, frames)
+'Spectral Flatness mean': float
+'Spectral flux': NDArray[float64] # shape(channels, frames)
+'Spectral flux mean': float
+'Spectral kurtosis': NDArray[float64] # shape(channels, frames)
+'Spectral kurtosis mean': float
+'Spectral rolloff': NDArray[float64] # shape(channels, frames)
+'Spectral rolloff mean': float
+'Spectral skewness': NDArray[float64] # shape(channels, frames)
+'Spectral skewness mean': float
+'Spectral slope': NDArray[float64] # shape(channels, frames)
+'Spectral slope mean': float
+'Spectral spread': NDArray[float64] # shape(channels, frames)
+'Spectral spread mean': float
+'Spectral variance': NDArray[float64] # shape(channels, frames)
+'Spectral variance mean': float
+'SRMR': NDArray[float64] # shape(...)
+'SRMR mean': float
+'Tempo': NDArray[float64] # shape(...)
+'Tempo mean': float
+'Tempogram': NDArray[float64] # shape(..., 384, samples)
+'Tempogram mean': float
+'Zero-crossing rate': NDArray[float64] # shape(..., 1, frames)
+'Zero-crossing rate mean': float
+'Zero-crossings rate': float
+```
+
+## Installation
+
+```sh
+pip install analyzeAudio
+```
+
+## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{analyzeaudio-0.0.12 → analyzeaudio-0.0.14}/analyzeAudio/analyzersUseFilename.py

@@ -40,7 +40,7 @@ def getSI_SDRmean(pathFilenameAlpha: str | PathLike[Any], pathFilenameBeta: str
 	return SI_SDRmean
 
 @cachetools.cached(cache=cacheAudioAnalyzers)
-def ffprobeShotgunAndCache(pathFilename: str | PathLike[Any]) -> dict[str, float]:
+def ffprobeShotgunAndCache(pathFilename: str | PathLike[Any]) -> dict[str, float | numpy.ndarray]:
 	# for lavfi amovie/movie, the colons after driveLetter letters need to be escaped twice.
 	pFn = pathlib.PureWindowsPath(pathFilename)
 	lavfiPathFilename = pFn.drive.replace(":", "\\\\:")+pathlib.PureWindowsPath(pFn.root,pFn.relative_to(pFn.anchor)).as_posix()
@@ -63,16 +63,20 @@ def ffprobeShotgunAndCache(pathFilename: str | PathLike[Any]) -> dict[str, float
 	stdoutFFprobe, _DISCARDstderr = systemProcessFFprobe.communicate()
 	FFprobeStructured = pythonizeFFprobe(stdoutFFprobe.decode('utf-8'))[-1]
 
-	dictionaryAspectsAnalyzed: dict[str, float] = {}
+	dictionaryAspectsAnalyzed: dict[str, float | numpy.ndarray] = {}
 	if 'aspectralstats' in FFprobeStructured:
 		for keyName in FFprobeStructured['aspectralstats']:
-			dictionaryAspectsAnalyzed[keyName] = numpy.mean(FFprobeStructured['aspectralstats'][keyName]).astype(float)
+			# No matter how many channels, each keyName is `numpy.ndarray[tuple[int, int], numpy.dtype[numpy.float64]]`
+			# where `tuple[int, int]` is (channel, frame)
+			# NOTE (as of this writing) `registrar` can only understand the generic class `numpy.ndarray` and not more specific typing
+			dictionaryAspectsAnalyzed[keyName] = FFprobeStructured['aspectralstats'][keyName]
+			# dictionaryAspectsAnalyzed[keyName] = numpy.mean(FFprobeStructured['aspectralstats'][keyName]).astype(float)
 	if 'r128' in FFprobeStructured:
 		for keyName in FFprobeStructured['r128']:
 			dictionaryAspectsAnalyzed[keyName] = FFprobeStructured['r128'][keyName][-1]
 	if 'astats' in FFprobeStructured:
 		for keyName, arrayFeatureValues in cast(dict[str, numpy.ndarray[Any, Any]], FFprobeStructured['astats']).items():
-			dictionaryAspectsAnalyzed[keyName.split('.')[-1]] = numpy.mean(arrayFeatureValues[..., -1:]).astype(float)
+			dictionaryAspectsAnalyzed[keyName.split('.')[-1]] = numpy.mean(arrayFeatureValues[..., -1:None]).astype(float)
 
 	return dictionaryAspectsAnalyzed
 
@@ -128,56 +132,56 @@ def analyzeLUFSlow(pathFilename: str | PathLike[Any]) -> float | None:
 def analyzeLUFShigh(pathFilename: str | PathLike[Any]) -> float | None:
 	return ffprobeShotgunAndCache(pathFilename).get('LRA.high')
 
-@registrationAudioAspect('Spectral mean')
-def analyzeMean(pathFilename: str | PathLike[Any]) -> float | None:
+@registrationAudioAspect('Power spectral density')
+def analyzeMean(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('mean')
 
 @registrationAudioAspect('Spectral variance')
-def analyzeVariance(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeVariance(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('variance')
 
 @registrationAudioAspect('Spectral centroid')
-def analyzeCentroid(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeCentroid(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('centroid')
 
 @registrationAudioAspect('Spectral spread')
-def analyzeSpread(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeSpread(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('spread')
 
 @registrationAudioAspect('Spectral skewness')
-def analyzeSkewness(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeSkewness(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('skewness')
 
 @registrationAudioAspect('Spectral kurtosis')
-def analyzeKurtosis(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeKurtosis(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('kurtosis')
 
 @registrationAudioAspect('Spectral entropy')
-def analyzeSpectralEntropy(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeSpectralEntropy(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('entropy')
 
 @registrationAudioAspect('Spectral flatness')
-def analyzeFlatness(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeFlatness(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('flatness')
 
 @registrationAudioAspect('Spectral crest')
-def analyzeCrest(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeCrest(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('crest')
 
 @registrationAudioAspect('Spectral flux')
-def analyzeFlux(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeFlux(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('flux')
 
 @registrationAudioAspect('Spectral slope')
-def analyzeSlope(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeSlope(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('slope')
 
 @registrationAudioAspect('Spectral decrease')
-def analyzeDecrease(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeDecrease(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('decrease')
 
 @registrationAudioAspect('Spectral rolloff')
-def analyzeRolloff(pathFilename: str | PathLike[Any]) -> float | None:
+def analyzeRolloff(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
 	return ffprobeShotgunAndCache(pathFilename).get('rolloff')
 
 @registrationAudioAspect('Abs_Peak_count')

{analyzeaudio-0.0.12 → analyzeaudio-0.0.14}/analyzeAudio/pythonator.py

@@ -1,8 +1,20 @@
 from collections import defaultdict
-from typing import Any
+from typing import Any, cast, NamedTuple
 import json
 import numpy
 
+# NOTE hey! hey! hey!
+# Is blackdetect broken?
+# 1. You don't have pytest tests for anything in the entire fricken package
+# 2. You tried to improve the blackdetect code, but you didn't test it with anything
+# 3. Search for "uncommentToFixBlackdetect"
+# NOTE You changed the code because a static type checker was mad at you. Ask yourself,
+# "Are you the tool or is the type checker the tool?"
+
+class Blackdetect(NamedTuple):
+	black_start: float | None = None
+	black_end: float | None = None
+
 def pythonizeFFprobe(FFprobeJSON_utf8: str):
 	FFroot: dict[str, Any] = json.loads(FFprobeJSON_utf8)
 	Z0Z_dictionaries: dict[str, numpy.ndarray[Any, Any] | dict[str, numpy.ndarray[Any, Any]]] = {}
@@ -25,14 +37,24 @@ def pythonizeFFprobe(FFprobeJSON_utf8: str):
 	leftCrumbs = False
 	if 'frames' in FFroot:
 		leftCrumbs = False
-		listTuplesBlackdetect: list[float | tuple[float]] = []
+		# listTuplesBlackdetect = [] # uncommentToFixBlackdetect
+		listTuplesBlackdetect: list[Blackdetect] = []
 		for indexFrame, FFframe in enumerate(FFroot['frames']):
 			if 'tags' in FFframe:
 				if 'lavfi.black_start' in FFframe['tags']:
-					listTuplesBlackdetect.append(float(FFframe['tags']['lavfi.black_start']))
+					# listTuplesBlackdetect.append(float(FFframe['tags']['lavfi.black_start'])) # uncommentToFixBlackdetect
+					listTuplesBlackdetect.append(Blackdetect(black_start=float(FFframe['tags']['lavfi.black_start'])))
 					del FFframe['tags']['lavfi.black_start']
 				if 'lavfi.black_end' in FFframe['tags']:
-					listTuplesBlackdetect[-1] = (listTuplesBlackdetect[-1], float(FFframe['tags']['lavfi.black_end']))
+					# listTuplesBlackdetect[-1] = (listTuplesBlackdetect[-1], float(FFframe['tags']['lavfi.black_end'])) # uncommentToFixBlackdetect
+					tupleBlackdetectLast = listTuplesBlackdetect.pop() if listTuplesBlackdetect else Blackdetect()
+					match tupleBlackdetectLast.black_end:
+						case None:
+							listTuplesBlackdetect.append(Blackdetect(tupleBlackdetectLast.black_start, float(FFframe['tags']['lavfi.black_end'])))
+						case _:
+							if tupleBlackdetectLast.black_start is not None:
+								listTuplesBlackdetect.append(tupleBlackdetectLast)
+							listTuplesBlackdetect.append(Blackdetect(black_end=(float(FFframe['tags']['lavfi.black_end']))))
 					del FFframe['tags']['lavfi.black_end']
 
 				# This is not the way to do it
@@ -66,12 +88,15 @@ def pythonizeFFprobe(FFprobeJSON_utf8: str):
 										if registrant not in Z0Z_dictionaries:
 											Z0Z_dictionaries[registrant] = {}
 										elif statistic not in Z0Z_dictionaries[registrant]:
-												Z0Z_dictionaries[registrant][statistic] = numpy.zeros((channel, len(FFroot['frames'])))
+												# NOTE (as of this writing) `registrar` can only understand the generic class `numpy.ndarray` and not more specific typing
+												valueSherpa = cast(numpy.ndarray, numpy.zeros((channel, len(FFroot['frames']))))
+												Z0Z_dictionaries[registrant][statistic] = valueSherpa
 										else:
 											raise  # Re-raise the exception
 									except IndexError:
 										if channel > Z0Z_dictionaries[registrant][statistic].shape[0]:
-											Z0Z_dictionaries[registrant][statistic].resize((channel, len(FFroot['frames'])))
+											Z0Z_dictionaries[registrant][statistic] = numpy.resize(Z0Z_dictionaries[registrant][statistic], (channel, len(FFroot['frames'])))
+											# Z0Z_dictionaries[registrant][statistic].resize((channel, len(FFroot['frames'])))
 										else:
 											raise  # Re-raise the exception
 
@@ -80,7 +105,17 @@ def pythonizeFFprobe(FFprobeJSON_utf8: str):
 			if FFframe:
 				leftCrumbs = True
 		if listTuplesBlackdetect:
-			Z0Z_dictionaries['blackdetect'] = numpy.array(listTuplesBlackdetect, dtype=[('black_start', numpy.float32), ('black_end', numpy.float32)], copy=False)
+			# 2025-03-06: I am _shocked_ that I was able to create a numpy structured array whenever it was that I originally wrote this code.
+			arrayBlackdetect = numpy.array(
+				[(
+					-1.0 if detect.black_start is None else detect.black_start,
+					-1.0 if detect.black_end is None else detect.black_end
+				) for detect in listTuplesBlackdetect],
+				dtype=[('black_start', numpy.float64), ('black_end', numpy.float64)],
+				copy=False
+			)
+			Z0Z_dictionaries['blackdetect'] = arrayBlackdetect
+			# Z0Z_dictionaries['blackdetect'] = numpy.array(listTuplesBlackdetect, dtype=[('black_start', numpy.float32), ('black_end', numpy.float32)], copy=False) # uncommentToFixBlackdetect
 	if not leftCrumbs:
 		del FFroot['frames']
 	return FFroot, Z0Z_dictionaries

analyzeaudio-0.0.14/analyzeAudio.egg-info/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.2
+Name: analyzeAudio
+Version: 0.0.14
+Summary: Measure one or more aspects of one or more audio files.
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/analyzeAudio
+Project-URL: Repository, https://github.com/hunterhogan/analyzeAudio.git
+Keywords: audio,analysis,measurement,metrics,torch,spectrum,spectral,waveform,loudness,LUFS,RMS,FFmpeg,FFprobe,SRMR,audio-analysis,signal-processing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Other Audience
+Classifier: License :: Free for non-commercial use
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+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
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Classifier: Topic :: Multimedia :: Sound/Audio :: Conversion
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cachetools
+Requires-Dist: librosa
+Requires-Dist: numpy
+Requires-Dist: optype[numpy]
+Requires-Dist: standard-aifc; python_version >= "3.13"
+Requires-Dist: standard-sunau; python_version >= "3.13"
+Requires-Dist: torch
+Requires-Dist: torchmetrics[audio]
+Requires-Dist: tqdm
+Requires-Dist: Z0Z_tools
+Provides-Extra: testing
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pyupgrade; extra == "testing"
+
+# analyzeAudio
+
+Measure one or more aspects of one or more audio files.
+
+## Note well: FFmpeg & FFprobe binaries must be in PATH
+
+Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
+
+## Some ways to use this package
+
+### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
+
+```python
+from analyzeAudio import analyzeAudioFile
+listAspectNames = ['LUFS integrated',
+                   'RMS peak',
+                   'SRMR mean',
+                   'Spectral Flatness mean']
+listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
+```
+
+### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
+
+The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
+
+```python
+import analyzeAudio
+analyzeAudio.getListAvailableAudioAspects()
+```
+
+### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
+
+### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
+
+```python
+from analyzeAudio import audioAspects
+SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
+```
+
+Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
+
+```python
+from analyzeAudio import audioAspects
+print(audioAspects['Chromagram']['analyzerParameters'])
+```
+
+### Use `whatMeasurements` command line tool to list available measurements
+
+```sh
+(.venv) C:\apps\analyzeAudio>whatMeasurements
+['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'Power spectral density', 'Power spectral density mean', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral centroid mean', 'Spectral crest', 'Spectral crest mean', 'Spectral decrease', 'Spectral decrease mean', 'Spectral entropy', 'Spectral entropy mean', 'Spectral flatness', 'Spectral flatness mean', 'Spectral flux', 'Spectral flux mean', 'Spectral kurtosis', 'Spectral kurtosis mean', 'Spectral rolloff', 'Spectral rolloff mean', 'Spectral skewness', 'Spectral skewness mean', 'Spectral slope', 'Spectral slope mean', 'Spectral spread', 'Spectral spread mean', 'Spectral variance', 'Spectral variance mean', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
+```
+
+## Some clues about the aspects
+
+```python
+'Abs_Peak_count': float
+'Bit_depth': float
+'Chromagram': NDArray[float64] # shape(..., 12, frames)
+'Chromagram mean': float
+'Crest factor': float
+'DC offset': float
+'Duration-samples': float
+'Dynamic range': float
+'Flat_factor': float
+'LUFS high': float
+'LUFS integrated': float
+'LUFS loudness range': float
+'LUFS low': float
+'Max_difference': float
+'Max_level': float
+'Mean_difference': float
+'Min_difference': float
+'Min_level': float
+'Noise_floor_count': float
+'Noise_floor': float
+'Peak dB': float
+'Peak_count': float
+'Power spectral density': NDArray[float64] # shape(channels, frames)
+'Power spectral density mean': float
+'RMS from waveform': NDArray[float64] # shape(..., 1, frames)
+'RMS from waveform mean': float
+'RMS peak': float
+'RMS total': float
+'RMS_difference': float
+'RMS_trough': float
+'SI-SDR mean': float
+'Signal entropy': float
+'Spectral Bandwidth': NDArray[float64] # shape(..., 1, frames)
+'Spectral Bandwidth mean': float
+'Spectral centroid': NDArray[float64] # shape(channels, frames)
+'Spectral centroid mean': float
+'Spectral Centroid': NDArray[float64] # shape(..., 1, frames)
+'Spectral Centroid mean': float
+'Spectral Contrast': NDArray[float64] # shape(..., 7, frames)
+'Spectral Contrast mean': float
+'Spectral crest': NDArray[float64] # shape(channels, frames)
+'Spectral crest mean': float
+'Spectral decrease': NDArray[float64] # shape(channels, frames)
+'Spectral decrease mean': float
+'Spectral entropy': NDArray[float64] # shape(channels, frames)
+'Spectral entropy mean': float
+'Spectral flatness': NDArray[float64] # shape(channels, frames)
+'Spectral flatness mean': float
+'Spectral Flatness': NDArray[float64] # shape(..., 1, frames)
+'Spectral Flatness mean': float
+'Spectral flux': NDArray[float64] # shape(channels, frames)
+'Spectral flux mean': float
+'Spectral kurtosis': NDArray[float64] # shape(channels, frames)
+'Spectral kurtosis mean': float
+'Spectral rolloff': NDArray[float64] # shape(channels, frames)
+'Spectral rolloff mean': float
+'Spectral skewness': NDArray[float64] # shape(channels, frames)
+'Spectral skewness mean': float
+'Spectral slope': NDArray[float64] # shape(channels, frames)
+'Spectral slope mean': float
+'Spectral spread': NDArray[float64] # shape(channels, frames)
+'Spectral spread mean': float
+'Spectral variance': NDArray[float64] # shape(channels, frames)
+'Spectral variance mean': float
+'SRMR': NDArray[float64] # shape(...)
+'SRMR mean': float
+'Tempo': NDArray[float64] # shape(...)
+'Tempo mean': float
+'Tempogram': NDArray[float64] # shape(..., 384, samples)
+'Tempogram mean': float
+'Zero-crossing rate': NDArray[float64] # shape(..., 1, frames)
+'Zero-crossing rate mean': float
+'Zero-crossings rate': float
+```
+
+## Installation
+
+```sh
+pip install analyzeAudio
+```
+
+## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{analyzeaudio-0.0.12 → analyzeaudio-0.0.14}/analyzeAudio.egg-info/requires.txt

@@ -7,6 +7,10 @@ torchmetrics[audio]
 tqdm
 Z0Z_tools
 
+[:python_version >= "3.13"]
+standard-aifc
+standard-sunau
+
 [testing]
 pytest-cov
 pytest-xdist

{analyzeaudio-0.0.12 → analyzeaudio-0.0.14}/pyproject.toml

@@ -9,35 +9,48 @@ classifiers = [
     "Environment :: Console",
     "Intended Audience :: Developers",
     "Intended Audience :: End Users/Desktop",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Information Technology",
     "Intended Audience :: Other Audience",
+    "License :: Free for non-commercial use",
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python",
-	"Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Sound/Audio",
     "Topic :: Multimedia :: Sound/Audio :: Analysis",
+    "Topic :: Multimedia :: Sound/Audio :: Conversion",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Software Development :: Libraries :: Python Modules",
     "Typing :: Typed",]
 dependencies = [
     "cachetools",
     "librosa",
     "numpy",
     "optype[numpy]",
+    "standard-aifc;python_version>='3.13'",
+    "standard-sunau;python_version>='3.13'",
     "torch",
     "torchmetrics[audio]",
     "tqdm",
     "Z0Z_tools",]
 description = "Measure one or more aspects of one or more audio files."
-keywords = ["audio", "analysis", "measurement", "metrics", "torch"]
+keywords = ["audio", "analysis", "measurement", "metrics", "torch", "spectrum", "spectral", "waveform", "loudness", "LUFS", "RMS", "FFmpeg", "FFprobe", "SRMR", "audio-analysis", "signal-processing"]
 license = { 'text' = "CC-BY-NC-4.0" }
 name = "analyzeAudio"
 optional-dependencies = { testing = [
     "pytest-cov",
     "pytest-xdist",
     "pytest",
-	"pyupgrade",] }
+    "pyupgrade",] }
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"
 urls = { Donate = "https://www.patreon.com/integrated", Homepage = "https://github.com/hunterhogan/analyzeAudio", Repository = "https://github.com/hunterhogan/analyzeAudio.git"  }
-version = "0.0.12"
+version = "0.0.14"
 
 [project.scripts]
 whatMeasurements = "analyzeAudio.audioAspectsRegistry:getListAvailableAudioAspects"

analyzeaudio-0.0.12/PKG-INFO

@@ -1,103 +0,0 @@
-Metadata-Version: 2.2
-Name: analyzeAudio
-Version: 0.0.12
-Summary: Measure one or more aspects of one or more audio files.
-Author-email: Hunter Hogan <HunterHogan@pm.me>
-License: CC-BY-NC-4.0
-Project-URL: Donate, https://www.patreon.com/integrated
-Project-URL: Homepage, https://github.com/hunterhogan/analyzeAudio
-Project-URL: Repository, https://github.com/hunterhogan/analyzeAudio.git
-Keywords: audio,analysis,measurement,metrics,torch
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Other Audience
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cachetools
-Requires-Dist: librosa
-Requires-Dist: numpy
-Requires-Dist: optype[numpy]
-Requires-Dist: torch
-Requires-Dist: torchmetrics[audio]
-Requires-Dist: tqdm
-Requires-Dist: Z0Z_tools
-Provides-Extra: testing
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-
-# analyzeAudio
-
-Measure one or more aspects of one or more audio files.
-
-## Note well: FFmpeg & FFprobe binaries must be in PATH
-
-Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
-
-## Some ways to use this package
-
-### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
-
-```python
-from analyzeAudio import analyzeAudioFile
-listAspectNames = ['LUFS integrated',
-                   'RMS peak',
-                   'SRMR mean',
-                   'Spectral Flatness mean']
-listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
-```
-
-### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
-
-The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
-
-```python
-import analyzeAudio
-analyzeAudio.getListAvailableAudioAspects()
-```
-
-### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
-
-### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
-
-```python
-from analyzeAudio import audioAspects
-SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
-```
-
-Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
-
-```python
-from analyzeAudio import audioAspects
-print(audioAspects['Chromagram']['analyzerParameters'])
-```
-
-### Use `whatMeasurements` command line tool to list available measurements
-
-```sh
-(.venv) C:\apps\analyzeAudio> whatMeasurements
-['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral crest', 'Spectral decrease', 'Spectral entropy', 'Spectral flatness', 'Spectral flux', 'Spectral kurtosis', 'Spectral mean', 'Spectral rolloff', 'Spectral skewness', 'Spectral slope', 'Spectral spread', 'Spectral variance', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
-```
-
-## Installation
-
-```sh
-pip install analyzeAudio
-```
-
-## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

analyzeaudio-0.0.12/README.md

@@ -1,65 +0,0 @@
-# analyzeAudio
-
-Measure one or more aspects of one or more audio files.
-
-## Note well: FFmpeg & FFprobe binaries must be in PATH
-
-Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
-
-## Some ways to use this package
-
-### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
-
-```python
-from analyzeAudio import analyzeAudioFile
-listAspectNames = ['LUFS integrated',
-                   'RMS peak',
-                   'SRMR mean',
-                   'Spectral Flatness mean']
-listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
-```
-
-### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
-
-The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
-
-```python
-import analyzeAudio
-analyzeAudio.getListAvailableAudioAspects()
-```
-
-### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
-
-### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
-
-```python
-from analyzeAudio import audioAspects
-SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
-```
-
-Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
-
-```python
-from analyzeAudio import audioAspects
-print(audioAspects['Chromagram']['analyzerParameters'])
-```
-
-### Use `whatMeasurements` command line tool to list available measurements
-
-```sh
-(.venv) C:\apps\analyzeAudio> whatMeasurements
-['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral crest', 'Spectral decrease', 'Spectral entropy', 'Spectral flatness', 'Spectral flux', 'Spectral kurtosis', 'Spectral mean', 'Spectral rolloff', 'Spectral skewness', 'Spectral slope', 'Spectral spread', 'Spectral variance', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
-```
-
-## Installation
-
-```sh
-pip install analyzeAudio
-```
-
-## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

analyzeaudio-0.0.12/analyzeAudio.egg-info/PKG-INFO

@@ -1,103 +0,0 @@
-Metadata-Version: 2.2
-Name: analyzeAudio
-Version: 0.0.12
-Summary: Measure one or more aspects of one or more audio files.
-Author-email: Hunter Hogan <HunterHogan@pm.me>
-License: CC-BY-NC-4.0
-Project-URL: Donate, https://www.patreon.com/integrated
-Project-URL: Homepage, https://github.com/hunterhogan/analyzeAudio
-Project-URL: Repository, https://github.com/hunterhogan/analyzeAudio.git
-Keywords: audio,analysis,measurement,metrics,torch
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Other Audience
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cachetools
-Requires-Dist: librosa
-Requires-Dist: numpy
-Requires-Dist: optype[numpy]
-Requires-Dist: torch
-Requires-Dist: torchmetrics[audio]
-Requires-Dist: tqdm
-Requires-Dist: Z0Z_tools
-Provides-Extra: testing
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-
-# analyzeAudio
-
-Measure one or more aspects of one or more audio files.
-
-## Note well: FFmpeg & FFprobe binaries must be in PATH
-
-Some options to [download FFmpeg and FFprobe](https://www.ffmpeg.org/download.html) at ffmpeg.org.
-
-## Some ways to use this package
-
-### Use `analyzeAudioFile` to measure one or more aspects of a single audio file
-
-```python
-from analyzeAudio import analyzeAudioFile
-listAspectNames = ['LUFS integrated',
-                   'RMS peak',
-                   'SRMR mean',
-                   'Spectral Flatness mean']
-listMeasurements = analyzeAudioFile(pathFilename, listAspectNames)
-```
-
-### Use `getListAvailableAudioAspects` to get a crude list of aspects this package can measure
-
-The aspect names are accurate, but the lack of additional documentation can make things challenging. 'Zero-crossing rate', 'Zero-crossing rate mean', and 'Zero-crossings rate', for example, are different from each other. ("... lack of additional documentation ...")
-
-```python
-import analyzeAudio
-analyzeAudio.getListAvailableAudioAspects()
-```
-
-### Use `analyzeAudioListPathFilenames` to measure one or more aspects of individual file in a list of audio files
-
-### Use `audioAspects` to call an analyzer function by using the name of the aspect you wish to measure
-
-```python
-from analyzeAudio import audioAspects
-SI_SDR_channelsMean = audioAspects['SI-SDR mean']['analyzer'](pathFilenameAudioFile, pathFilenameDifferentAudioFile)
-```
-
-Retrieve the names of the parameters for an analyzer function with the `['analyzerParameters']` key-name.
-
-```python
-from analyzeAudio import audioAspects
-print(audioAspects['Chromagram']['analyzerParameters'])
-```
-
-### Use `whatMeasurements` command line tool to list available measurements
-
-```sh
-(.venv) C:\apps\analyzeAudio> whatMeasurements
-['Abs_Peak_count', 'Bit_depth', 'Chromagram', 'Chromagram mean', 'Crest factor', 'DC offset', 'Duration-samples', 'Dynamic range', 'Flat_factor', 'LUFS high', 'LUFS integrated', 'LUFS loudness range', 'LUFS low', 'Max_difference', 'Max_level', 'Mean_difference', 'Min_difference', 'Min_level', 'Noise_floor', 'Noise_floor_count', 'Peak dB', 'Peak_count', 'RMS from waveform', 'RMS from waveform mean', 'RMS peak', 'RMS total', 'RMS_difference', 'RMS_trough', 'SI-SDR mean', 'SRMR', 'SRMR mean', 'Signal entropy', 'Spectral Bandwidth', 'Spectral Bandwidth mean', 'Spectral Centroid', 'Spectral Centroid mean', 'Spectral Contrast', 'Spectral Contrast mean', 'Spectral Flatness', 'Spectral Flatness mean', 'Spectral centroid', 'Spectral crest', 'Spectral decrease', 'Spectral entropy', 'Spectral flatness', 'Spectral flux', 'Spectral kurtosis', 'Spectral mean', 'Spectral rolloff', 'Spectral skewness', 'Spectral slope', 'Spectral spread', 'Spectral variance', 'Tempo', 'Tempo mean', 'Tempogram', 'Tempogram mean', 'Zero-crossing rate', 'Zero-crossing rate mean', 'Zero-crossings rate']
-```
-
-## Installation
-
-```sh
-pip install analyzeAudio
-```
-
-## 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://github.com/hunterhogan/analyzeAudio/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)