analyzeAudio 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

analyzeAudio/__init__.py

@@ -1,11 +1,11 @@
 from .audioAspectsRegistry import registrationAudioAspect, cacheAudioAnalyzers, analyzeAudioFile, \
-    analyzeAudioListPathFilenames, getListAvailableAudioAspects, audioAspects
+	analyzeAudioListPathFilenames, getListAvailableAudioAspects, audioAspects
 
 __all__ = [
-    'analyzeAudioFile',
-    'analyzeAudioListPathFilenames',
-    'audioAspects',
-    'getListAvailableAudioAspects',
+	'analyzeAudioFile',
+	'analyzeAudioListPathFilenames',
+	'audioAspects',
+	'getListAvailableAudioAspects',
 ]
 
 from . import analyzersUseFilename

analyzeAudio/analyzersUseFilename.py

@@ -1,234 +1,238 @@
 from .pythonator import pythonizeFFprobe
 from analyzeAudio import registrationAudioAspect, cacheAudioAnalyzers
+from os import PathLike
 from statistics import mean
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, cast
 import cachetools
 import numpy
-import os
 import pathlib
 import re as regex
 import subprocess
 
 @registrationAudioAspect('SI-SDR mean')
-def getSI_SDRmean(pathFilenameAlpha: Union[str, os.PathLike[Any]], pathFilenameBeta: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    """
-    Calculate the mean Scale-Invariant Signal-to-Distortion Ratio (SI-SDR) between two audio files.
-    This function uses FFmpeg to compute the SI-SDR between two audio files specified by their paths.
-    The SI-SDR values are extracted from the FFmpeg output and their mean is calculated.
-    Parameters:
-        pathFilenameAlpha: Path to the first audio file.
-        pathFilenameBeta: Path to the second audio file.
-    Returns:
-        SI_SDRmean: The mean SI-SDR value in decibels (dB).
-    Raises:
-        subprocess.CalledProcessError: If the FFmpeg command fails.
-        ValueError: If no SI-SDR values are found in the FFmpeg output.
-    """
-    commandLineFFmpeg = [
-        'ffmpeg', '-hide_banner', '-loglevel', '32',
-        '-i', f'{str(pathlib.Path(pathFilenameAlpha))}', '-i', f'{str(pathlib.Path(pathFilenameBeta))}',
-        '-filter_complex', '[0][1]asisdr', '-f', 'null', '-'
-    ]
-    systemProcessFFmpeg = subprocess.run(commandLineFFmpeg, check=True, stderr=subprocess.PIPE)
-
-    stderrFFmpeg = systemProcessFFmpeg.stderr.decode()
-
-    regexSI_SDR = regex.compile(r"^\[Parsed_asisdr_.* (.*) dB", regex.MULTILINE)
-
-    listMatchesSI_SDR = regexSI_SDR.findall(stderrFFmpeg)
-    SI_SDRmean = mean(float(match) for match in listMatchesSI_SDR)
-    return SI_SDRmean
+def getSI_SDRmean(pathFilenameAlpha: str | PathLike[Any], pathFilenameBeta: str | PathLike[Any]) -> float | None:
+	"""
+	Calculate the mean Scale-Invariant Signal-to-Distortion Ratio (SI-SDR) between two audio files.
+	This function uses FFmpeg to compute the SI-SDR between two audio files specified by their paths.
+	The SI-SDR values are extracted from the FFmpeg output and their mean is calculated.
+	Parameters:
+		pathFilenameAlpha: Path to the first audio file.
+		pathFilenameBeta: Path to the second audio file.
+	Returns:
+		SI_SDRmean: The mean SI-SDR value in decibels (dB).
+	Raises:
+		subprocess.CalledProcessError: If the FFmpeg command fails.
+		ValueError: If no SI-SDR values are found in the FFmpeg output.
+	"""
+	commandLineFFmpeg = [
+		'ffmpeg', '-hide_banner', '-loglevel', '32',
+		'-i', f'{str(pathlib.Path(pathFilenameAlpha))}', '-i', f'{str(pathlib.Path(pathFilenameBeta))}',
+		'-filter_complex', '[0][1]asisdr', '-f', 'null', '-'
+	]
+	systemProcessFFmpeg = subprocess.run(commandLineFFmpeg, check=True, stderr=subprocess.PIPE)
+
+	stderrFFmpeg = systemProcessFFmpeg.stderr.decode()
+
+	regexSI_SDR = regex.compile(r"^\[Parsed_asisdr_.* (.*) dB", regex.MULTILINE)
+
+	listMatchesSI_SDR = regexSI_SDR.findall(stderrFFmpeg)
+	SI_SDRmean = mean(float(match) for match in listMatchesSI_SDR)
+	return SI_SDRmean
 
 @cachetools.cached(cache=cacheAudioAnalyzers)
-def ffprobeShotgunAndCache(pathFilename: Union[str, os.PathLike[Any]]) -> Dict[str, float]:
-    # 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()
-
-    filterChain: List[str] = []
-    filterChain += ["astats=metadata=1:measure_perchannel=Crest_factor+Zero_crossings_rate+Dynamic_range:measure_overall=all"]
-    filterChain += ["aspectralstats"]
-    filterChain += ["ebur128=metadata=1:framelog=quiet"]
-
-    entriesFFprobe = ["frame_tags"]
-
-    commandLineFFprobe = [
-        "ffprobe", "-hide_banner",
-        "-f", "lavfi", f"amovie={lavfiPathFilename},{','.join(filterChain)}",
-        "-show_entries", ':'.join(entriesFFprobe),
-        "-output_format", "json=compact=1",
-    ]
-
-    systemProcessFFprobe = subprocess.Popen(commandLineFFprobe, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    stdoutFFprobe, DISCARDstderr = systemProcessFFprobe.communicate()
-    FFprobeStructured = pythonizeFFprobe(stdoutFFprobe.decode('utf-8'))[-1]
-
-    dictionaryAspectsAnalyzed = {}
-    if 'aspectralstats' in FFprobeStructured:
-        for keyName in FFprobeStructured['aspectralstats']:
-            dictionaryAspectsAnalyzed[keyName] = numpy.mean(FFprobeStructured['aspectralstats'][keyName])
-    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, FFprobeStructured['astats']).items():
-            dictionaryAspectsAnalyzed[keyName.split('.')[-1]] = numpy.mean(arrayFeatureValues[..., -1:])
-
-    return dictionaryAspectsAnalyzed
+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()
+
+	filterChain: list[str] = []
+	filterChain += ["astats=metadata=1:measure_perchannel=Crest_factor+Zero_crossings_rate+Dynamic_range:measure_overall=all"]
+	filterChain += ["aspectralstats"]
+	filterChain += ["ebur128=metadata=1:framelog=quiet"]
+
+	entriesFFprobe = ["frame_tags"]
+
+	commandLineFFprobe = [
+		"ffprobe", "-hide_banner",
+		"-f", "lavfi", f"amovie={lavfiPathFilename},{','.join(filterChain)}",
+		"-show_entries", ':'.join(entriesFFprobe),
+		"-output_format", "json=compact=1",
+	]
+
+	systemProcessFFprobe = subprocess.Popen(commandLineFFprobe, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+	stdoutFFprobe, _DISCARDstderr = systemProcessFFprobe.communicate()
+	FFprobeStructured = pythonizeFFprobe(stdoutFFprobe.decode('utf-8'))[-1]
+
+	dictionaryAspectsAnalyzed: dict[str, float | numpy.ndarray] = {}
+	if 'aspectralstats' in FFprobeStructured:
+		for keyName in FFprobeStructured['aspectralstats']:
+			# 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:None]).astype(float)
+
+	return dictionaryAspectsAnalyzed
 
 @registrationAudioAspect('Zero-crossings rate')
-def analyzeZero_crossings_rate(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Zero_crossings_rate')
+def analyzeZero_crossings_rate(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Zero_crossings_rate')
 
 @registrationAudioAspect('DC offset')
-def analyzeDCoffset(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('DC_offset')
+def analyzeDCoffset(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('DC_offset')
 
 @registrationAudioAspect('Dynamic range')
-def analyzeDynamicRange(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Dynamic_range')
+def analyzeDynamicRange(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Dynamic_range')
 
 @registrationAudioAspect('Signal entropy')
-def analyzeSignalEntropy(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Entropy')
+def analyzeSignalEntropy(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Entropy')
 
 @registrationAudioAspect('Duration-samples')
-def analyzeNumber_of_samples(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Number_of_samples')
+def analyzeNumber_of_samples(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Number_of_samples')
 
 @registrationAudioAspect('Peak dB')
-def analyzePeak_level(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Peak_level')
+def analyzePeak_level(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Peak_level')
 
 @registrationAudioAspect('RMS total')
-def analyzeRMS_level(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('RMS_level')
+def analyzeRMS_level(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('RMS_level')
 
 @registrationAudioAspect('Crest factor')
-def analyzeCrest_factor(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Crest_factor')
+def analyzeCrest_factor(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Crest_factor')
 
 @registrationAudioAspect('RMS peak')
-def analyzeRMS_peak(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('RMS_peak')
+def analyzeRMS_peak(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('RMS_peak')
 
 @registrationAudioAspect('LUFS integrated')
-def analyzeLUFSintegrated(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('I')
+def analyzeLUFSintegrated(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('I')
 
 @registrationAudioAspect('LUFS loudness range')
-def analyzeLRA(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('LRA')
+def analyzeLRA(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('LRA')
 
 @registrationAudioAspect('LUFS low')
-def analyzeLUFSlow(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('LRA.low')
+def analyzeLUFSlow(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('LRA.low')
 
 @registrationAudioAspect('LUFS high')
-def analyzeLUFShigh(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('LRA.high')
+def analyzeLUFShigh(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('LRA.high')
 
-@registrationAudioAspect('Spectral mean')
-def analyzeMean(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('mean')
+@registrationAudioAspect('Power spectral density')
+def analyzeMean(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('mean')
 
 @registrationAudioAspect('Spectral variance')
-def analyzeVariance(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('variance')
+def analyzeVariance(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('variance')
 
 @registrationAudioAspect('Spectral centroid')
-def analyzeCentroid(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('centroid')
+def analyzeCentroid(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('centroid')
 
 @registrationAudioAspect('Spectral spread')
-def analyzeSpread(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('spread')
+def analyzeSpread(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('spread')
 
 @registrationAudioAspect('Spectral skewness')
-def analyzeSkewness(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('skewness')
+def analyzeSkewness(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('skewness')
 
 @registrationAudioAspect('Spectral kurtosis')
-def analyzeKurtosis(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('kurtosis')
+def analyzeKurtosis(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('kurtosis')
 
 @registrationAudioAspect('Spectral entropy')
-def analyzeSpectralEntropy(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('entropy')
+def analyzeSpectralEntropy(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('entropy')
 
 @registrationAudioAspect('Spectral flatness')
-def analyzeFlatness(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('flatness')
+def analyzeFlatness(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('flatness')
 
 @registrationAudioAspect('Spectral crest')
-def analyzeCrest(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('crest')
+def analyzeCrest(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('crest')
 
 @registrationAudioAspect('Spectral flux')
-def analyzeFlux(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('flux')
+def analyzeFlux(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('flux')
 
 @registrationAudioAspect('Spectral slope')
-def analyzeSlope(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('slope')
+def analyzeSlope(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('slope')
 
 @registrationAudioAspect('Spectral decrease')
-def analyzeDecrease(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('decrease')
+def analyzeDecrease(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('decrease')
 
 @registrationAudioAspect('Spectral rolloff')
-def analyzeRolloff(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('rolloff')
+def analyzeRolloff(pathFilename: str | PathLike[Any]) -> numpy.ndarray:
+	return ffprobeShotgunAndCache(pathFilename).get('rolloff')
 
 @registrationAudioAspect('Abs_Peak_count')
-def analyzeAbs_Peak_count(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    print('Abs_Peak_count', pathFilename)
-    return ffprobeShotgunAndCache(pathFilename).get('Abs_Peak_count')
+def analyzeAbs_Peak_count(pathFilename: str | PathLike[Any]) -> float | None:
+	print('Abs_Peak_count', pathFilename)
+	return ffprobeShotgunAndCache(pathFilename).get('Abs_Peak_count')
 
 @registrationAudioAspect('Bit_depth')
-def analyzeBit_depth(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Bit_depth')
+def analyzeBit_depth(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Bit_depth')
 
 @registrationAudioAspect('Flat_factor')
-def analyzeFlat_factor(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Flat_factor')
+def analyzeFlat_factor(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Flat_factor')
 
 @registrationAudioAspect('Max_difference')
-def analyzeMax_difference(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Max_difference')
+def analyzeMax_difference(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Max_difference')
 
 @registrationAudioAspect('Max_level')
-def analyzeMax_level(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Max_level')
+def analyzeMax_level(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Max_level')
 
 @registrationAudioAspect('Mean_difference')
-def analyzeMean_difference(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Mean_difference')
+def analyzeMean_difference(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Mean_difference')
 
 @registrationAudioAspect('Min_difference')
-def analyzeMin_difference(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Min_difference')
+def analyzeMin_difference(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Min_difference')
 
 @registrationAudioAspect('Min_level')
-def analyzeMin_level(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Min_level')
+def analyzeMin_level(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Min_level')
 
 @registrationAudioAspect('Noise_floor')
-def analyzeNoise_floor(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Noise_floor')
+def analyzeNoise_floor(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Noise_floor')
 
 @registrationAudioAspect('Noise_floor_count')
-def analyzeNoise_floor_count(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Noise_floor_count')
+def analyzeNoise_floor_count(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Noise_floor_count')
 
 @registrationAudioAspect('Peak_count')
-def analyzePeak_count(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('Peak_count')
+def analyzePeak_count(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('Peak_count')
 
 @registrationAudioAspect('RMS_difference')
-def analyzeRMS_difference(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('RMS_difference')
+def analyzeRMS_difference(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('RMS_difference')
 
 @registrationAudioAspect('RMS_trough')
-def analyzeRMS_trough(pathFilename: Union[str, os.PathLike[Any]]) -> Optional[float]:
-    return ffprobeShotgunAndCache(pathFilename).get('RMS_trough')
+def analyzeRMS_trough(pathFilename: str | PathLike[Any]) -> float | None:
+	return ffprobeShotgunAndCache(pathFilename).get('RMS_trough')

analyzeAudio/analyzersUseSpectrogram.py

@@ -3,26 +3,28 @@ from typing import Any
 import cachetools
 import librosa
 import numpy
+from optype.numpy import AnyFloatingDType, ToArray3D, ToFloat3D
+from numpy import dtype, floating
 
 @registrationAudioAspect('Chromagram')
-def analyzeChromagram(spectrogramPower: numpy.ndarray, sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
-    return librosa.feature.chroma_stft(S=spectrogramPower, sr=sampleRate, **keywordArguments)
+def analyzeChromagram(spectrogramPower: numpy.ndarray[Any, dtype[floating[Any]]], sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
+	return librosa.feature.chroma_stft(S=spectrogramPower, sr=sampleRate, **keywordArguments)
 
 @registrationAudioAspect('Spectral Contrast')
-def analyzeSpectralContrast(spectrogramMagnitude: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    return librosa.feature.spectral_contrast(S=spectrogramMagnitude, **keywordArguments)
+def analyzeSpectralContrast(spectrogramMagnitude: numpy.ndarray[Any, dtype[floating[Any]]], **keywordArguments: Any) -> numpy.ndarray:
+	return librosa.feature.spectral_contrast(S=spectrogramMagnitude, **keywordArguments)
 
 @registrationAudioAspect('Spectral Bandwidth')
-def analyzeSpectralBandwidth(spectrogramMagnitude: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    centroid = audioAspects['Spectral Centroid']['analyzer'](spectrogramMagnitude)
-    return librosa.feature.spectral_bandwidth(S=spectrogramMagnitude, centroid=centroid, **keywordArguments)
+def analyzeSpectralBandwidth(spectrogramMagnitude: numpy.ndarray[Any, dtype[floating[Any]]], **keywordArguments: Any) -> numpy.ndarray:
+	centroid = audioAspects['Spectral Centroid']['analyzer'](spectrogramMagnitude)
+	return librosa.feature.spectral_bandwidth(S=spectrogramMagnitude, centroid=centroid, **keywordArguments)
 
 @cachetools.cached(cache=cacheAudioAnalyzers)
 @registrationAudioAspect('Spectral Centroid')
-def analyzeSpectralCentroid(spectrogramMagnitude: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    return librosa.feature.spectral_centroid(S=spectrogramMagnitude, **keywordArguments)
+def analyzeSpectralCentroid(spectrogramMagnitude: numpy.ndarray[Any, dtype[floating[Any]]], **keywordArguments: Any) -> numpy.ndarray:
+	return librosa.feature.spectral_centroid(S=spectrogramMagnitude, **keywordArguments)
 
 @registrationAudioAspect('Spectral Flatness')
-def analyzeSpectralFlatness(spectrogramMagnitude: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    spectralFlatness = librosa.feature.spectral_flatness(S=spectrogramMagnitude, **keywordArguments)
-    return 20 * numpy.log10(spectralFlatness, where=(spectralFlatness != 0)) # dB
+def analyzeSpectralFlatness(spectrogramMagnitude: numpy.ndarray[Any, dtype[floating[Any]]], **keywordArguments: Any) -> numpy.ndarray:
+	spectralFlatness = librosa.feature.spectral_flatness(S=spectrogramMagnitude, **keywordArguments)
+	return 20 * numpy.log10(spectralFlatness, where=(spectralFlatness != 0)) # dB

analyzeAudio/analyzersUseTensor.py

@@ -1,10 +1,10 @@
 from analyzeAudio import registrationAudioAspect
 from torchmetrics.functional.audio.srmr import speech_reverberation_modulation_energy_ratio
-from typing import Any, Optional
+from typing import Any
 import numpy
 import torch
 
 @registrationAudioAspect('SRMR')
-def analyzeSRMR(tensorAudio: torch.Tensor, sampleRate: int, pytorchOnCPU: Optional[bool], **keywordArguments: Any) -> numpy.ndarray:
-    keywordArguments['fast'] = keywordArguments.get('fast') or pytorchOnCPU or None
-    return torch.Tensor.numpy(speech_reverberation_modulation_energy_ratio(tensorAudio, sampleRate, **keywordArguments))
+def analyzeSRMR(tensorAudio: torch.Tensor, sampleRate: int, pytorchOnCPU: bool | None, **keywordArguments: Any) -> numpy.ndarray:
+	keywordArguments['fast'] = keywordArguments.get('fast') or pytorchOnCPU or None
+	return torch.Tensor.numpy(speech_reverberation_modulation_energy_ratio(tensorAudio, sampleRate, **keywordArguments))

analyzeAudio/analyzersUseWaveform.py

@@ -2,24 +2,25 @@ from analyzeAudio import registrationAudioAspect, audioAspects, cacheAudioAnalyz
 from typing import Any
 import librosa
 import numpy
+from optype.numpy import ToArray2D, AnyFloatingDType
 import cachetools
 
 @cachetools.cached(cache=cacheAudioAnalyzers)
 @registrationAudioAspect('Tempogram')
-def analyzeTempogram(waveform: numpy.ndarray, sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
-    return librosa.feature.tempogram(y=waveform, sr=sampleRate, **keywordArguments)
+def analyzeTempogram(waveform: ToArray2D[AnyFloatingDType], sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
+	return librosa.feature.tempogram(y=waveform, sr=sampleRate, **keywordArguments)
 
 # "RMS value from audio samples is faster ... However, ... spectrogram ... more accurate ... because ... windowed"
 @registrationAudioAspect('RMS from waveform')
-def analyzeRMS(waveform: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    arrayRMS = librosa.feature.rms(y=waveform, **keywordArguments)
-    return 20 * numpy.log10(arrayRMS, where=(arrayRMS != 0)) # dB
+def analyzeRMS(waveform: ToArray2D[AnyFloatingDType], **keywordArguments: Any) -> numpy.ndarray:
+	arrayRMS = librosa.feature.rms(y=waveform, **keywordArguments)
+	return 20 * numpy.log10(arrayRMS, where=(arrayRMS != 0)) # dB
 
 @registrationAudioAspect('Tempo')
-def analyzeTempo(waveform: numpy.ndarray, sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
-    tempogram = audioAspects['Tempogram']['analyzer'](waveform, sampleRate)
-    return librosa.feature.tempo(y=waveform, sr=sampleRate, tg=tempogram, **keywordArguments)
+def analyzeTempo(waveform: ToArray2D[AnyFloatingDType], sampleRate: int, **keywordArguments: Any) -> numpy.ndarray:
+	tempogram = audioAspects['Tempogram']['analyzer'](waveform, sampleRate)
+	return librosa.feature.tempo(y=waveform, sr=sampleRate, tg=tempogram, **keywordArguments)
 
 @registrationAudioAspect('Zero-crossing rate') # This is distinct from 'Zero-crossings rate'
-def analyzeZeroCrossingRate(waveform: numpy.ndarray, **keywordArguments: Any) -> numpy.ndarray:
-    return librosa.feature.zero_crossing_rate(y=waveform, **keywordArguments)
+def analyzeZeroCrossingRate(waveform: ToArray2D[AnyFloatingDType], **keywordArguments: Any) -> numpy.ndarray:
+	return librosa.feature.zero_crossing_rate(y=waveform, **keywordArguments)