from __future__ import annotations
from typing import TypeVar, Generic, Literal, Any
import sys
if sys.version_info < (3, 11):
from typing_extensions import TypeAlias
else:
from typing import TypeAlias
from dataclasses import dataclass
import numpy as np
import numpy.typing as npt
__all__ = (
'Floating', 'Complex', 'SosCoeff', 'SosZI',
'AnyArray', 'BoolArray', 'IndexArray', 'FloatArray', 'ComplexArray',
'Float1dArray', 'Float2dArray', 'Float3dArray', 'Float2dArray32', 'AnyFloatArray',
'AnyNdArray', 'Any1dArray', 'Any2dArray', 'Any3dArray', 'ShapeT',
'NumChannels', 'NumChannelsT', 'ChannelIndex', 'ChannelIndexT',
'CurrentMeasurement',
)
NumChannels = Literal[1, 2, 3, 5]
"""Number of audio channels supported by the meter (1, 2, 3, or 5)."""
NumChannelsT = TypeVar('NumChannelsT', bound=NumChannels)
"""TypeVar bound to :data:`NumChannels`."""
ChannelIndex = Literal[0, 1, 2, 3, 4]
"""Zero-based index for an audio channel, valid for channel counts up to 5 (``0`` through ``4``)."""
ChannelIndexT = TypeVar('ChannelIndexT', bound=ChannelIndex)
"""TypeVar bound to :data:`ChannelIndex`."""
Floating = np.floating
Complex = np.complex128
DType_t = TypeVar("DType_t", bound=np.dtype[Any])
DType_co = TypeVar("DType_co", bound=np.dtype[Any], covariant=True)
""""""
ShapeT = TypeVar('ShapeT', bound=tuple[int,...])
ShapeT_co = TypeVar('ShapeT_co', bound=tuple[int,...], covariant=True)
_1DArray = np.ndarray[tuple[int], DType_co]
_2DArray = np.ndarray[tuple[int, int], DType_co]
_3DArray = np.ndarray[tuple[int, int, int], DType_co]
# type AnyNdArray[_St: (tuple[int,...]), _Dt: (_AnyDtype)] = np.ndarray[_St, _Dt]
AnyNdArray: TypeAlias = np.ndarray[ShapeT, DType_co]
"""A generic type for numpy ND arrays"""
# type Any1dArray[_Dt: (_AnyDtype)] = _1DArray[_Dt]
Any1dArray: TypeAlias = _1DArray[DType_co]
"""A generic type for numpy 1D arrays"""
# type Any2dArray[_Dt: (_AnyDtype)] = _2DArray[_Dt]
Any2dArray: TypeAlias = _2DArray[DType_co]
"""A generic type for numpy 2D arrays"""
# type Any3dArray[_Dt: (_AnyDtype)] = _3DArray[_Dt]
Any3dArray: TypeAlias = _3DArray[DType_co]
"""A generic type for numpy 3D arrays"""
AnyFloatArray = AnyNdArray[ShapeT, np.dtype[Floating]]
AnyArray = npt.NDArray[Any]
BoolArray = AnyNdArray[ShapeT, np.dtype[np.bool_]]
IndexArray = AnyNdArray[ShapeT, np.dtype[np.intp]]
FloatArray = AnyNdArray[ShapeT, np.dtype[np.float64]]
ComplexArray = AnyNdArray[ShapeT, np.dtype[Complex]]
Float1dArray = Any1dArray[np.dtype[np.float64]]
"""1D array of :class:`~numpy.float64`"""
Float2dArray = Any2dArray[np.dtype[np.float64]]
"""2D array of :class:`~numpy.float64`"""
Float3dArray = Any3dArray[np.dtype[np.float64]]
"""3D array of :class:`~numpy.float64`"""
Float2dArray32 = Any2dArray[np.dtype[np.float32]]
"""2D array of :class:`~numpy.float32`"""
SosCoeff = np.ndarray[tuple[int, Literal[6]], np.dtype[np.float64]]
"""Array representing second-order sections filter coefficients"""
SosZI = np.ndarray[tuple[int, int, Literal[2]], np.dtype[np.float64]]
"""Array representing initial conditions for second-order sections filtering"""
# TODO: Revert to NamedTuple when Python 3.10 support is dropped
[docs]
@dataclass(frozen=True)
class CurrentMeasurement(Generic[NumChannelsT]):
"""Represents the current measurement state for a gating block"""
time: float|Floating
"""The measurement time for this gating block"""
momentary: float|Floating
"""The :term:`Momentary Loudness` for this gating block"""
short_term: float|Floating
"""The :term:`Short-Term Loudness` for this gating block"""
integrated: float|Floating
"""The :term:`Integrated Loudness` for this gating block"""
lra: float|Floating
"""The :term:`Loudness Range` for this gating block"""
true_peak_current: np.ndarray[tuple[NumChannelsT], np.dtype[np.float64]]
"""The :term:`True Peak` value for each channel for this gating block"""
true_peak_max: float|Floating
"""The maximum :term:`True Peak` value across all channels for this gating block"""