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

sonusai/metrics/calc_class_weights.py

@@ -54,7 +54,7 @@ def calc_class_weights_from_truth(truth: Truth, other_weight: float | None = Non
 
 def calc_class_weights_from_mixdb(
     mixdb: MixtureDatabase,
-    mixids: GeneralizedIDs | None = None,
+    mixids: GeneralizedIDs = "*",
     other_weight: float = 1,
     other_index: int = -1,
 ) -> tuple[np.ndarray, np.ndarray]:
@@ -77,8 +77,6 @@ def calc_class_weights_from_mixdb(
     from sonusai.mixture import get_class_count_from_mixids
 
     count = np.ceil(np.array(get_class_count_from_mixids(mixdb=mixdb, mixids=mixids)) / mixdb.feature_step_samples)
-    if mixdb.truth_mutex and other_weight is not None and other_weight > 0:
-        count[other_index] = count[other_index] / np.float32(other_weight)
     total_features = sum(count)
 
     weights = np.empty(mixdb.num_classes, dtype=np.float32)

sonusai/metrics/calc_optimal_thresholds.py

@@ -51,8 +51,8 @@ def calc_optimal_thresholds(
             AUC[nci] = np.NaN
             AP[nci] = np.NaN
         else:
-            AP[nci] = average_precision_score(truth_binary[:, nci], predict[:, nci], average=None)
-            AUC[nci] = roc_auc_score(truth_binary[:, nci], predict[:, nci], average=None)
+            AP[nci] = average_precision_score(truth_binary[:, nci], predict[:, nci], average=None)  # pyright: ignore [reportArgumentType]
+            AUC[nci] = roc_auc_score(truth_binary[:, nci], predict[:, nci], average=None)  # pyright: ignore [reportArgumentType]
 
             # Optimal threshold from PR curve, optimizes f-score
             precision, recall, thrpr = precision_recall_curve(truth_binary[:, nci], predict[:, nci])

sonusai/metrics/calc_phase_distance.py

@@ -26,7 +26,7 @@ def calc_phase_distance(
     # weighted mean over all (scalar)
     reference_mag = np.abs(reference)
     ref_weight = reference_mag / (np.sum(reference_mag) + eps)  # frames x bins
-    err = np.around(np.sum(ref_weight * rh_angle_diff), 3)
+    err = float(np.around(np.sum(ref_weight * rh_angle_diff), 3))
 
     # weighted mean over frames (value per bin)
     err_b = np.zeros(reference.shape[1])

sonusai/metrics/calc_speech.py

@@ -32,16 +32,16 @@ def calc_speech(hypothesis: np.ndarray, reference: np.ndarray, sample_rate: int
     llr_mean = np.mean(ll_rs[:llr_len])
 
     # Segmental SNR
-    snr_dist, segsnr_dist = _calc_snr(hypothesis=hypothesis, reference=reference, sample_rate=sample_rate)
+    _, segsnr_dist = _calc_snr(hypothesis=hypothesis, reference=reference, sample_rate=sample_rate)
     seg_snr = np.mean(segsnr_dist)
 
     # PESQ
     _pesq = calc_pesq(hypothesis=hypothesis, reference=reference, sample_rate=sample_rate)
 
     # Now compute the composite measures
-    csig = np.clip(3.093 - 1.029 * llr_mean + 0.603 * _pesq - 0.009 * wss_dist, 1, 5)
-    cbak = np.clip(1.634 + 0.478 * _pesq - 0.007 * wss_dist + 0.063 * seg_snr, 1, 5)
-    covl = np.clip(1.594 + 0.805 * _pesq - 0.512 * llr_mean - 0.007 * wss_dist, 1, 5)
+    csig = float(np.clip(3.093 - 1.029 * llr_mean + 0.603 * _pesq - 0.009 * wss_dist, 1, 5))
+    cbak = float(np.clip(1.634 + 0.478 * _pesq - 0.007 * wss_dist + 0.063 * seg_snr, 1, 5))
+    covl = float(np.clip(1.594 + 0.805 * _pesq - 0.512 * llr_mean - 0.007 * wss_dist, 1, 5))
 
     return SpeechMetrics(_pesq, csig, cbak, covl)
 
@@ -284,8 +284,8 @@ def _calc_log_likelihood_ratio_measure(
         hypothesis_frame = np.multiply(hypothesis_frame, window)
 
         # (2) Get the autocorrelation lags and LPC parameters used to compute the log likelihood ratio measure.
-        r_reference, ref_reference, a_reference = _lp_coefficients(reference_frame, p)
-        r_hypothesis, ref_hypothesis, a_hypothesis = _lp_coefficients(hypothesis_frame, p)
+        r_reference, _, a_reference = _lp_coefficients(reference_frame, p)
+        _, _, a_hypothesis = _lp_coefficients(hypothesis_frame, p)
 
         # (3) Compute the log likelihood ratio measure
         numerator = np.dot(np.matmul(a_hypothesis, toeplitz(r_reference)), a_hypothesis)

sonusai/metrics/class_summary.py

@@ -38,7 +38,7 @@ def class_summary(
     # TODO: re-work for modern mixdb API
     y_truth_f, y_predict = get_mixids_data(mixdb, mixids, truth_f, predict)  # type: ignore[name-defined]
 
-    if not mixdb.truth_mutex and num_classes > 1:
+    if num_classes > 1:
         if not isinstance(predict_thr, np.ndarray):
             if predict_thr == 0:
                 predict_thr = np.atleast_1d(0.5)
@@ -53,25 +53,16 @@ def class_summary(
     # [ACC, TPR, PPV, TNR, FPR, HITFA, F1, MCC, NT, PT, TP, FP, AP, AUC]
     table_idx = np.array([2, 1, 6, 4, 0, 12, 13, 9])
     col_n = ["PPV", "TPR", "F1", "FPR", "ACC", "AP", "AUC", "Support"]
-    if mixdb.truth_mutex:
-        if len(mixdb.class_labels) >= num_classes - 1:  # labels exist with or without Other
-            row_n = mixdb.class_labels
-            if len(mixdb.class_labels) == num_classes - 1:  # Other label does not exist, so add it
-                row_n.append("Other")
-        else:
-            row_n = [f"Class {i}" for i in range(1, num_classes)]
-            row_n.append("Other")
+    if len(mixdb.class_labels) == num_classes:
+        row_n = mixdb.class_labels
     else:
-        if len(mixdb.class_labels) == num_classes:
-            row_n = mixdb.class_labels
-        else:
-            row_n = [f"Class {i}" for i in range(1, num_classes + 1)]
+        row_n = [f"Class {i}" for i in range(1, num_classes + 1)]
 
-    df = pd.DataFrame(metrics[:, table_idx], columns=col_n, index=row_n)
+    df = pd.DataFrame(metrics[:, table_idx], columns=col_n, index=row_n) # pyright: ignore [reportArgumentType]
 
     # [miPPV, miTPR, miF1, miFPR, miACC, miAP, miAUC, TPSUM]
     avg_row_n = ["Macro-avg", "Micro-avg", "Weighted-avg"]
-    dfavg = pd.DataFrame(metavg, columns=col_n, index=avg_row_n)
+    dfavg = pd.DataFrame(metavg, columns=col_n, index=avg_row_n) # pyright: ignore [reportArgumentType]
 
     # dfblank = pd.DataFrame([''])
     # pd.concat([df, dfblank, dfblank, dfavg])

sonusai/metrics/confusion_matrix_summary.py

@@ -37,7 +37,7 @@ def confusion_matrix_summary(
     ytrue, ypred = get_mixids_data(mixdb=mixdb, mixids=mixids, truth_f=truth_f, predict=predict)  # type: ignore[name-defined]
 
     # Check predict_thr array or scalar and return final scalar predict_thr value
-    if not mixdb.truth_mutex and num_classes > 1:
+    if num_classes > 1:
         if not isinstance(predict_thr, np.ndarray):
             if predict_thr == 0:
                 # multi-label predict_thr scalar 0 force to 0.5 default
@@ -61,31 +61,15 @@ def confusion_matrix_summary(
     else:
         class_names = [f"Class {i}" for i in range(1, num_classes + 1)]
 
-    class_nums = [f"{i}" for i in range(1, num_classes + 1)]
-
-    if mixdb.truth_mutex:
-        # single-label mode force to argmax mode
-        predict_thr = np.array(0, dtype=np.float32)
-        _, _, cm, cmn, _, _ = one_hot(ytrue, ypred, predict_thr, truth_thr, timesteps)
-        row_n = class_names
-        row_n[-1] = "Other"
-        # mux = pd.MultiIndex.from_product([['Single-label/mutex mode, truth thr = {}'.format(truth_thr)],
-        #                                   class_nums])
-        # mux = pd.MultiIndex.from_product([['truth thr = {}'.format(truth_thr)], class_nums])
-
-        cmdf = pd.DataFrame(cm, index=row_n, columns=class_nums, dtype=np.int32)
-        cmndf = pd.DataFrame(cmn, index=row_n, columns=class_nums, dtype=np.float32)
-
-    else:
-        _, _, cm, cmn, _, _ = one_hot(ytrue[:, class_idx], ypred[:, class_idx], predict_thr, truth_thr, timesteps)
-        cname = class_names[class_idx]
-        row_n = ["TrueN", "TrueP"]
-        col_n = ["N-" + cname, "P-" + cname]
-        cmdf = pd.DataFrame(cm, index=row_n, columns=col_n, dtype=np.int32)
-        cmndf = pd.DataFrame(cmn, index=row_n, columns=col_n, dtype=np.float32)
-        # add thresholds in 3rd row
-        pdnote = pd.DataFrame(np.atleast_2d([predict_thr, truth_thr]), index=["p/t thr:"], columns=col_n)
-        cmdf = pd.concat([cmdf, pdnote])
-        cmndf = pd.concat([cmndf, pdnote])
+    _, _, cm, cmn, _, _ = one_hot(ytrue[:, class_idx], ypred[:, class_idx], predict_thr, truth_thr, timesteps)
+    cname = class_names[class_idx]
+    row_n = ["TrueN", "TrueP"]
+    col_n = ["N-" + cname, "P-" + cname]
+    cmdf = pd.DataFrame(cm, index=row_n, columns=col_n, dtype=np.int32)  # pyright: ignore [reportArgumentType]
+    cmndf = pd.DataFrame(cmn, index=row_n, columns=col_n, dtype=np.float32)  # pyright: ignore [reportArgumentType]
+    # add thresholds in 3rd row
+    pdnote = pd.DataFrame(np.atleast_2d([predict_thr, truth_thr]), index=["p/t thr:"], columns=col_n)  # pyright: ignore [reportArgumentType, reportCallIssue]
+    cmdf = pd.concat([cmdf, pdnote])
+    cmndf = pd.concat([cmndf, pdnote])
 
     return cmdf, cmndf

sonusai/metrics/one_hot.py

@@ -185,11 +185,11 @@ def one_hot(
             AP = np.NaN
             # threshold_optpr[nci] = np.NaN
         else:
-            AP = average_precision_score(truthb[:, nci], predict[:, nci], average=None)
+            AP = average_precision_score(truthb[:, nci], predict[:, nci], average=None)  # pyright: ignore [reportArgumentType]
             if len(np.unique(truthb[:, nci])) < 2:  # if active classes not > 1 AUC must be NaN
                 AUC = np.NaN  # i.e. all ones sklearn auc will fail
             else:
-                AUC = roc_auc_score(truthb[:, nci], predict[:, nci], average=None)
+                AUC = roc_auc_score(truthb[:, nci], predict[:, nci], average=None)  # pyright: ignore [reportArgumentType]
             # # Optimal threshold from PR curve, optimizes f-score
             # precision, recall, thresholds = precision_recall_curve(truthb[:, nci], predict[:, nci])
             # fscore = (2 * precision * recall) / (precision + recall)
@@ -263,7 +263,7 @@ def one_hot(
         ]  # specific format, last 3 are unique
 
         # weighted average TBD
-        wp, wr, wf1, _ = precision_recall_fscore_support(truthb, predb, average="weighted", zero_division=0)
+        wp, wr, wf1, _ = precision_recall_fscore_support(truthb, predb, average="weighted", zero_division=0)  # pyright: ignore [reportArgumentType]
         if np.sum(truthb):
             taidx = np.sum(truthb, axis=0) > 0
             wap = average_precision_score(truthb[:, taidx], predict[:, taidx], average="weighted")

sonusai/metrics/snr_summary.py

@@ -48,7 +48,7 @@ def snr_summary(
     snr_mixids = get_mixids_from_snr(mixdb=mixdb, mixids=mixid)
 
     # Check predict_thr array or scalar and return final scalar predict_thr value
-    if not mixdb.truth_mutex and num_classes > 1:
+    if num_classes > 1:
         if not isinstance(predict_thr, np.ndarray):
             if predict_thr == 0:
                 # multi-label predict_thr scalar 0 force to 0.5 default
@@ -84,7 +84,7 @@ def snr_summary(
     for ii, snr in enumerate(snr_mixids):
         # TODO: re-work for modern mixdb API
         y_truth, y_predict = get_mixids_data(mixdb, snr_mixids[snr], truth_f, predict)  # type: ignore[name-defined]
-        _, metrics, _, _, _, mavg = one_hot(y_truth, y_predict, predict_thr, truth_thr, timesteps)
+        _, _, _, _, _, mavg = one_hot(y_truth, y_predict, predict_thr, truth_thr, timesteps)
 
         # mavg macro, micro, weighted: [PPV, TPR, F1, FPR, ACC, mAP, mAUC, TPSUM]
         macro_avg[ii, :] = mavg[0, 0:7]
@@ -104,21 +104,21 @@ def snr_summary(
 
     # SNR format: PPV, TPR, F1, FPR, ACC, AP, AUC
     col_n = ["PPV", "TPR", "F1", "FPR", "ACC", "AP", "AUC"]
-    snr_macrodf = pd.DataFrame(macro_avg, index=list(snr_mixids.keys()), columns=col_n)
+    snr_macrodf = pd.DataFrame(macro_avg, index=list(snr_mixids.keys()), columns=col_n)  # pyright: ignore [reportArgumentType]
     snr_macrodf.sort_index(ascending=False, inplace=True)
 
-    snr_microdf = pd.DataFrame(micro_avg, index=list(snr_mixids.keys()), columns=col_n)
+    snr_microdf = pd.DataFrame(micro_avg, index=list(snr_mixids.keys()), columns=col_n)  # pyright: ignore [reportArgumentType]
     snr_microdf.sort_index(ascending=False, inplace=True)
 
-    snr_wghtdf = pd.DataFrame(wghtd_avg, index=list(snr_mixids.keys()), columns=col_n)
+    snr_wghtdf = pd.DataFrame(wghtd_avg, index=list(snr_mixids.keys()), columns=col_n)  # pyright: ignore [reportArgumentType]
     snr_wghtdf.sort_index(ascending=False, inplace=True)
 
     # Add segmental SNR columns if provided
     if segsnr is not None:
         ssnrdf = pd.DataFrame(
             ssnr_stats,
-            index=list(snr_mixids.keys()),
-            columns=["SSNRavg", "SSNR80p", "SSNRmax"],
+            index=list(snr_mixids.keys()),  # pyright: ignore [reportArgumentType]
+            columns=["SSNRavg", "SSNR80p", "SSNRmax"],  # pyright: ignore [reportArgumentType]
         )
         ssnrdf.sort_index(ascending=False, inplace=True)
         snr_macrodf = pd.concat([snr_macrodf, ssnrdf], axis=1)

sonusai/mixture/__init__.py

@@ -46,19 +46,15 @@ from .constants import SAMPLE_RATE
 from .constants import VALID_AUGMENTATIONS
 from .constants import VALID_CONFIGS
 from .constants import VALID_NOISE_MIX_MODES
+from .data_io import clear_cached_data
 from .data_io import read_cached_data
 from .data_io import write_cached_data
 from .datatypes import AudioF
-from .datatypes import AudiosF
-from .datatypes import AudiosT
 from .datatypes import AudioStatsMetrics
 from .datatypes import AudioT
 from .datatypes import Augmentation
 from .datatypes import AugmentationRule
-from .datatypes import AugmentationRules
-from .datatypes import Augmentations
 from .datatypes import AugmentedTarget
-from .datatypes import AugmentedTargets
 from .datatypes import ClassCount
 from .datatypes import EnergyF
 from .datatypes import EnergyT
@@ -70,35 +66,27 @@ from .datatypes import GenFTData
 from .datatypes import GenMixData
 from .datatypes import ImpulseResponseData
 from .datatypes import ImpulseResponseFile
-from .datatypes import ImpulseResponseFiles
-from .datatypes import ListAudiosT
 from .datatypes import MetricDoc
 from .datatypes import MetricDocs
 from .datatypes import Mixture
 from .datatypes import MixtureDatabaseConfig
-from .datatypes import Mixtures
 from .datatypes import NoiseFile
-from .datatypes import NoiseFiles
 from .datatypes import Predict
 from .datatypes import Segsnr
 from .datatypes import SnrFMetrics
 from .datatypes import SpectralMask
-from .datatypes import SpectralMasks
 from .datatypes import SpeechMetadata
 from .datatypes import SpeechMetrics
 from .datatypes import TargetFile
-from .datatypes import TargetFiles
 from .datatypes import TransformConfig
 from .datatypes import Truth
 from .datatypes import TruthConfig
 from .datatypes import TruthConfigs
 from .datatypes import TruthDict
 from .datatypes import TruthParameter
-from .datatypes import TruthParameters
 from .datatypes import UniversalSNR
 from .feature import get_audio_from_feature
 from .feature import get_feature_from_audio
-from .generation import generate_mixtures
 from .generation import get_all_snrs_from_config
 from .generation import initialize_db
 from .generation import populate_class_label_table
@@ -111,17 +99,14 @@ from .generation import populate_target_file_table
 from .generation import populate_top_table
 from .generation import populate_truth_parameters_table
 from .generation import update_mixid_width
-from .generation import update_mixture
+from .generation import update_mixture_table
 from .helpers import augmented_noise_samples
 from .helpers import augmented_target_samples
 from .helpers import check_audio_files_exist
 from .helpers import forward_transform
 from .helpers import frames_from_samples
 from .helpers import get_audio_from_transform
-from .helpers import get_ft
-from .helpers import get_segsnr
 from .helpers import get_transform_from_audio
-from .helpers import get_truth
 from .helpers import inverse_transform
 from .helpers import mixture_metadata
 from .helpers import write_mixture_metadata

sonusai/mixture/augmentation.py

@@ -1,12 +1,11 @@
 from sonusai.mixture.datatypes import AudioT
 from sonusai.mixture.datatypes import Augmentation
 from sonusai.mixture.datatypes import AugmentationRule
-from sonusai.mixture.datatypes import AugmentationRules
 from sonusai.mixture.datatypes import ImpulseResponseData
 from sonusai.mixture.datatypes import OptionalNumberStr
 
 
-def get_augmentation_rules(rules: list[dict] | dict, num_ir: int = 0) -> AugmentationRules:
+def get_augmentation_rules(rules: list[dict] | dict, num_ir: int = 0) -> list[AugmentationRule]:
     """Generate augmentation rules from list of input rules
 
     :param rules: Dictionary of augmentation config rule[s]
@@ -25,7 +24,7 @@ def get_augmentation_rules(rules: list[dict] | dict, num_ir: int = 0) -> Augment
         rule = _parse_ir(rule, num_ir)
         processed_rules = _expand_rules(expanded_rules=processed_rules, rule=rule)
 
-    return [dataclass_from_dict(AugmentationRule, processed_rule) for processed_rule in processed_rules]
+    return [dataclass_from_dict(AugmentationRule, processed_rule) for processed_rule in processed_rules]  # pyright: ignore [reportReturnType]
 
 
 def _expand_rules(expanded_rules: list[dict], rule: dict) -> list[dict]:
@@ -163,7 +162,7 @@ def estimate_augmented_length_from_length(length: int, tempo: OptionalNumberStr
     return length
 
 
-def get_mixups(augmentations: AugmentationRules) -> list[int]:
+def get_mixups(augmentations: list[AugmentationRule]) -> list[int]:
     """Get a list of mixup values used
 
     :param augmentations: List of augmentations
@@ -172,7 +171,7 @@ def get_mixups(augmentations: AugmentationRules) -> list[int]:
     return sorted({augmentation.mixup for augmentation in augmentations})
 
 
-def get_augmentation_indices_for_mixup(augmentations: AugmentationRules, mixup: int) -> list[int]:
+def get_augmentation_indices_for_mixup(augmentations: list[AugmentationRule], mixup: int) -> list[int]:
     """Get a list of augmentation indices for a given mixup value
 
     :param augmentations: List of augmentations
@@ -327,4 +326,4 @@ def augmentation_from_rule(rule: AugmentationRule, num_ir: int) -> Augmentation:
     if _rule_has_rand(processed_rule):
         processed_rule = _generate_random_rule(processed_rule, num_ir)
 
-    return dataclass_from_dict(Augmentation, processed_rule)
+    return dataclass_from_dict(Augmentation, processed_rule)  # pyright: ignore [reportReturnType]

sonusai/mixture/class_count.py

@@ -3,7 +3,7 @@ from sonusai.mixture.datatypes import GeneralizedIDs
 from sonusai.mixture.mixdb import MixtureDatabase
 
 
-def get_class_count_from_mixids(mixdb: MixtureDatabase, mixids: GeneralizedIDs | None = None) -> ClassCount:
+def get_class_count_from_mixids(mixdb: MixtureDatabase, mixids: GeneralizedIDs = "*") -> ClassCount:
     """Sums the class counts for given mixids"""
     total_class_count = [0] * mixdb.num_classes
     m_ids = mixdb.mixids_to_list(mixids)

sonusai/mixture/config.py

@@ -1,9 +1,8 @@
 from sonusai.mixture.datatypes import ImpulseResponseFile
-from sonusai.mixture.datatypes import ImpulseResponseFiles
-from sonusai.mixture.datatypes import NoiseFiles
-from sonusai.mixture.datatypes import SpectralMasks
-from sonusai.mixture.datatypes import TargetFiles
-from sonusai.mixture.datatypes import TruthParameters
+from sonusai.mixture.datatypes import NoiseFile
+from sonusai.mixture.datatypes import SpectralMask
+from sonusai.mixture.datatypes import TargetFile
+from sonusai.mixture.datatypes import TruthParameter
 
 
 def raw_load_config(name: str) -> dict:
@@ -210,7 +209,7 @@ def update_config_from_hierarchy(root: str, leaf: str, config: dict) -> dict:
     return new_config
 
 
-def get_target_files(config: dict, show_progress: bool = False) -> TargetFiles:
+def get_target_files(config: dict, show_progress: bool = False) -> list[TargetFile]:
     """Get the list of target files from a config
 
     :param config: Config dictionary
@@ -223,7 +222,7 @@ def get_target_files(config: dict, show_progress: bool = False) -> TargetFiles:
     from sonusai.utils import par_track
     from sonusai.utils import track
 
-    from .datatypes import TargetFiles
+    from .datatypes import TargetFile
 
     class_indices = config["class_indices"]
     if not isinstance(class_indices, list):
@@ -255,7 +254,7 @@ def get_target_files(config: dict, show_progress: bool = False) -> TargetFiles:
         if any(class_index > num_classes for class_index in target_file["class_indices"]):
             raise ValueError(f"class index elements must not be greater than {num_classes}")
 
-    return dataclass_from_dict(TargetFiles, target_files)
+    return dataclass_from_dict(list[TargetFile], target_files)
 
 
 def append_target_files(
@@ -294,6 +293,7 @@ def append_target_files(
     if tokens is None:
         tokens = {}
 
+    truth_configs_merged = deepcopy(truth_configs)
     if isinstance(entry, dict):
         if "name" in entry:
             in_name = entry["name"]
@@ -312,15 +312,11 @@ def append_target_files(
                 raise AttributeError(
                     f"Truth config '{key}' override specified for {entry['name']} is not defined at top level"
                 )
-        truth_configs_merged = {}
-        for key in truth_configs_override:
-            truth_configs_merged[key] = deepcopy(truth_configs[key])
-            if truth_configs_override[key] is not None:
+            if key in truth_configs_override:
                 truth_configs_merged[key] |= truth_configs_override[key]
         level_type = entry.get("level_type", level_type)
     else:
         in_name = entry
-        truth_configs_merged = deepcopy(truth_configs)
 
     in_name, new_tokens = tokenized_expand(in_name)
     tokens.update(new_tokens)
@@ -416,7 +412,7 @@ def append_target_files(
     return target_files
 
 
-def get_noise_files(config: dict, show_progress: bool = False) -> NoiseFiles:
+def get_noise_files(config: dict, show_progress: bool = False) -> list[NoiseFile]:
     """Get the list of noise files from a config
 
     :param config: Config dictionary
@@ -429,7 +425,7 @@ def get_noise_files(config: dict, show_progress: bool = False) -> NoiseFiles:
     from sonusai.utils import par_track
     from sonusai.utils import track
 
-    from .datatypes import NoiseFiles
+    from .datatypes import NoiseFile
 
     noise_files = list(chain.from_iterable([append_noise_files(entry=entry) for entry in config["noises"]]))
 
@@ -437,7 +433,7 @@ def get_noise_files(config: dict, show_progress: bool = False) -> NoiseFiles:
     noise_files = par_track(_get_num_samples, noise_files, progress=progress)
     progress.close()
 
-    return dataclass_from_dict(NoiseFiles, noise_files)
+    return dataclass_from_dict(list[NoiseFile], noise_files)
 
 
 def append_noise_files(entry: dict | str, tokens: dict | None = None) -> list[dict]:
@@ -522,26 +518,25 @@ def append_noise_files(entry: dict | str, tokens: dict | None = None) -> list[di
     return noise_files
 
 
-def get_impulse_response_files(config: dict) -> ImpulseResponseFiles:
+def get_impulse_response_files(config: dict) -> list[ImpulseResponseFile]:
     """Get the list of impulse response files from a config
 
     :param config: Config dictionary
     :return: List of impulse response files
     """
-    return [ImpulseResponseFile(entry["name"], entry["tags"]) for entry in config["impulse_responses"]]
-    # from itertools import chain
-    #
-    # return list(
-    #     chain.from_iterable(
-    #         [
-    #             append_impulse_response_files(entry=ImpulseResponseFile(entry["name"], entry["tags"]))
-    #             for entry in config["impulse_responses"]
-    #         ]
-    #     )
-    # )
-
-
-def append_impulse_response_files(entry: ImpulseResponseFile, tokens: dict | None = None) -> list[str]:
+    from itertools import chain
+
+    return list(
+        chain.from_iterable(
+            [
+                append_impulse_response_files(entry=ImpulseResponseFile(entry["name"], entry.get("tags", [])))
+                for entry in config["impulse_responses"]
+            ]
+        )
+    )
+
+
+def append_impulse_response_files(entry: ImpulseResponseFile, tokens: dict | None = None) -> list[ImpulseResponseFile]:
     """Process impulse response files list and append as needed
 
     :param entry: Impulse response file entry to append to the list
@@ -569,7 +564,7 @@ def append_impulse_response_files(entry: ImpulseResponseFile, tokens: dict | Non
     if not names:
         raise OSError(f"Could not find {in_name}. Make sure path exists")
 
-    impulse_response_files: list[str] = []
+    impulse_response_files: list[ImpulseResponseFile] = []
     for name in names:
         ext = splitext(name)[1].lower()
         dir_name = dirname(name)
@@ -607,14 +602,14 @@ def append_impulse_response_files(entry: ImpulseResponseFile, tokens: dict | Non
                         raise OSError(f"Error processing {name}: {e}") from e
                 else:
                     validate_input_file(name)
-                    impulse_response_files.append(tokenized_replace(name, tokens))
+                    impulse_response_files.append(ImpulseResponseFile(tokenized_replace(name, tokens), entry.tags))
             except Exception as e:
                 raise OSError(f"Error processing {name}: {e}") from e
 
     return impulse_response_files
 
 
-def get_spectral_masks(config: dict) -> SpectralMasks:
+def get_spectral_masks(config: dict) -> list[SpectralMask]:
     """Get the list of spectral masks from a config
 
     :param config: Config dictionary
@@ -623,12 +618,12 @@ def get_spectral_masks(config: dict) -> SpectralMasks:
     from sonusai.utils import dataclass_from_dict
 
     try:
-        return dataclass_from_dict(SpectralMasks, config["spectral_masks"])
+        return dataclass_from_dict(list[SpectralMask], config["spectral_masks"])
     except Exception as e:
         raise ValueError(f"Error in spectral_masks: {e}") from e
 
 
-def get_truth_parameters(config: dict) -> TruthParameters:
+def get_truth_parameters(config: dict) -> list[TruthParameter]:
     """Get the list of truth parameters from a config
 
     :param config: Config dictionary
@@ -637,26 +632,21 @@ def get_truth_parameters(config: dict) -> TruthParameters:
     from copy import deepcopy
 
     from sonusai.mixture import truth_functions
-    from sonusai.mixture.truth_functions.datatypes import TruthFunctionConfig
 
     from .constants import REQUIRED_TRUTH_CONFIGS
     from .datatypes import TruthParameter
 
-    truth_parameters: TruthParameters = []
+    truth_parameters: list[TruthParameter] = []
     for name, truth_config in config["truth_configs"].items():
         optional_config = deepcopy(truth_config)
         for key in REQUIRED_TRUTH_CONFIGS:
             del optional_config[key]
 
-        t_config = TruthFunctionConfig(
-            feature=config["feature"],
-            num_classes=config["num_classes"],
-            class_indices=[1],
-            target_gain=1,
-            config=optional_config,
+        parameters = getattr(truth_functions, truth_config["function"] + "_parameters")(
+            config["feature"],
+            config["num_classes"],
+            optional_config,
         )
-
-        parameters = getattr(truth_functions, truth_config["function"] + "_parameters")(t_config)
         truth_parameters.append(TruthParameter(name, parameters))
 
     return truth_parameters

sonusai/mixture/data_io.py

@@ -128,6 +128,22 @@ def write_pickle_data(location: str, index: str, items: list[tuple[str, Any]] |
             f.write(pickle.dumps(item[1]))
 
 
+def clear_pickle_data(location: str, index: str, items: list[str] | str) -> None:
+    """Clear mixture, target, or noise data pickle file
+
+    :param location: Location of the file
+    :param index: Mixture, target, or noise index
+    :param items: String(s) of data to retrieve
+    """
+    from pathlib import Path
+
+    if not isinstance(items, list):
+        items = [items]
+
+    for item in items:
+        Path(_get_pickle_name(location, index, item)).unlink(missing_ok=True)
+
+
 def read_cached_data(location: str, name: str, index: str, items: list[str] | str) -> Any:
     """Read cached data from a file
 
@@ -143,7 +159,7 @@ def read_cached_data(location: str, name: str, index: str, items: list[str] | st
 
 
 def write_cached_data(location: str, name: str, index: str, items: list[tuple[str, Any]] | tuple[str, Any]) -> None:
-    """Write mixture data to a file
+    """Write data to a file
 
     :param location: Location of the mixture database
     :param name: Data name ('mixture', 'target', or 'noise')
@@ -153,3 +169,16 @@ def write_cached_data(location: str, name: str, index: str, items: list[tuple[st
     from os.path import join
 
     write_pickle_data(join(location, name), index, items)
+
+
+def clear_cached_data(location: str, name: str, index: str, items: list[str] | str) -> None:
+    """Remove cached data file(s)
+
+    :param location: Location of the mixture database
+    :param name: Data name ('mixture', 'target', or 'noise')
+    :param index: Data index (mixture, target, or noise ID)
+    :param items: String(s) of data to clear
+    """
+    from os.path import join
+
+    clear_pickle_data(join(location, name), index, items)