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

sonusai/mixture/generation.py

@@ -1,17 +1,15 @@
 # ruff: noqa: S608
-from .datatypes import AudiosT
 from .datatypes import AudioT
 from .datatypes import Augmentation
-from .datatypes import AugmentationRules
-from .datatypes import AugmentedTargets
+from .datatypes import AugmentationRule
+from .datatypes import AugmentedTarget
 from .datatypes import GenMixData
-from .datatypes import ImpulseResponseFiles
+from .datatypes import ImpulseResponseFile
 from .datatypes import Mixture
-from .datatypes import Mixtures
-from .datatypes import NoiseFiles
-from .datatypes import SpectralMasks
-from .datatypes import TargetFiles
-from .datatypes import Targets
+from .datatypes import NoiseFile
+from .datatypes import SpectralMask
+from .datatypes import Target
+from .datatypes import TargetFile
 from .datatypes import UniversalSNRGenerator
 from .mixdb import MixtureDatabase
 
@@ -37,7 +35,7 @@ def initialize_db(location: str, test: bool = False) -> None:
     CREATE TABLE truth_parameters(
     id INTEGER PRIMARY KEY NOT NULL,
     name TEXT NOT NULL,
-    parameters INTEGER NOT NULL)
+    parameters INTEGER)
     """)
 
     con.execute("""
@@ -121,8 +119,8 @@ def initialize_db(location: str, test: bool = False) -> None:
     id INTEGER PRIMARY KEY NOT NULL,
     file_id INTEGER NOT NULL,
     augmentation TEXT NOT NULL,
-    gain FLOAT,
-    FOREIGN KEY(file_id) REFERENCES target_file (id))
+    FOREIGN KEY(file_id) REFERENCES target_file (id),
+    UNIQUE(file_id, augmentation))
     """)
 
     con.execute("""
@@ -165,11 +163,12 @@ def populate_top_table(location: str, config: dict, test: bool = False) -> None:
     con = db_connection(location=location, readonly=False, test=test)
     con.execute(
         """
-    INSERT INTO top (version, asr_configs, class_balancing, feature, noise_mix_mode, num_classes,
+    INSERT INTO top (id, version, asr_configs, class_balancing, feature, noise_mix_mode, num_classes,
     seed, mixid_width, speaker_metadata_tiers, textgrid_metadata_tiers)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     """,
         (
+            1,
             MIXDB_VERSION,
             json.dumps(config["asr_configs"]),
             config["class_balancing"],
@@ -271,7 +270,7 @@ def populate_truth_parameters_table(location: str, config: dict, test: bool = Fa
     con.close()
 
 
-def populate_target_file_table(location: str, target_files: TargetFiles, test: bool = False) -> None:
+def populate_target_file_table(location: str, target_files: list[TargetFile], test: bool = False) -> None:
     """Populate target file table"""
     import json
     from pathlib import Path
@@ -331,7 +330,7 @@ def populate_target_file_table(location: str, target_files: TargetFiles, test: b
 
     # Update textgrid_metadata_tiers in the top table
     con.execute(
-        "UPDATE top SET textgrid_metadata_tiers=? WHERE top.id = ?",
+        "UPDATE top SET textgrid_metadata_tiers=? WHERE ? = top.id",
         (json.dumps(sorted(textgrid_metadata_tiers)), 1),
     )
 
@@ -339,7 +338,7 @@ def populate_target_file_table(location: str, target_files: TargetFiles, test: b
     con.close()
 
 
-def populate_noise_file_table(location: str, noise_files: NoiseFiles, test: bool = False) -> None:
+def populate_noise_file_table(location: str, noise_files: list[NoiseFile], test: bool = False) -> None:
     """Populate noise file table"""
     from .mixdb import db_connection
 
@@ -353,7 +352,7 @@ def populate_noise_file_table(location: str, noise_files: NoiseFiles, test: bool
 
 
 def populate_impulse_response_file_table(
-    location: str, impulse_response_files: ImpulseResponseFiles, test: bool = False
+    location: str, impulse_response_files: list[ImpulseResponseFile], test: bool = False
 ) -> None:
     """Populate impulse response file table"""
     import json
@@ -383,79 +382,115 @@ def update_mixid_width(location: str, num_mixtures: int, test: bool = False) ->
 
     con = db_connection(location=location, readonly=False, test=test)
     con.execute(
-        "UPDATE top SET mixid_width=? WHERE top.id = ?",
+        "UPDATE top SET mixid_width=? WHERE ? = top.id",
         (max_text_width(num_mixtures), 1),
     )
     con.commit()
     con.close()
 
 
-def populate_mixture_table(location: str, mixtures: Mixtures, test: bool = False) -> None:
-    """Populate mixture table"""
+def populate_mixture_table(
+    location: str,
+    noise_mix_mode: str,
+    augmented_targets: list[AugmentedTarget],
+    target_files: list[TargetFile],
+    target_augmentations: list[AugmentationRule],
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
+    spectral_masks: list[SpectralMask],
+    all_snrs: list[UniversalSNRGenerator],
+    mixups: list[int],
+    num_classes: int,
+    feature_step_samples: int,
+    num_ir: int,
+    test: bool = False,
+) -> tuple[int, int]:
+    """Generate mixtures and populate mixture table"""
     from .helpers import from_mixture
     from .helpers import from_target
     from .mixdb import db_connection
 
-    con = db_connection(location=location, readonly=False, test=test)
+    if noise_mix_mode == "exhaustive":
+        func = _exhaustive_noise_mix
+    elif noise_mix_mode == "non-exhaustive":
+        func = _non_exhaustive_noise_mix
+    elif noise_mix_mode == "non-combinatorial":
+        func = _non_combinatorial_noise_mix
+    else:
+        raise ValueError(f"invalid noise_mix_mode: {noise_mix_mode}")
+
+    used_noise_files, used_noise_samples, mixtures = func(
+        augmented_targets=augmented_targets,
+        target_files=target_files,
+        target_augmentations=target_augmentations,
+        noise_files=noise_files,
+        noise_augmentations=noise_augmentations,
+        spectral_masks=spectral_masks,
+        all_snrs=all_snrs,
+        mixups=mixups,
+        num_classes=num_classes,
+        feature_step_samples=feature_step_samples,
+        num_ir=num_ir,
+    )
 
+    con = db_connection(location=location, readonly=False, test=test)
     # Populate target table
-    targets: list[tuple[int, str, float]] = []
     for mixture in mixtures:
         for target in mixture.targets:
-            entry = from_target(target)
-            if entry not in targets:
-                targets.append(entry)
-
-    con.executemany("INSERT INTO target (file_id, augmentation, gain) VALUES (?, ?, ?)", targets)
+            con.execute(
+                """
+                INSERT OR IGNORE INTO target (file_id, augmentation)
+                VALUES (?, ?)
+                """,
+                from_target(target),
+            )
 
     # Populate mixture table
-    cur = con.cursor()
-    for mixture in mixtures:
-        cur.execute(
+    for m_id, mixture in enumerate(mixtures):
+        con.execute(
             """
-        INSERT INTO mixture (name, noise_file_id, noise_augmentation, noise_offset, noise_snr_gain, random_snr,
-        snr, samples, spectral_mask_id, spectral_mask_seed, target_snr_gain)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """,
-            from_mixture(mixture),
+            INSERT INTO mixture (id, name, noise_file_id, noise_augmentation, noise_offset, noise_snr_gain, random_snr,
+            snr, samples, spectral_mask_id, spectral_mask_seed, target_snr_gain)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (m_id + 1, *from_mixture(mixture)),
         )
 
-        mixture_id = cur.lastrowid
         for target in mixture.targets:
             target_id = con.execute(
                 """
-            SELECT target.id
-            FROM target
-            WHERE ? = target.file_id AND ? = target.augmentation AND ? = target.gain
+                SELECT target.id
+                FROM target
+                WHERE ? = target.file_id AND ? = target.augmentation
             """,
                 from_target(target),
             ).fetchone()[0]
             con.execute(
                 "INSERT INTO mixture_target (mixture_id, target_id) VALUES (?, ?)",
-                (mixture_id, target_id),
+                (m_id + 1, target_id),
             )
 
     con.commit()
     con.close()
 
+    return used_noise_files, used_noise_samples
 
-def update_mixture(mixdb: MixtureDatabase, mixture: Mixture, with_data: bool = False) -> tuple[Mixture, GenMixData]:
-    """Update mixture record with name and gains
 
-    :param mixdb: Mixture database
-    :param mixture: Mixture record
-    :param with_data: Return audio data
-    :return: Generated audio data (if requested)
-    """
+def update_mixture_table(location: str, m_id: int, with_data: bool = False, test: bool = False) -> GenMixData:
+    """Update mixture record with name and gains"""
     from .audio import get_next_noise
     from .augmentation import apply_gain
     from .datatypes import GenMixData
+    from .helpers import from_mixture
     from .helpers import get_target
+    from .mixdb import db_connection
 
+    mixdb = MixtureDatabase(location, test)
+    mixture = mixdb.mixture(m_id)
     mixture, targets_audio = _initialize_targets_audio(mixdb, mixture)
 
     noise_audio = _augmented_noise_audio(mixdb, mixture)
-    noise_audio = get_next_noise(audio=noise_audio, offset=mixture.noise.offset, length=mixture.samples)
+    noise_audio = get_next_noise(audio=noise_audio, offset=mixture.noise_offset, length=mixture.samples)
 
     # Apply IR and sum targets audio before initializing the mixture SNR gains
     target_audio = get_target(mixdb, mixture, targets_audio)
@@ -466,8 +501,29 @@ def update_mixture(mixdb: MixtureDatabase, mixture: Mixture, with_data: bool = F
 
     mixture.name = f"{int(mixture.name):0{mixdb.mixid_width}}"
 
+    con = db_connection(location=location, readonly=False, test=test)
+    con.execute(
+        """
+        UPDATE mixture SET  name=?,
+                            noise_file_id=?,
+                            noise_augmentation=?,
+                            noise_offset=?,
+                            noise_snr_gain=?,
+                            random_snr=?,
+                            snr=?,
+                            samples=?,
+                            spectral_mask_id=?,
+                            spectral_mask_seed=?,
+                            target_snr_gain=?
+        WHERE ? = mixture.id
+        """,
+        (*from_mixture(mixture), m_id + 1),
+    )
+    con.commit()
+    con.close()
+
     if not with_data:
-        return mixture, GenMixData()
+        return GenMixData()
 
     # Apply SNR gains
     targets_audio = [apply_gain(audio=target_audio, gain=mixture.target_snr_gain) for target_audio in targets_audio]
@@ -477,7 +533,7 @@ def update_mixture(mixdb: MixtureDatabase, mixture: Mixture, with_data: bool = F
     target_audio = get_target(mixdb, mixture, targets_audio)
     mixture_audio = target_audio + noise_audio
 
-    return mixture, GenMixData(
+    return GenMixData(
         mixture=mixture_audio,
         targets=targets_audio,
         target=target_audio,
@@ -502,7 +558,7 @@ def _augmented_noise_audio(mixdb: MixtureDatabase, mixture: Mixture) -> AudioT:
     return audio
 
 
-def _initialize_targets_audio(mixdb: MixtureDatabase, mixture: Mixture) -> tuple[Mixture, AudiosT]:
+def _initialize_targets_audio(mixdb: MixtureDatabase, mixture: Mixture) -> tuple[Mixture, list[AudioT]]:
     from .augmentation import apply_augmentation
     from .augmentation import pad_audio_to_length
 
@@ -517,13 +573,6 @@ def _initialize_targets_audio(mixdb: MixtureDatabase, mixture: Mixture) -> tuple
             )
         )
 
-        # target_gain is used to back out the gain augmentation in order to return the target audio
-        # to its normalized level when calculating truth (if needed).
-        if target.augmentation.gain is not None:
-            target.gain = round(10 ** (target.augmentation.gain / 20), ndigits=5)
-        else:
-            target.gain = 1
-
     mixture.samples = max([len(item) for item in targets_audio])
 
     for idx in range(len(targets_audio)):
@@ -540,14 +589,11 @@ def _initialize_mixture_gains(
     from sonusai.utils import asl_p56
     from sonusai.utils import db_to_linear
 
-    if mixture.snr < -96:
+    if mixture.is_noise_only:
         # Special case for zeroing out target data
         mixture.target_snr_gain = 0
         mixture.noise_snr_gain = 1
-        # Setting target_gain to zero will cause the truth to be all zeros.
-        for target in mixture.targets:
-            target.gain = 0
-    elif mixture.snr > 96:
+    elif mixture.is_target_only:
         # Special case for zeroing out noise data
         mixture.target_snr_gain = 1
         mixture.noise_snr_gain = 0
@@ -598,98 +644,20 @@ def _initialize_mixture_gains(
     return mixture
 
 
-def generate_mixtures(
-    noise_mix_mode: str,
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
-    all_snrs: list[UniversalSNRGenerator],
-    mixups: list[int],
-    num_classes: int,
-    feature_step_samples: int,
-    num_ir: int,
-) -> tuple[int, int, Mixtures]:
-    """Generate mixtures
-
-    :param noise_mix_mode: Noise mix mode
-    :param augmented_targets: List of augmented targets
-    :param target_files: List of target files
-    :param target_augmentations: List of target augmentations
-    :param noise_files: List of noise files
-    :param noise_augmentations: List of noise augmentations
-    :param spectral_masks: List of spectral masks
-    :param all_snrs: List of all SNRs
-    :param mixups: List of mixup values
-    :param num_classes: Number of classes
-    :param feature_step_samples: Number of samples in a feature step
-    :param num_ir: Number of impulse response files
-    :return: (Number of noise files used, number of noise samples used, list of mixture records)
-    """
-    if noise_mix_mode == "exhaustive":
-        return _exhaustive_noise_mix(
-            augmented_targets=augmented_targets,
-            target_files=target_files,
-            target_augmentations=target_augmentations,
-            noise_files=noise_files,
-            noise_augmentations=noise_augmentations,
-            spectral_masks=spectral_masks,
-            all_snrs=all_snrs,
-            mixups=mixups,
-            num_classes=num_classes,
-            feature_step_samples=feature_step_samples,
-            num_ir=num_ir,
-        )
-
-    if noise_mix_mode == "non-exhaustive":
-        return _non_exhaustive_noise_mix(
-            augmented_targets=augmented_targets,
-            target_files=target_files,
-            target_augmentations=target_augmentations,
-            noise_files=noise_files,
-            noise_augmentations=noise_augmentations,
-            spectral_masks=spectral_masks,
-            all_snrs=all_snrs,
-            mixups=mixups,
-            num_classes=num_classes,
-            feature_step_samples=feature_step_samples,
-            num_ir=num_ir,
-        )
-
-    if noise_mix_mode == "non-combinatorial":
-        return _non_combinatorial_noise_mix(
-            augmented_targets=augmented_targets,
-            target_files=target_files,
-            target_augmentations=target_augmentations,
-            noise_files=noise_files,
-            noise_augmentations=noise_augmentations,
-            spectral_masks=spectral_masks,
-            all_snrs=all_snrs,
-            mixups=mixups,
-            num_classes=num_classes,
-            feature_step_samples=feature_step_samples,
-            num_ir=num_ir,
-        )
-
-    raise ValueError(f"invalid noise_mix_mode: {noise_mix_mode}")
-
-
 def _exhaustive_noise_mix(
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
+    augmented_targets: list[AugmentedTarget],
+    target_files: list[TargetFile],
+    target_augmentations: list[AugmentationRule],
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
+    spectral_masks: list[SpectralMask],
     all_snrs: list[UniversalSNRGenerator],
     mixups: list[int],
     num_classes: int,
     feature_step_samples: int,
     num_ir: int,
-) -> tuple[int, int, Mixtures]:
-    """Use every noise/augmentation with every target/augmentation"""
+) -> tuple[int, int, list[Mixture]]:
+    """Use every noise/augmentation with every target/augmentation+interferences/augmentation"""
     from random import randint
 
     import numpy as np
@@ -697,12 +665,10 @@ def _exhaustive_noise_mix(
     from .augmentation import augmentation_from_rule
     from .augmentation import estimate_augmented_length_from_length
     from .datatypes import Mixture
-    from .datatypes import Mixtures
     from .datatypes import Noise
     from .datatypes import UniversalSNR
     from .targets import get_augmented_target_ids_for_mixup
 
-    mixtures: Mixtures = []
     m_id = 0
     used_noise_files = len(noise_files) * len(noise_augmentations)
     used_noise_samples = 0
@@ -717,6 +683,8 @@ def _exhaustive_noise_mix(
         )
         for mixup in mixups
     ]
+
+    mixtures: list[Mixture] = []
     for noise_file_id in range(len(noise_files)):
         for noise_augmentation_rule in noise_augmentations:
             noise_augmentation = augmentation_from_rule(noise_augmentation_rule, num_ir)
@@ -743,11 +711,8 @@ def _exhaustive_noise_mix(
                                 Mixture(
                                     targets=targets,
                                     name=str(m_id),
-                                    noise=Noise(
-                                        file_id=noise_file_id + 1,
-                                        augmentation=noise_augmentation,
-                                        offset=noise_offset,
-                                    ),
+                                    noise=Noise(file_id=noise_file_id + 1, augmentation=noise_augmentation),
+                                    noise_offset=noise_offset,
                                     samples=target_length,
                                     snr=UniversalSNR(value=snr.value, is_random=snr.is_random),
                                     spectral_mask_id=spectral_mask_id + 1,
@@ -763,32 +728,30 @@ def _exhaustive_noise_mix(
 
 
 def _non_exhaustive_noise_mix(
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
+    augmented_targets: list[AugmentedTarget],
+    target_files: list[TargetFile],
+    target_augmentations: list[AugmentationRule],
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
+    spectral_masks: list[SpectralMask],
     all_snrs: list[UniversalSNRGenerator],
     mixups: list[int],
     num_classes: int,
     feature_step_samples: int,
     num_ir: int,
-) -> tuple[int, int, Mixtures]:
-    """Cycle through every target/augmentation without necessarily using all noise/augmentation combinations
-    (reduced data set).
+) -> tuple[int, int, list[Mixture]]:
+    """Cycle through every target/augmentation+interferences/augmentation without necessarily using all
+    noise/augmentation combinations (reduced data set).
     """
     from random import randint
 
     import numpy as np
 
     from .datatypes import Mixture
-    from .datatypes import Mixtures
     from .datatypes import Noise
     from .datatypes import UniversalSNR
     from .targets import get_augmented_target_ids_for_mixup
 
-    mixtures: Mixtures = []
     m_id = 0
     used_noise_files = set()
     used_noise_samples = 0
@@ -806,6 +769,8 @@ def _non_exhaustive_noise_mix(
         )
         for mixup in mixups
     ]
+
+    mixtures: list[Mixture] = []
     for mixup in augmented_target_indices_for_mixups:
         for augmented_target_indices in mixup:
             targets, target_length = _get_target_info(
@@ -841,11 +806,8 @@ def _non_exhaustive_noise_mix(
                         Mixture(
                             targets=targets,
                             name=str(m_id),
-                            noise=Noise(
-                                file_id=noise_file_id + 1,
-                                augmentation=noise_augmentation,
-                                offset=noise_offset,
-                            ),
+                            noise=Noise(file_id=noise_file_id + 1, augmentation=noise_augmentation),
+                            noise_offset=noise_offset,
                             samples=target_length,
                             snr=UniversalSNR(value=snr.value, is_random=snr.is_random),
                             spectral_mask_id=spectral_mask_id + 1,
@@ -858,21 +820,21 @@ def _non_exhaustive_noise_mix(
 
 
 def _non_combinatorial_noise_mix(
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
+    augmented_targets: list[AugmentedTarget],
+    target_files: list[TargetFile],
+    target_augmentations: list[AugmentationRule],
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
+    spectral_masks: list[SpectralMask],
     all_snrs: list[UniversalSNRGenerator],
     mixups: list[int],
     num_classes: int,
     feature_step_samples: int,
     num_ir: int,
-) -> tuple[int, int, Mixtures]:
-    """Combine a target/augmentation with a single cut of a noise/augmentation non-exhaustively
-    (each target/augmentation does not use each noise/augmentation). Cut has random start and loop back to
-    beginning if end of noise/augmentation is reached.
+) -> tuple[int, int, list[Mixture]]:
+    """Combine a target/augmentation+interferences/augmentation with a single cut of a noise/augmentation
+    non-exhaustively (each target/augmentation+interferences/augmentation does not use each noise/augmentation).
+    Cut has random start and loop back to beginning if end of noise/augmentation is reached.
     """
     from random import choice
     from random import randint
@@ -880,12 +842,10 @@ def _non_combinatorial_noise_mix(
     import numpy as np
 
     from .datatypes import Mixture
-    from .datatypes import Mixtures
     from .datatypes import Noise
     from .datatypes import UniversalSNR
     from .targets import get_augmented_target_ids_for_mixup
 
-    mixtures: Mixtures = []
     m_id = 0
     used_noise_files = set()
     used_noise_samples = 0
@@ -902,6 +862,8 @@ def _non_combinatorial_noise_mix(
         )
         for mixup in mixups
     ]
+
+    mixtures: list[Mixture] = []
     for mixup in augmented_target_indices_for_mixups:
         for augmented_target_indices in mixup:
             targets, target_length = _get_target_info(
@@ -935,11 +897,8 @@ def _non_combinatorial_noise_mix(
                         Mixture(
                             targets=targets,
                             name=str(m_id),
-                            noise=Noise(
-                                file_id=noise_file_id + 1,
-                                augmentation=noise_augmentation,
-                                offset=choice(range(noise_length)),  # noqa: S311
-                            ),
+                            noise=Noise(file_id=noise_file_id + 1, augmentation=noise_augmentation),
+                            noise_offset=choice(range(noise_length)),  # noqa: S311
                             samples=target_length,
                             snr=UniversalSNR(value=snr.value, is_random=snr.is_random),
                             spectral_mask_id=spectral_mask_id + 1,
@@ -954,8 +913,8 @@ def _non_combinatorial_noise_mix(
 def _get_next_noise_indices(
     noise_file_id: int | None,
     noise_augmentation_id: int | None,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
     num_ir: int,
 ) -> tuple[int, int, Augmentation, int]:
     from .augmentation import augmentation_from_rule
@@ -984,8 +943,8 @@ def _get_next_noise_offset(
     noise_augmentation_id: int | None,
     noise_offset: int | None,
     target_length: int,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
+    noise_files: list[NoiseFile],
+    noise_augmentations: list[AugmentationRule],
     num_ir: int,
 ) -> tuple[int, int, Augmentation, int]:
     from .augmentation import augmentation_from_rule
@@ -1018,18 +977,16 @@ def _get_next_noise_offset(
 
 def _get_target_info(
     augmented_target_ids: list[int],
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
+    augmented_targets: list[AugmentedTarget],
+    target_files: list[TargetFile],
+    target_augmentations: list[AugmentationRule],
     feature_step_samples: int,
     num_ir: int,
-) -> tuple[Targets, int]:
+) -> tuple[list[Target], int]:
     from .augmentation import augmentation_from_rule
     from .augmentation import estimate_augmented_length_from_length
-    from .datatypes import Target
-    from .datatypes import Targets
 
-    mixups: Targets = []
+    mixups: list[Target] = []
     target_length = 0
     for idx in augmented_target_ids:
         tfi = augmented_targets[idx].target_id
@@ -1073,7 +1030,7 @@ def _get_textgrid_tiers_from_target_file(target_file: str) -> list[str]:
     return sorted(tg.tierNames)
 
 
-def _populate_speaker_table(location: str, target_files: TargetFiles, test: bool = False) -> None:
+def _populate_speaker_table(location: str, target_files: list[TargetFile], test: bool = False) -> None:
     """Populate speaker table"""
     import json
     from pathlib import Path
@@ -1122,7 +1079,7 @@ def _populate_speaker_table(location: str, target_files: TargetFiles, test: bool
         if description[0] not in ("id", "parent")
     ]
     con.execute(
-        "UPDATE top SET speaker_metadata_tiers=? WHERE top.id = ?",
+        "UPDATE top SET speaker_metadata_tiers=? WHERE ? = top.id",
         (json.dumps(tiers), 1),
     )
 
@@ -1133,7 +1090,7 @@ def _populate_speaker_table(location: str, target_files: TargetFiles, test: bool
     con.close()
 
 
-def _populate_truth_config_table(location: str, target_files: TargetFiles, test: bool = False) -> None:
+def _populate_truth_config_table(location: str, target_files: list[TargetFile], test: bool = False) -> None:
     """Populate truth_config table"""
     import json