sonusai 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

sonusai/mixture/generation.py

@@ -8,6 +8,7 @@ from ..datatypes import Source
 from ..datatypes import SourceFile
 from ..datatypes import SourcesAudioT
 from ..datatypes import UniversalSNRGenerator
+from .db import SQLiteDatabase
 from .mixdb import MixtureDatabase
 
 
@@ -18,186 +19,173 @@ def config_file(location: str) -> str:
 
 
 def initialize_db(location: str, test: bool = False, verbose: bool = False) -> None:
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, create=True, test=test, verbose=verbose)
-
-    con.execute("""
-    CREATE TABLE truth_config(
-    id INTEGER PRIMARY KEY NOT NULL,
-    config TEXT NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE truth_parameters(
-    id INTEGER PRIMARY KEY NOT NULL,
-    category TEXT NOT NULL,
-    name TEXT NOT NULL,
-    parameters INTEGER)
-    """)
-
-    con.execute("""
-    CREATE TABLE source_file (
-    id INTEGER PRIMARY KEY NOT NULL,
-    category TEXT NOT NULL,
-    class_indices TEXT,
-    level_type TEXT NOT NULL,
-    name TEXT NOT NULL,
-    samples INTEGER NOT NULL,
-    speaker_id INTEGER,
-    FOREIGN KEY(speaker_id) REFERENCES speaker (id))
-    """)
-
-    con.execute("""
-    CREATE TABLE ir_file (
-    id INTEGER PRIMARY KEY NOT NULL,
-    delay INTEGER NOT NULL,
-    name TEXT NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE ir_tag (
-    id INTEGER PRIMARY KEY NOT NULL,
-    tag TEXT NOT NULL UNIQUE)
-    """)
-
-    con.execute("""
-    CREATE TABLE ir_file_ir_tag (
-    file_id INTEGER NOT NULL,
-    tag_id INTEGER NOT NULL,
-    FOREIGN KEY(file_id) REFERENCES ir_file (id),
-    FOREIGN KEY(tag_id) REFERENCES ir_tag (id))
-    """)
-
-    con.execute("""
-    CREATE TABLE speaker (
-    id INTEGER PRIMARY KEY NOT NULL,
-    parent TEXT NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE top (
-    id INTEGER PRIMARY KEY NOT NULL,
-    asr_configs TEXT NOT NULL,
-    class_balancing BOOLEAN NOT NULL,
-    feature TEXT NOT NULL,
-    mixid_width INTEGER NOT NULL,
-    num_classes INTEGER NOT NULL,
-    seed INTEGER NOT NULL,
-    speaker_metadata_tiers TEXT NOT NULL,
-    textgrid_metadata_tiers TEXT NOT NULL,
-    version INTEGER NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE class_label (
-    id INTEGER PRIMARY KEY NOT NULL,
-    label TEXT NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE class_weights_threshold (
-    id INTEGER PRIMARY KEY NOT NULL,
-    threshold FLOAT NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE spectral_mask (
-    id INTEGER PRIMARY KEY NOT NULL,
-    f_max_width INTEGER NOT NULL,
-    f_num INTEGER NOT NULL,
-    t_max_percent INTEGER NOT NULL,
-    t_max_width INTEGER NOT NULL,
-    t_num INTEGER NOT NULL)
-    """)
-
-    con.execute("""
-    CREATE TABLE source_file_truth_config (
-    source_file_id INTEGER NOT NULL,
-    truth_config_id INTEGER NOT NULL,
-    FOREIGN KEY(source_file_id) REFERENCES source_file (id),
-    FOREIGN KEY(truth_config_id) REFERENCES truth_config (id))
-    """)
-
-    con.execute("""
-    CREATE TABLE source (
-    id INTEGER PRIMARY KEY NOT NULL,
-    effects TEXT NOT NULL,
-    file_id INTEGER NOT NULL,
-    pre_tempo FLOAT NOT NULL,
-    repeat BOOLEAN NOT NULL,
-    snr FLOAT NOT NULL,
-    snr_gain FLOAT NOT NULL,
-    snr_random BOOLEAN NOT NULL,
-    start INTEGER NOT NULL,
-    UNIQUE(effects, file_id, pre_tempo, repeat, snr, snr_gain, snr_random, start),
-    FOREIGN KEY(file_id) REFERENCES source_file (id))
-    """)
-
-    con.execute("""
-    CREATE TABLE mixture (
-    id INTEGER PRIMARY KEY NOT NULL,
-    name TEXT NOT NULL,
-    samples INTEGER NOT NULL,
-    spectral_mask_id INTEGER NOT NULL,
-    spectral_mask_seed INTEGER NOT NULL,
-    FOREIGN KEY(spectral_mask_id) REFERENCES spectral_mask (id))
-    """)
-
-    con.execute("""
-    CREATE TABLE mixture_source (
-    mixture_id INTEGER NOT NULL,
-    source_id INTEGER NOT NULL,
-    FOREIGN KEY(mixture_id) REFERENCES mixture (id),
-    FOREIGN KEY(source_id) REFERENCES source (id))
-    """)
-
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, create=True, test=test, verbose=verbose) as c:
+        c.execute("""
+        CREATE TABLE truth_config(
+        id INTEGER PRIMARY KEY NOT NULL,
+        config TEXT NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE truth_parameters(
+        id INTEGER PRIMARY KEY NOT NULL,
+        category TEXT NOT NULL,
+        name TEXT NOT NULL,
+        parameters INTEGER)
+        """)
+
+        c.execute("""
+        CREATE TABLE source_file (
+        id INTEGER PRIMARY KEY NOT NULL,
+        category TEXT NOT NULL,
+        class_indices TEXT,
+        level_type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        samples INTEGER NOT NULL,
+        speaker_id INTEGER,
+        FOREIGN KEY(speaker_id) REFERENCES speaker (id))
+        """)
+
+        c.execute("""
+        CREATE TABLE ir_file (
+        id INTEGER PRIMARY KEY NOT NULL,
+        delay INTEGER NOT NULL,
+        name TEXT NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE ir_tag (
+        id INTEGER PRIMARY KEY NOT NULL,
+        tag TEXT NOT NULL UNIQUE)
+        """)
+
+        c.execute("""
+        CREATE TABLE ir_file_ir_tag (
+        file_id INTEGER NOT NULL,
+        tag_id INTEGER NOT NULL,
+        FOREIGN KEY(file_id) REFERENCES ir_file (id),
+        FOREIGN KEY(tag_id) REFERENCES ir_tag (id))
+        """)
+
+        c.execute("""
+        CREATE TABLE speaker (
+        id INTEGER PRIMARY KEY NOT NULL,
+        parent TEXT NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE top (
+        id INTEGER PRIMARY KEY NOT NULL,
+        asr_configs TEXT NOT NULL,
+        class_balancing BOOLEAN NOT NULL,
+        feature TEXT NOT NULL,
+        mixid_width INTEGER NOT NULL,
+        num_classes INTEGER NOT NULL,
+        seed INTEGER NOT NULL,
+        speaker_metadata_tiers TEXT NOT NULL,
+        textgrid_metadata_tiers TEXT NOT NULL,
+        version INTEGER NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE class_label (
+        id INTEGER PRIMARY KEY NOT NULL,
+        label TEXT NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE class_weights_threshold (
+        id INTEGER PRIMARY KEY NOT NULL,
+        threshold FLOAT NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE spectral_mask (
+        id INTEGER PRIMARY KEY NOT NULL,
+        f_max_width INTEGER NOT NULL,
+        f_num INTEGER NOT NULL,
+        t_max_percent INTEGER NOT NULL,
+        t_max_width INTEGER NOT NULL,
+        t_num INTEGER NOT NULL)
+        """)
+
+        c.execute("""
+        CREATE TABLE source_file_truth_config (
+        source_file_id INTEGER NOT NULL,
+        truth_config_id INTEGER NOT NULL,
+        FOREIGN KEY(source_file_id) REFERENCES source_file (id),
+        FOREIGN KEY(truth_config_id) REFERENCES truth_config (id))
+        """)
+
+        c.execute("""
+        CREATE TABLE source (
+        id INTEGER PRIMARY KEY NOT NULL,
+        effects TEXT NOT NULL,
+        file_id INTEGER NOT NULL,
+        pre_tempo FLOAT NOT NULL,
+        repeat BOOLEAN NOT NULL,
+        snr FLOAT NOT NULL,
+        snr_gain FLOAT NOT NULL,
+        snr_random BOOLEAN NOT NULL,
+        start INTEGER NOT NULL,
+        UNIQUE(effects, file_id, pre_tempo, repeat, snr, snr_gain, snr_random, start),
+        FOREIGN KEY(file_id) REFERENCES source_file (id))
+        """)
+
+        c.execute("""
+        CREATE TABLE mixture (
+        id INTEGER PRIMARY KEY NOT NULL,
+        name TEXT NOT NULL,
+        samples INTEGER NOT NULL,
+        spectral_mask_id INTEGER NOT NULL,
+        spectral_mask_seed INTEGER NOT NULL,
+        FOREIGN KEY(spectral_mask_id) REFERENCES spectral_mask (id))
+        """)
+
+        c.execute("""
+        CREATE TABLE mixture_source (
+        mixture_id INTEGER NOT NULL,
+        source_id INTEGER NOT NULL,
+        FOREIGN KEY(mixture_id) REFERENCES mixture (id),
+        FOREIGN KEY(source_id) REFERENCES source (id))
+        """)
 
 
 def populate_top_table(location: str, config: dict, test: bool = False, verbose: bool = False) -> None:
-    """Populate top table"""
+    """Populate the top table"""
     import json
 
     from .constants import MIXDB_VERSION
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.execute(
-        """
-    INSERT INTO top (id, asr_configs, class_balancing, feature, mixid_width, num_classes,
-    seed, speaker_metadata_tiers, textgrid_metadata_tiers, version)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    """,
-        (
-            1,
-            json.dumps(config["asr_configs"]),
-            config["class_balancing"],
-            config["feature"],
-            0,
-            config["num_classes"],
-            config["seed"],
-            "",
-            "",
-            MIXDB_VERSION,
-        ),
-    )
-    con.commit()
-    con.close()
+
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.execute(
+            """
+        INSERT INTO top (id, asr_configs, class_balancing, feature, mixid_width, num_classes,
+        seed, speaker_metadata_tiers, textgrid_metadata_tiers, version)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+            (
+                1,
+                json.dumps(config["asr_configs"]),
+                config["class_balancing"],
+                config["feature"],
+                0,
+                config["num_classes"],
+                config["seed"],
+                "",
+                "",
+                MIXDB_VERSION,
+            ),
+        )
 
 
 def populate_class_label_table(location: str, config: dict, test: bool = False, verbose: bool = False) -> None:
     """Populate class_label table"""
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.executemany(
-        "INSERT INTO class_label (label) VALUES (?)",
-        [(item,) for item in config["class_labels"]],
-    )
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.executemany(
+            "INSERT INTO class_label (label) VALUES (?)",
+            [(item,) for item in config["class_labels"]],
+        )
 
 
 def populate_class_weights_threshold_table(
@@ -207,8 +195,6 @@ def populate_class_weights_threshold_table(
     verbose: bool = False,
 ) -> None:
     """Populate class_weights_threshold table"""
-    from .mixdb import db_connection
-
     class_weights_threshold = config["class_weights_threshold"]
     num_classes = config["num_classes"]
 
@@ -221,61 +207,53 @@ def populate_class_weights_threshold_table(
     if len(class_weights_threshold) != num_classes:
         raise ValueError(f"invalid class_weights_threshold length: {len(class_weights_threshold)}")
 
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.executemany(
-        "INSERT INTO class_weights_threshold (threshold) VALUES (?)",
-        [(item,) for item in class_weights_threshold],
-    )
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.executemany(
+            "INSERT INTO class_weights_threshold (threshold) VALUES (?)",
+            [(item,) for item in class_weights_threshold],
+        )
 
 
 def populate_spectral_mask_table(location: str, config: dict, test: bool = False, verbose: bool = False) -> None:
     """Populate spectral_mask table"""
     from .config import get_spectral_masks
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.executemany(
-        """
-    INSERT INTO spectral_mask (f_max_width, f_num, t_max_percent, t_max_width, t_num) VALUES (?, ?, ?, ?, ?)
-    """,
-        [
-            (
-                item.f_max_width,
-                item.f_num,
-                item.t_max_percent,
-                item.t_max_width,
-                item.t_num,
-            )
-            for item in get_spectral_masks(config)
-        ],
-    )
-    con.commit()
-    con.close()
+
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.executemany(
+            """
+        INSERT INTO spectral_mask (f_max_width, f_num, t_max_percent, t_max_width, t_num) VALUES (?, ?, ?, ?, ?)
+        """,
+            [
+                (
+                    item.f_max_width,
+                    item.f_num,
+                    item.t_max_percent,
+                    item.t_max_width,
+                    item.t_num,
+                )
+                for item in get_spectral_masks(config)
+            ],
+        )
 
 
 def populate_truth_parameters_table(location: str, config: dict, test: bool = False, verbose: bool = False) -> None:
     """Populate truth_parameters table"""
     from .config import get_truth_parameters
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.executemany(
-        """
-    INSERT INTO truth_parameters (category, name, parameters) VALUES (?, ?, ?)
-    """,
-        [
-            (
-                item.category,
-                item.name,
-                item.parameters,
-            )
-            for item in get_truth_parameters(config)
-        ],
-    )
-    con.commit()
-    con.close()
+
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.executemany(
+            """
+        INSERT INTO truth_parameters (category, name, parameters) VALUES (?, ?, ?)
+        """,
+            [
+                (
+                    item.category,
+                    item.name,
+                    item.parameters,
+                )
+                for item in get_truth_parameters(config)
+            ],
+        )
 
 
 def populate_source_file_table(
@@ -284,72 +262,65 @@ def populate_source_file_table(
     test: bool = False,
     verbose: bool = False,
 ) -> None:
-    """Populate source file table"""
+    """Populate the source file table"""
     import json
     from pathlib import Path
 
-    from .mixdb import db_connection
-
     _populate_truth_config_table(location, files, test, verbose)
     _populate_speaker_table(location, files, test, verbose)
 
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        textgrid_metadata_tiers: set[str] = set()
+        for file in files:
+            # Get TextGrid tiers for source file and add to collection
+            tiers = _get_textgrid_tiers_from_source_file(file.name)
+            for tier in tiers:
+                textgrid_metadata_tiers.add(tier)
+
+            # Get truth settings for file
+            truth_config_ids: list[int] = []
+            if file.truth_configs:
+                for name, config in file.truth_configs.items():
+                    ts = json.dumps({"name": name} | config.to_dict())
+                    c.execute(
+                        "SELECT truth_config.id FROM truth_config WHERE ? = truth_config.config",
+                        (ts,),
+                    )
+                    truth_config_ids.append(c.fetchone()[0])
 
-    cur = con.cursor()
-    textgrid_metadata_tiers: set[str] = set()
-    for file in files:
-        # Get TextGrid tiers for source file and add to collection
-        tiers = _get_textgrid_tiers_from_source_file(file.name)
-        for tier in tiers:
-            textgrid_metadata_tiers.add(tier)
+            # Get speaker_id for source file
+            c.execute("SELECT speaker.id FROM speaker WHERE ? = speaker.parent", (Path(file.name).parent.as_posix(),))
+            result = c.fetchone()
+            speaker_id = None
+            if result is not None:
+                speaker_id = result[0]
 
-        # Get truth settings for file
-        truth_config_ids: list[int] = []
-        if file.truth_configs:
-            for name, config in file.truth_configs.items():
-                ts = json.dumps({"name": name} | config.to_dict())
-                cur.execute(
-                    "SELECT truth_config.id FROM truth_config WHERE ? = truth_config.config",
-                    (ts,),
+            # Add entry
+            c.execute(
+                """
+                INSERT INTO source_file (category, class_indices, level_type, name, samples, speaker_id)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    file.category,
+                    json.dumps(file.class_indices),
+                    file.level_type,
+                    file.name,
+                    file.samples,
+                    speaker_id,
+                ),
+            )
+            source_file_id = c.lastrowid
+            for truth_config_id in truth_config_ids:
+                c.execute(
+                    "INSERT INTO source_file_truth_config (source_file_id, truth_config_id) VALUES (?, ?)",
+                    (source_file_id, truth_config_id),
                 )
-                truth_config_ids.append(cur.fetchone()[0])
 
-        # Get speaker_id for source file
-        cur.execute("SELECT speaker.id FROM speaker WHERE ? = speaker.parent", (Path(file.name).parent.as_posix(),))
-        result = cur.fetchone()
-        speaker_id = None
-        if result is not None:
-            speaker_id = result[0]
-
-        # Add entry
-        cur.execute(
-            """
-            INSERT INTO source_file (category, class_indices, level_type, name, samples, speaker_id)
-            VALUES (?, ?, ?, ?, ?, ?)
-            """,
-            (
-                file.category,
-                json.dumps(file.class_indices),
-                file.level_type,
-                file.name,
-                file.samples,
-                speaker_id,
-            ),
+        # Update textgrid_metadata_tiers in the top table
+        c.execute(
+            "UPDATE top SET textgrid_metadata_tiers=? WHERE ? = id", (json.dumps(sorted(textgrid_metadata_tiers)), 1)
         )
-        source_file_id = cur.lastrowid
-        for truth_config_id in truth_config_ids:
-            cur.execute(
-                "INSERT INTO source_file_truth_config (source_file_id, truth_config_id) VALUES (?, ?)",
-                (source_file_id, truth_config_id),
-            )
-
-    # Update textgrid_metadata_tiers in the top table
-    con.execute(
-        "UPDATE top SET textgrid_metadata_tiers=? WHERE ? = id", (json.dumps(sorted(textgrid_metadata_tiers)), 1)
-    )
-
-    con.commit()
-    con.close()
 
 
 def populate_impulse_response_file_table(
@@ -358,40 +329,30 @@ def populate_impulse_response_file_table(
     test: bool = False,
     verbose: bool = False,
 ) -> None:
-    """Populate impulse response file table"""
-    from .mixdb import db_connection
-
+    """Populate the impulse response file table"""
     _populate_impulse_response_tag_table(location, files, test, verbose)
 
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-
-    cur = con.cursor()
-    for file in files:
-        # Get tags for file
-        tag_ids: list[int] = []
-        for tag in file.tags:
-            cur.execute("SELECT id FROM ir_tag WHERE ? = tag", (tag,))
-            tag_ids.append(cur.fetchone()[0])
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        for file in files:
+            # Get the tags for the file
+            tag_ids: list[int] = []
+            for tag in file.tags:
+                c.execute("SELECT id FROM ir_tag WHERE ? = tag", (tag,))
+                tag_ids.append(c.fetchone()[0])
 
-        cur.execute("INSERT INTO ir_file (delay, name) VALUES (?, ?)", (file.delay, file.name))
+            c.execute("INSERT INTO ir_file (delay, name) VALUES (?, ?)", (file.delay, file.name))
 
-        file_id = cur.lastrowid
-        for tag_id in tag_ids:
-            cur.execute("INSERT INTO ir_file_ir_tag (file_id, tag_id) VALUES (?, ?)", (file_id, tag_id))
-
-    con.commit()
-    con.close()
+            file_id = c.lastrowid
+            for tag_id in tag_ids:
+                c.execute("INSERT INTO ir_file_ir_tag (file_id, tag_id) VALUES (?, ?)", (file_id, tag_id))
 
 
 def update_mixid_width(location: str, num_mixtures: int, test: bool = False, verbose: bool = False) -> None:
     """Update the mixid width"""
     from ..utils.max_text_width import max_text_width
-    from .mixdb import db_connection
 
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-    con.execute("UPDATE top SET mixid_width=? WHERE ? = id", (max_text_width(num_mixtures), 1))
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.execute("UPDATE top SET mixid_width=? WHERE ? = id", (max_text_width(num_mixtures), 1))
 
 
 def generate_mixtures(
@@ -447,53 +408,49 @@ def populate_mixture_table(
     from ..utils.parallel import track
     from .helpers import from_mixture
     from .helpers import from_source
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
 
-    # Populate source table
     if logging:
         logger.info("Populating mixture and source tables")
-    for mixture in track(mixtures, disable=not show_progress):
-        m_id = int(mixture.name) + 1
-        con.execute(
-            """
-            INSERT INTO mixture (id, name, samples, spectral_mask_id, spectral_mask_seed)
-            VALUES (?, ?, ?, ?, ?)
-            """,
-            (m_id, *from_mixture(mixture)),
-        )
 
-        for source in mixture.all_sources.values():
-            con.execute(
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        # Populate source table
+        for mixture in track(mixtures, disable=not show_progress):
+            m_id = int(mixture.name) + 1
+            c.execute(
                 """
-            INSERT OR IGNORE INTO source (effects, file_id, pre_tempo, repeat, snr, snr_gain, snr_random, start)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            """,
-                from_source(source),
+                INSERT INTO mixture (id, name, samples, spectral_mask_id, spectral_mask_seed)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (m_id, *from_mixture(mixture)),
             )
 
-            source_id = con.execute(
-                """
-                SELECT id
-                FROM source
-                WHERE ? = effects
-                AND ? = file_id
-                AND ? = pre_tempo
-                AND ? = repeat
-                AND ? = snr
-                AND ? = snr_gain
-                AND ? = snr_random
-                AND ? = start
-            """,
-                from_source(source),
-            ).fetchone()[0]
-            con.execute("INSERT INTO mixture_source (mixture_id, source_id) VALUES (?, ?)", (m_id, source_id))
+            for source in mixture.all_sources.values():
+                c.execute(
+                    """
+                INSERT OR IGNORE INTO source (effects, file_id, pre_tempo, repeat, snr, snr_gain, snr_random, start)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                    from_source(source),
+                )
 
-    if logging:
-        logger.info("Closing mixture and source tables")
-    con.commit()
-    con.close()
+                source_id = c.execute(
+                    """
+                    SELECT id
+                    FROM source
+                    WHERE ? = effects
+                    AND ? = file_id
+                    AND ? = pre_tempo
+                    AND ? = repeat
+                    AND ? = snr
+                    AND ? = snr_gain
+                    AND ? = snr_random
+                    AND ? = start
+                """,
+                    from_source(source),
+                ).fetchone()[0]
+                c.execute("INSERT INTO mixture_source (mixture_id, source_id) VALUES (?, ?)", (m_id, source_id))
+        if logging:
+            logger.info("Closing mixture and source tables")
 
 
 def update_mixture(mixdb: MixtureDatabase, mixture: Mixture, with_data: bool = False) -> tuple[Mixture, GenMixData]:
@@ -867,14 +824,13 @@ def _populate_speaker_table(
     test: bool = False,
     verbose: bool = False,
 ) -> None:
-    """Populate speaker table"""
+    """Populate the speaker table"""
     import json
     from pathlib import Path
 
     import yaml
 
     from ..utils.tokenized_shell_vars import tokenized_expand
-    from .mixdb import db_connection
 
     # Determine columns for speaker table
     all_parents = {Path(file.name).parent for file in source_files}
@@ -891,36 +847,32 @@ def _populate_speaker_table(
             new_columns.append(column)
     new_columns = sorted(set(new_columns))
 
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-
-    for new_column in new_columns:
-        con.execute(f"ALTER TABLE speaker ADD COLUMN {new_column} TEXT")
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        for new_column in new_columns:
+            c.execute(f"ALTER TABLE speaker ADD COLUMN {new_column} TEXT")
 
-    # Populate speaker table
-    speaker_rows: list[tuple[str, ...]] = []
-    for key in speakers:
-        entry = (speakers[key].get(column, None) for column in new_columns)
-        speaker_rows.append((key.as_posix(), *entry))  # type: ignore[arg-type]
+        # Populate speaker table
+        speaker_rows: list[tuple[str, ...]] = []
+        for key in speakers:
+            entry = (speakers[key].get(column, None) for column in new_columns)
+            speaker_rows.append((key.as_posix(), *entry))  # type: ignore[arg-type]
 
-    column_ids = ", ".join(["parent", *new_columns])
-    column_values = ", ".join(["?"] * (len(new_columns) + 1))
-    con.executemany(f"INSERT INTO speaker ({column_ids}) VALUES ({column_values})", speaker_rows)
+        column_ids = ", ".join(["parent", *new_columns])
+        column_values = ", ".join(["?"] * (len(new_columns) + 1))
+        c.executemany(f"INSERT INTO speaker ({column_ids}) VALUES ({column_values})", speaker_rows)
 
-    con.execute("CREATE INDEX speaker_parent_idx ON speaker (parent)")
+        c.execute("CREATE INDEX speaker_parent_idx ON speaker (parent)")
 
-    # Update speaker_metadata_tiers in the top table
-    tiers = [
-        description[0]
-        for description in con.execute("SELECT * FROM speaker").description
-        if description[0] not in ("id", "parent")
-    ]
-    con.execute("UPDATE top SET speaker_metadata_tiers=? WHERE ? = id", (json.dumps(tiers), 1))
+        # Update speaker_metadata_tiers in the top table
+        tiers = [
+            description[0]
+            for description in c.execute("SELECT * FROM speaker").description
+            if description[0] not in ("id", "parent")
+        ]
+        c.execute("UPDATE top SET speaker_metadata_tiers=? WHERE ? = id", (json.dumps(tiers), 1))
 
-    if "speaker_id" in tiers:
-        con.execute("CREATE INDEX speaker_speaker_id_idx ON source_file (speaker_id)")
-
-    con.commit()
-    con.close()
+        if "speaker_id" in tiers:
+            c.execute("CREATE INDEX speaker_speaker_id_idx ON source_file (speaker_id)")
 
 
 def _populate_truth_config_table(
@@ -932,24 +884,18 @@ def _populate_truth_config_table(
     """Populate truth_config table"""
     import json
 
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-
-    # Populate truth_config table
-    truth_configs: list[str] = []
-    for file in source_files:
-        for name, config in file.truth_configs.items():
-            ts = json.dumps({"name": name} | config.to_dict())
-            if ts not in truth_configs:
-                truth_configs.append(ts)
-    con.executemany(
-        "INSERT INTO truth_config (config) VALUES (?)",
-        [(item,) for item in truth_configs],
-    )
-
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        # Populate truth_config table
+        truth_configs: list[str] = []
+        for file in source_files:
+            for name, config in file.truth_configs.items():
+                ts = json.dumps({"name": name} | config.to_dict())
+                if ts not in truth_configs:
+                    truth_configs.append(ts)
+        c.executemany(
+            "INSERT INTO truth_config (config) VALUES (?)",
+            [(item,) for item in truth_configs],
+        )
 
 
 def _populate_impulse_response_tag_table(
@@ -959,14 +905,8 @@ def _populate_impulse_response_tag_table(
     verbose: bool = False,
 ) -> None:
     """Populate ir_tag table"""
-    from .mixdb import db_connection
-
-    con = db_connection(location=location, readonly=False, test=test, verbose=verbose)
-
-    con.executemany(
-        "INSERT INTO ir_tag (tag) VALUES (?)",
-        [(tag,) for tag in {tag for file in files for tag in file.tags}],
-    )
-
-    con.commit()
-    con.close()
+    with SQLiteDatabase(location=location, readonly=False, test=test, verbose=verbose) as c:
+        c.executemany(
+            "INSERT INTO ir_tag (tag) VALUES (?)",
+            [(tag,) for tag in {tag for file in files for tag in file.tags}],
+        )