sonusai 0.19.6__py3-none-any.whl → 0.19.8__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,73 @@ 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"""
-    from .helpers import from_mixture
-    from .helpers import from_target
-    from .mixdb import db_connection
-
-    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)
-
-    # Populate mixture table
-    cur = con.cursor()
-    for mixture in mixtures:
-        cur.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),
-        )
-
-        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
-            """,
-                from_target(target),
-            ).fetchone()[0]
-            con.execute(
-                "INSERT INTO mixture_target (mixture_id, target_id) VALUES (?, ?)",
-                (mixture_id, target_id),
-            )
-
-    con.commit()
-    con.close()
+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"""
+    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 = func(
+        location=location,
+        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,
+        test=test,
+    )
 
+    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 +459,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 +491,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 +516,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 +531,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 +547,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,97 +602,21 @@ 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,
+    location: 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,
-) -> tuple[int, int, Mixtures]:
+    test: bool = False,
+) -> tuple[int, int]:
     """Use every noise/augmentation with every target/augmentation"""
     from random import randint
 
@@ -697,12 +625,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
@@ -739,42 +665,44 @@ def _exhaustive_noise_mix(
 
                     for spectral_mask_id in range(len(spectral_masks)):
                         for snr in all_snrs:
-                            mixtures.append(
-                                Mixture(
+                            _insert_mixture_record(
+                                location=location,
+                                m_id=m_id,
+                                mixture=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,
                                     spectral_mask_seed=randint(0, np.iinfo("i").max),  # noqa: S311
-                                )
+                                ),
+                                test=test,
                             )
                             m_id += 1
 
                             noise_offset = int((noise_offset + target_length) % noise_length)
                             used_noise_samples += target_length
 
-    return used_noise_files, used_noise_samples, mixtures
+    return used_noise_files, used_noise_samples
 
 
 def _non_exhaustive_noise_mix(
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
+    location: 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,
-) -> tuple[int, int, Mixtures]:
+    test: bool = False,
+) -> tuple[int, int]:
     """Cycle through every target/augmentation without necessarily using all noise/augmentation combinations
     (reduced data set).
     """
@@ -783,12 +711,10 @@ def _non_exhaustive_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
@@ -837,39 +763,41 @@ def _non_exhaustive_noise_mix(
 
                     used_noise_files.add(f"{noise_file_id}_{noise_augmentation_id}")
 
-                    mixtures.append(
-                        Mixture(
+                    _insert_mixture_record(
+                        location=location,
+                        m_id=m_id,
+                        mixture=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,
                             spectral_mask_seed=randint(0, np.iinfo("i").max),  # noqa: S311
-                        )
+                        ),
+                        test=test,
                     )
                     m_id += 1
 
-    return len(used_noise_files), used_noise_samples, mixtures
+    return len(used_noise_files), used_noise_samples
 
 
 def _non_combinatorial_noise_mix(
-    augmented_targets: AugmentedTargets,
-    target_files: TargetFiles,
-    target_augmentations: AugmentationRules,
-    noise_files: NoiseFiles,
-    noise_augmentations: AugmentationRules,
-    spectral_masks: SpectralMasks,
+    location: 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,
-) -> tuple[int, int, Mixtures]:
+    test: bool = False,
+) -> tuple[int, int]:
     """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.
@@ -880,12 +808,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
@@ -931,31 +857,31 @@ def _non_combinatorial_noise_mix(
 
                     used_noise_files.add(f"{noise_file_id}_{noise_augmentation_id}")
 
-                    mixtures.append(
-                        Mixture(
+                    _insert_mixture_record(
+                        location=location,
+                        m_id=m_id,
+                        mixture=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,
                             spectral_mask_seed=randint(0, np.iinfo("i").max),  # noqa: S311
-                        )
+                        ),
+                        test=test,
                     )
                     m_id += 1
 
-    return len(used_noise_files), used_noise_samples, mixtures
+    return len(used_noise_files), used_noise_samples
 
 
 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 +910,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 +944,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
@@ -1049,6 +973,49 @@ def _get_target_info(
     return mixups, target_length
 
 
+def _insert_mixture_record(location: str, m_id: int, mixture: Mixture, test: bool = False) -> None:
+    from .helpers import from_mixture
+    from .helpers import from_target
+    from .mixdb import db_connection
+
+    con = db_connection(location=location, readonly=False, test=test)
+    # Populate target table
+    for target in mixture.targets:
+        con.execute(
+            """
+            INSERT OR IGNORE INTO target (file_id, augmentation)
+            VALUES (?, ?)
+            """,
+            from_target(target),
+        )
+
+    # Populate mixture table
+    con.execute(
+        """
+        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)),
+    )
+
+    for target in mixture.targets:
+        target_id = con.execute(
+            """
+            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 (?, ?)",
+            (m_id + 1, target_id),
+        )
+    con.commit()
+    con.close()
+
+
 def get_all_snrs_from_config(config: dict) -> list[UniversalSNRGenerator]:
     from .datatypes import UniversalSNRGenerator
 
@@ -1073,7 +1040,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 +1089,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 +1100,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