sonusai 0.19.5__py3-none-any.whl → 0.19.8__py3-none-any.whl

sonusai/mixture/truth_functions/file.py

@@ -1,6 +1,5 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def file_validate(config: dict) -> None:
@@ -17,28 +16,33 @@ def file_validate(config: dict) -> None:
             raise ValueError("Truth file does not contain truth_f dataset")
 
 
-def file_parameters(config: TruthFunctionConfig) -> int:
+def file_parameters(_feature: str, _num_classes: int, config: dict) -> int:
     import h5py
     import numpy as np
 
-    with h5py.File(config.config["file"], "r") as f:
+    with h5py.File(config["file"], "r") as f:
         truth = np.array(f["truth_f"])
 
     return truth.shape[-1]
 
 
-def file(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def file(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """file truth function documentation"""
     import h5py
     import numpy as np
+    from pyaaware import feature_inverse_transform_config
+
+    target_audio = mixdb.mixture_targets(m_id)[target_index]
 
-    with h5py.File(config.config["file"], "r") as f:
+    frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
+
+    with h5py.File(config["file"], "r") as f:
         truth = np.array(f["truth_f"])
 
     if truth.ndim != 2:
         raise ValueError("Truth file data is not 2 dimensions")
 
-    if truth.shape[0] != len(data.target_audio) // config.frame_size:
+    if truth.shape[0] != len(target_audio) // frame_size:
         raise ValueError("Truth file does not contain the right amount of frames")
 
     return truth

sonusai/mixture/truth_functions/metadata.py

@@ -0,0 +1,24 @@
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
+
+
+def metadata_validate(config: dict) -> None:
+    if len(config) == 0:
+        raise AttributeError("metadata truth function is missing config")
+
+    parameters = ["tier"]
+    for parameter in parameters:
+        if parameter not in config:
+            raise AttributeError(f"metadata truth function is missing required '{parameter}'")
+
+
+def metadata_parameters(_feature: str, _num_classes: int, _config: dict) -> int | None:
+    return None
+
+
+def metadata(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+    """Metadata truth generation function
+
+    Retrieves metadata from target.
+    """
+    return mixdb.mixture_speech_metadata(m_id, config["tier"])[target_index]

sonusai/mixture/truth_functions/metrics.py

@@ -0,0 +1,28 @@
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
+
+
+def metrics_validate(config: dict) -> None:
+    if len(config) == 0:
+        raise AttributeError("metrics truth function is missing config")
+
+    parameters = ["metric"]
+    for parameter in parameters:
+        if parameter not in config:
+            raise AttributeError(f"metrics truth function is missing required '{parameter}'")
+
+
+def metrics_parameters(_feature: str, _num_classes: int, _config: dict) -> int | None:
+    return None
+
+
+def metrics(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+    """Metadata truth generation function
+
+    Retrieves metrics from target.
+    """
+    if not isinstance(config["metric"], list):
+        m = [config["metric"]]
+    else:
+        m = config["metric"]
+    return mixdb.mixture_metrics(m_id, m)[0][target_index]

sonusai/mixture/truth_functions/phoneme.py

@@ -1,17 +1,16 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def phoneme_validate(_config: dict) -> None:
     raise NotImplementedError("Truth function phoneme is not supported yet")
 
 
-def phoneme_parameters(_config: TruthFunctionConfig) -> int:
+def phoneme_parameters(_feature: str, _num_classes: int, _config: dict) -> int:
     raise NotImplementedError("Truth function phoneme is not supported yet")
 
 
-def phoneme(_data: TruthFunctionData, _config: TruthFunctionConfig) -> Truth:
+def phoneme(_mixdb: MixtureDatabase, _m_id: int, _target_index: int, _config: dict) -> Truth:
     """Read in .txt transcript and run a Python function to generate text grid data
     (indicating which phonemes are active). Then generate truth based on this data and put
     in the correct classes based on the index in the config.

sonusai/mixture/truth_functions/sed.py

@@ -1,12 +1,5 @@
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
-
-
-def _strictly_decreasing(list_to_check: list) -> bool:
-    from itertools import pairwise
-
-    return all(x > y for x, y in pairwise(list_to_check))
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def sed_validate(config: dict) -> None:
@@ -23,11 +16,11 @@ def sed_validate(config: dict) -> None:
         raise ValueError(f"sed truth function 'thresholds' are not strictly decreasing: {thresholds}")
 
 
-def sed_parameters(config: TruthFunctionConfig) -> int:
-    return config.num_classes
+def sed_parameters(_feature: str, num_classes: int, _config: dict) -> int:
+    return num_classes
 
 
-def sed(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def sed(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
     """Sound energy detection truth generation function
 
     Calculates sound energy detection truth using simple 3 threshold
@@ -62,30 +55,46 @@ def sed(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
     import numpy as np
     import torch
     from pyaaware import SED
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+    from pyaaware import feature_inverse_transform_config
+
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+
+    frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
 
-    if len(data.target_audio) % config.frame_size != 0:
-        raise ValueError(f"Number of samples in audio is not a multiple of {config.frame_size}")
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = config.target_fft.frames(data.target_audio)
-    parameters = sed_parameters(config)
-    if config.target_gain == 0:
+    if len(target_audio) % frame_size != 0:
+        raise ValueError(f"Number of samples in audio is not a multiple of {frame_size}")
+
+    frames = ft.frames(target_audio)
+    parameters = sed_parameters(mixdb.feature, mixdb.num_classes, config)
+    target_gain = mixdb.mixture(m_id).target_gain(target_index)
+    if target_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
     # SED wants 1-based indices
     s = SED(
-        thresholds=config.config["thresholds"],
-        index=config.class_indices,
-        frame_size=config.frame_size,
-        num_classes=config.num_classes,
+        thresholds=config["thresholds"],
+        index=mixdb.target_file(mixdb.mixture(m_id).targets[target_index].file_id).class_indices,
+        frame_size=frame_size,
+        num_classes=mixdb.num_classes,
     )
 
     # Back out target gain
-    target_audio = data.target_audio / config.target_gain
+    target_audio = target_audio / target_gain
 
     # Compute energy
-    target_energy = config.target_fft.execute_all(torch.from_numpy(target_audio))[1].numpy()
+    target_energy = ft.execute_all(target_audio)[1].numpy()
 
     if frames != target_energy.shape[0]:
         raise ValueError("Incorrect frames calculation in sed truth function")
 
     return s.execute_all(target_energy)
+
+
+def _strictly_decreasing(list_to_check: list) -> bool:
+    from itertools import pairwise
+
+    return all(x > y for x, y in pairwise(list_to_check))

sonusai/mixture/truth_functions/target.py

@@ -1,21 +1,24 @@
-from sonusai.mixture.datatypes import AudioF
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
-from sonusai.mixture.truth_functions.datatypes import TruthFunctionData
+from sonusai.mixture import MixtureDatabase
+from sonusai.mixture import Truth
 
 
 def target_f_validate(_config: dict) -> None:
     pass
 
 
-def target_f_parameters(config: TruthFunctionConfig) -> int:
-    if config.ttype == "tdac-co":
-        return config.target_fft.bins
+def target_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-    return config.target_fft.bins * 2
+    ft = ForwardTransform(**feature_forward_transform_config(feature))
 
+    if ft.ttype == "tdac-co":
+        return ft.bins
 
-def target_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+    return ft.bins * 2
+
+
+def target_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target truth function
 
     Calculates the true transform of the target using the STFT
@@ -26,23 +29,34 @@ def target_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
                   [:, bins] (target real only for tdac-co)
     """
     import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    target_freq = config.target_fft.execute_all(torch.from_numpy(data.target_audio))[0].numpy()
-    return _stack_real_imag(target_freq, config.ttype)
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+
+    target_freq = ft.execute_all(target_audio)[0].numpy()
+    return _stack_real_imag(target_freq, ft.ttype)
 
 
 def target_mixture_f_validate(_config: dict) -> None:
     pass
 
 
-def target_mixture_f_parameters(config: TruthFunctionConfig) -> int:
-    if config.ttype == "tdac-co":
-        return config.target_fft.bins * 2
+def target_mixture_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    ft = ForwardTransform(**feature_forward_transform_config(feature))
+
+    if ft.ttype == "tdac-co":
+        return ft.bins * 2
 
-    return config.target_fft.bins * 4
+    return ft.bins * 4
 
 
-def target_mixture_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def target_mixture_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target and mixture truth function
 
     Calculates the true transform of the target and the mixture
@@ -55,14 +69,21 @@ def target_mixture_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Tr
     """
     import numpy as np
     import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
 
-    target_freq = config.target_fft.execute_all(torch.from_numpy(data.target_audio))[0].numpy()
-    mixture_freq = config.mixture_fft.execute_all(torch.from_numpy(data.mixture_audio))[0].numpy()
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+
+    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    mixture_audio = torch.from_numpy(mixdb.mixture_mixture(m_id))
+
+    target_freq = ft.execute_all(torch.from_numpy(target_audio))[0].numpy()
+    mixture_freq = ft.execute_all(torch.from_numpy(mixture_audio))[0].numpy()
 
     frames, bins = target_freq.shape
     truth = np.empty((frames, bins * 4), dtype=np.float32)
-    truth[:, : bins * 2] = _stack_real_imag(target_freq, config.ttype)
-    truth[:, bins * 2 :] = _stack_real_imag(mixture_freq, config.ttype)
+    truth[:, : bins * 2] = _stack_real_imag(target_freq, ft.ttype)
+    truth[:, bins * 2 :] = _stack_real_imag(mixture_freq, ft.ttype)
     return truth
 
 
@@ -70,11 +91,14 @@ def target_swin_f_validate(_config: dict) -> None:
     pass
 
 
-def target_swin_f_parameters(config: TruthFunctionConfig) -> int:
-    return config.target_fft.bins * 2
+def target_swin_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
+    from pyaaware import ForwardTransform
+    from pyaaware import feature_forward_transform_config
+
+    return ForwardTransform(**feature_forward_transform_config(feature)).bins * 2
 
 
-def target_swin_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth:
+def target_swin_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
     """Frequency domain target with synthesis window truth function
 
     Calculates the true transform of the target using the STFT
@@ -85,20 +109,29 @@ def target_swin_f(data: TruthFunctionData, config: TruthFunctionConfig) -> Truth
     Output shape: [:, 2 * bins] (stacked real, imag)
     """
     import numpy as np
+    import torch
+    from pyaaware import ForwardTransform
+    from pyaaware import InverseTransform
+    from pyaaware import feature_forward_transform_config
+    from pyaaware import feature_inverse_transform_config
 
     from sonusai.utils import stack_complex
 
-    truth = np.empty((len(data.target_audio) // config.frame_size, config.target_fft.bins * 2), dtype=np.float32)
-    for idx, offset in enumerate(range(0, len(data.target_audio), config.frame_size)):
-        target_freq = config.target_fft.execute(
-            np.multiply(data.target_audio[offset : offset + config.frame_size], config.swin)
-        )[0]
+    ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
+    it = InverseTransform(**feature_inverse_transform_config(mixdb.feature))
+
+    target_audio = mixdb.mixture_targets(m_id)[target_index]
+
+    truth = np.empty((len(target_audio) // ft.overlap, ft.bins * 2), dtype=np.float32)
+    for idx, offset in enumerate(range(0, len(target_audio), ft.overlap)):
+        audio_frame = torch.from_numpy(np.multiply(target_audio[offset : offset + ft.overlap], it.window))
+        target_freq = ft.execute(audio_frame)[0].numpy()
         truth[idx] = stack_complex(target_freq)
 
     return truth
 
 
-def _stack_real_imag(data: AudioF, ttype: str) -> Truth:
+def _stack_real_imag(data: Truth, ttype: str) -> Truth:
     import numpy as np
 
     from sonusai.utils import stack_complex

sonusai/mkwav.py

@@ -1,12 +1,13 @@
 """sonusai mkwav
 
-usage: mkwav [-hvtn] [-i MIXID] LOC
+usage: mkwav [-hvtsn] [-i MIXID] LOC
 
 options:
     -h, --help
     -v, --verbose                   Be verbose.
     -i MIXID, --mixid MIXID         Mixture ID(s) to generate. [default: *].
     -t, --target                    Write target file.
+    -s, --targets                   Write targets files.
     -n, --noise                     Write noise file.
 
 The mkwav command creates WAV files from a SonusAI database.
@@ -17,18 +18,16 @@ Inputs:
 
 Outputs the following to the mixture database directory:
     <id>
-        mixture.wav:   mixture
-        target.wav:    target (optional)
-        noise.wav:     noise (optional)
+        mixture.wav:        mixture
+        target.wav:         target (optional)
+        targets<n>.wav:     targets <n> (optional)
+        noise.wav:          noise (optional)
         metadata.txt
     mkwav.log
 
 """
 
 import signal
-from dataclasses import dataclass
-
-from sonusai.mixture import MixtureDatabase
 
 
 def signal_handler(_sig, _frame):
@@ -43,39 +42,28 @@ def signal_handler(_sig, _frame):
 signal.signal(signal.SIGINT, signal_handler)
 
 
-@dataclass
-class MPGlobal:
-    mixdb: MixtureDatabase
-    write_target: bool
-    write_noise: bool
-
-
-MP_GLOBAL: MPGlobal
-
-
-def _process_mixture(m_id: int) -> None:
+def _process_mixture(m_id: int, location: str, write_target: bool, write_targets: bool, write_noise: bool) -> None:
     from os.path import join
 
+    from sonusai.mixture import MixtureDatabase
     from sonusai.mixture import write_mixture_metadata
     from sonusai.utils import float_to_int16
     from sonusai.utils import write_audio
 
-    global MP_GLOBAL
-
-    mixdb = MP_GLOBAL.mixdb
-    write_target = MP_GLOBAL.write_target
-    write_noise = MP_GLOBAL.write_noise
+    mixdb = MixtureDatabase(location)
 
-    mixture = mixdb.mixture(m_id)
-    location = join(mixdb.location, mixture.name)
+    location = join(mixdb.location, "mixture", mixdb.mixture(m_id).name)
 
     write_audio(name=join(location, "mixture.wav"), audio=float_to_int16(mixdb.mixture_mixture(m_id)))
     if write_target:
         write_audio(name=join(location, "target.wav"), audio=float_to_int16(mixdb.mixture_target(m_id)))
+    if write_targets:
+        for idx, target in enumerate(mixdb.mixture_targets(m_id)):
+            write_audio(name=join(location, f"targets{idx}.wav"), audio=float_to_int16(target))
     if write_noise:
         write_audio(name=join(location, "noise.wav"), audio=float_to_int16(mixdb.mixture_noise(m_id)))
 
-    write_mixture_metadata(mixdb, mixture)
+    write_mixture_metadata(mixdb, m_id)
 
 
 def main() -> None:
@@ -88,20 +76,21 @@ def main() -> None:
 
     verbose = args["--verbose"]
     mixid = args["--mixid"]
-    MP_GLOBAL.write_target = args["--target"]
-    MP_GLOBAL.write_noise = args["--noise"]
+    write_target = args["--target"]
+    write_targets = args["--targets"]
+    write_noise = args["--noise"]
     location = args["LOC"]
 
     import time
+    from functools import partial
     from os.path import join
 
-    import sonusai
     from sonusai import create_file_handler
     from sonusai import initial_log_messages
     from sonusai import logger
     from sonusai import update_console_handler
+    from sonusai.mixture import MixtureDatabase
     from sonusai.mixture import check_audio_files_exist
-    from sonusai.utils import human_readable_size
     from sonusai.utils import par_track
     from sonusai.utils import seconds_to_hms
     from sonusai.utils import track
@@ -113,31 +102,33 @@ def main() -> None:
     initial_log_messages("mkwav")
 
     logger.info(f"Load mixture database from {location}")
-    MP_GLOBAL.mixdb = MixtureDatabase(location)
-    mixid = MP_GLOBAL.mixdb.mixids_to_list(mixid)
+    mixdb = MixtureDatabase(location)
+    mixid = mixdb.mixids_to_list(mixid)
 
-    total_samples = MP_GLOBAL.mixdb.total_samples(mixid)
-    duration = total_samples / sonusai.mixture.SAMPLE_RATE
+    total_samples = mixdb.total_samples(mixid)
 
     logger.info("")
     logger.info(f"Found {len(mixid):,} mixtures to process")
     logger.info(f"{total_samples:,} samples")
 
-    check_audio_files_exist(MP_GLOBAL.mixdb)
+    check_audio_files_exist(mixdb)
 
     progress = track(total=len(mixid))
-    par_track(_process_mixture, mixid, progress=progress)
+    par_track(
+        partial(
+            _process_mixture,
+            location=location,
+            write_target=write_target,
+            write_targets=write_targets,
+            write_noise=write_noise,
+        ),
+        mixid,
+        progress=progress,
+    )
     progress.close()
 
     logger.info(f"Wrote {len(mixid)} mixtures to {location}")
     logger.info("")
-    logger.info(f"Duration: {seconds_to_hms(seconds=duration)}")
-    logger.info(f"mixture:  {human_readable_size(total_samples * 2, 1)}")
-    if MP_GLOBAL.write_target:
-        logger.info(f"target:   {human_readable_size(total_samples * 2, 1)}")
-    if MP_GLOBAL.write_noise:
-        logger.info(f"noise:    {human_readable_size(total_samples * 2, 1)}")
-
     end_time = time.monotonic()
     logger.info(f"Completed in {seconds_to_hms(seconds=end_time - start_time)}")
     logger.info("")

sonusai/queries/queries.py

@@ -5,6 +5,10 @@ from sonusai.mixture.datatypes import GeneralizedIDs
 from sonusai.mixture.mixdb import MixtureDatabase
 
 
+def _true_predicate(_: Any) -> bool:
+    return True
+
+
 def get_mixids_from_mixture_field_predicate(
     mixdb: MixtureDatabase,
     field: str,
@@ -20,9 +24,7 @@ def get_mixids_from_mixture_field_predicate(
     mixid_out = mixdb.mixids_to_list(mixids)
 
     if predicate is None:
-
-        def predicate(_: Any) -> bool:
-            return True
+        predicate = _true_predicate
 
     criteria_set = set()
     for m_id in mixid_out:
@@ -70,9 +72,7 @@ def get_mixids_from_truth_configs_field_predicate(
     values = get_all_truth_configs_values_from_field(mixdb, field)
 
     if predicate is None:
-
-        def predicate(_: Any) -> bool:
-            return True
+        predicate = _true_predicate
 
     # Get only values of interest
     values = [value for value in values if predicate(value)]
@@ -118,7 +118,7 @@ def get_all_truth_configs_values_from_field(mixdb: MixtureDatabase, field: str)
                 value = getattr(truth_config, field)
             else:
                 value = getattr(truth_config.config, field, None)
-            if isinstance(value, str):
+            if not isinstance(value, list):
                 value = [value]
             result.extend(value)
 
@@ -164,17 +164,13 @@ def get_mixids_from_snr(
         - keys are the SNRs
         - values are lists of the mixids that match the SNR
     """
-    from typing import Any
-
     mixid_out = mixdb.mixids_to_list(mixids)
 
     # Get all the SNRs
     snrs = [float(snr) for snr in mixdb.all_snrs if not snr.is_random]
 
     if predicate is None:
-
-        def predicate(_: Any) -> bool:
-            return True
+        predicate = _true_predicate
 
     # Get only the SNRs of interest (filter on predicate)
     snrs = [snr for snr in snrs if predicate(snr)]
@@ -201,9 +197,7 @@ def get_mixids_from_class_indices(
     mixid_out = mixdb.mixids_to_list(mixids)
 
     if predicate is None:
-
-        def predicate(_: Any) -> bool:
-            return True
+        predicate = _true_predicate
 
     criteria_set = set()
     for m_id in mixid_out:

sonusai/speech/l2arctic.py

@@ -54,6 +54,7 @@ def load_phonemes(audio: str | os.PathLike[str]) -> list[TimeAlignedType] | None
 
 def _load_ta(audio: str | os.PathLike[str], tier: str) -> list[TimeAlignedType] | None:
     from praatio import textgrid
+    from praatio.utilities.constants import Interval
 
     file = Path(audio).parent.parent / "textgrid" / (Path(audio).stem + ".TextGrid")
     if not os.path.exists(file):
@@ -65,7 +66,8 @@ def _load_ta(audio: str | os.PathLike[str], tier: str) -> list[TimeAlignedType]
 
     entries: list[TimeAlignedType] = []
     for entry in tg.getTier(tier).entries:
-        entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
+        if isinstance(entry, Interval):
+            entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
 
     return entries
 
@@ -79,6 +81,7 @@ def load_annotations(
     :return: A dictionary of a list of TimeAlignedType objects.
     """
     from praatio import textgrid
+    from praatio.utilities.constants import Interval
 
     file = Path(audio).parent.parent / "annotation" / (Path(audio).stem + ".TextGrid")
     if not os.path.exists(file):
@@ -89,7 +92,8 @@ def load_annotations(
     for tier in tg.tierNames:
         entries: list[TimeAlignedType] = []
         for entry in tg.getTier(tier).entries:
-            entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
+            if isinstance(entry, Interval):
+                entries.append(TimeAlignedType(text=entry.label, start=entry.start, end=entry.end))
         result[tier] = entries
 
     return result

sonusai/summarize_metric_spenh.py

@@ -48,7 +48,7 @@ def summarize_metric_spenh(location: str, by: str = "MIXID", reverse: bool = Fal
                     data.append(line.strip().split())
                     break
 
-    df = pd.DataFrame(data, columns=header)
+    df = pd.DataFrame(data, columns=header)  # pyright: ignore [reportArgumentType]
     df[header[0:-2]] = df[header[0:-2]].apply(pd.to_numeric, errors="coerce")
     return df.sort_values(by=by, ascending=not reverse).to_string(index=False)
 

sonusai/utils/__init__.py

@@ -27,6 +27,7 @@ from .get_frames_per_batch import get_frames_per_batch
 from .get_label_names import get_label_names
 from .grouper import grouper
 from .human_readable_size import human_readable_size
+from .load_object import load_object
 from .max_text_width import max_text_width
 from .model_utils import import_module
 from .numeric_conversion import float_to_int16

sonusai/utils/asr_functions/aaware_whisper.py

@@ -20,7 +20,7 @@ def aaware_whisper(audio: AudioT, **_config) -> ASRResult:
 
     url = getenv("AAWARE_WHISPER_URL")
     if url is None:
-        raise EnvironmentError("AAWARE_WHISPER_URL environment variable does not exist")
+        raise OSError("AAWARE_WHISPER_URL environment variable does not exist")
     url += "/asr?task=transcribe&language=en&encode=true&output=json"
 
     with tempfile.TemporaryDirectory() as tmp: