sonusai 0.17.3__py3-none-any.whl → 0.18.1__py3-none-any.whl

sonusai/mixture/mixdb.py

@@ -1,15 +1,12 @@
 from functools import cached_property
 from functools import lru_cache
 from functools import partial
-from pathlib import Path
 from sqlite3 import Connection
 from sqlite3 import Cursor
 from typing import Any
 from typing import Callable
 from typing import Optional
 
-from praatio import textgrid
-from praatio.utilities.constants import Interval
 from sonusai.mixture.datatypes import AudioF
 from sonusai.mixture.datatypes import AudioT
 from sonusai.mixture.datatypes import AudiosF
@@ -33,7 +30,6 @@ from sonusai.mixture.datatypes import TargetFiles
 from sonusai.mixture.datatypes import TransformConfig
 from sonusai.mixture.datatypes import Truth
 from sonusai.mixture.datatypes import UniversalSNR
-from sonusai.mixture.tokenized_shell_vars import tokenized_expand
 
 
 def db_file(location: str, test: bool = False) -> str:
@@ -87,14 +83,12 @@ class MixtureDatabase:
     def __init__(self, location: str, test: bool = False) -> None:
         self.location = location
         self.db = partial(SQLiteContextManager, self.location, test)
-        self._speaker_metadata_tiers: list[str] = []
 
     @cached_property
     def json(self) -> str:
         from .datatypes import MixtureDatabaseConfig
 
         config = MixtureDatabaseConfig(
-            asr_manifest=self.asr_manifests,
             class_balancing=self.class_balancing,
             class_labels=self.class_labels,
             class_weights_threshold=self.class_weights_thresholds,
@@ -120,86 +114,6 @@ class MixtureDatabase:
         with open(file=json_name, mode='w') as file:
             file.write(self.json)
 
-    def target_asr_data(self, t_id: int) -> str | None:
-        """Get the ASR data for the given target ID
-
-        :param t_id: Target ID
-        :return: ASR text or None
-        """
-        from .tokenized_shell_vars import tokenized_expand
-
-        name, _ = tokenized_expand(self.target_file(t_id).name)
-        return self.asr_manifest_data.get(name, None)
-
-    def mixture_asr_data(self, m_id: int) -> list[str | None]:
-        """Get the ASR data for the given mixid
-
-        :param m_id: Zero-based mixture ID
-        :return: List of ASR text or None
-        """
-        return [self.target_asr_data(target.file_id) for target in self.mixture(m_id).targets]
-
-    @cached_property
-    def asr_manifest_data(self) -> dict[str, str]:
-        """Get ASR data
-
-        Each line of a manifest file should be in the following format:
-
-        {"audio_filepath": "/path/to/audio.wav", "text": "the transcription of the utterance", "duration": 23.147}
-
-        The audio_filepath field should provide an absolute path to the audio file corresponding to the utterance. The
-        text field should contain the full transcript for the utterance, and the duration field should reflect the
-        duration of the utterance in seconds.
-
-        Each entry in the manifest (describing one audio file) should be bordered by '{' and '}' and must be contained
-        on one line. The fields that describe the file should be separated by commas, and have the form
-        "field_name": value, as shown above.
-
-        Since the manifest specifies the path for each utterance, the audio files do not have to be located in the same
-        directory as the manifest, or even in any specific directory structure.
-
-        The manifest dictionary consists of key/value pairs where the keys are target file names and the values are ASR
-        text.
-        """
-        import json
-
-        from sonusai import SonusAIError
-        from .tokenized_shell_vars import tokenized_expand
-
-        expected_keys = ['audio_filepath', 'text', 'duration']
-
-        def _error_preamble(e_name: str, e_line_num: int) -> str:
-            return f'Invalid entry in ASR manifest {e_name} line {e_line_num}'
-
-        asr_manifest_data: dict[str, str] = {}
-
-        for name in self.asr_manifests:
-            expanded_name, _ = tokenized_expand(name)
-            with open(file=expanded_name, mode='r') as f:
-                line_num = 1
-                for line in f:
-                    result = json.loads(line.strip())
-
-                    for key in expected_keys:
-                        if key not in result:
-                            SonusAIError(f'{_error_preamble(name, line_num)}: missing field "{key}"')
-
-                    for key in result.keys():
-                        if key not in expected_keys:
-                            SonusAIError(f'{_error_preamble(name, line_num)}: unknown field "{key}"')
-
-                    key, _ = tokenized_expand(result['audio_filepath'])
-                    value = result['text']
-
-                    if key in asr_manifest_data:
-                        SonusAIError(f'{_error_preamble(name, line_num)}: entry already exists')
-
-                    asr_manifest_data[key] = value
-
-                    line_num += 1
-
-        return asr_manifest_data
-
     @cached_property
     def fg_config(self) -> FeatureGeneratorConfig:
         return FeatureGeneratorConfig(feature_mode=self.feature,
@@ -215,32 +129,32 @@ class MixtureDatabase:
     @cached_property
     def num_classes(self) -> int:
         with self.db() as c:
-            return int(c.execute("SELECT top.num_classes from top").fetchone()[0])
+            return int(c.execute("SELECT top.num_classes FROM top").fetchone()[0])
 
     @cached_property
     def truth_mutex(self) -> bool:
         with self.db() as c:
-            return bool(c.execute("SELECT top.truth_mutex from top").fetchone()[0])
+            return bool(c.execute("SELECT top.truth_mutex FROM top").fetchone()[0])
 
     @cached_property
     def truth_reduction_function(self) -> str:
         with self.db() as c:
-            return str(c.execute("SELECT top.truth_reduction_function from top").fetchone()[0])
+            return str(c.execute("SELECT top.truth_reduction_function FROM top").fetchone()[0])
 
     @cached_property
     def noise_mix_mode(self) -> str:
         with self.db() as c:
-            return str(c.execute("SELECT top.noise_mix_mode from top").fetchone()[0])
+            return str(c.execute("SELECT top.noise_mix_mode FROM top").fetchone()[0])
 
     @cached_property
     def class_balancing(self) -> bool:
         with self.db() as c:
-            return bool(c.execute("SELECT top.class_balancing from top").fetchone()[0])
+            return bool(c.execute("SELECT top.class_balancing FROM top").fetchone()[0])
 
     @cached_property
     def feature(self) -> str:
         with self.db() as c:
-            return str(c.execute("SELECT top.feature from top").fetchone()[0])
+            return str(c.execute("SELECT top.feature FROM top").fetchone()[0])
 
     @cached_property
     def fg_decimation(self) -> int:
@@ -292,14 +206,14 @@ class MixtureDatabase:
     def feature_step_samples(self) -> int:
         return self.ft_config.R * self.fg_decimation * self.fg_step
 
-    def total_samples(self, mixids: GeneralizedIDs = '*') -> int:
-        return sum([self.mixture(m_id).samples for m_id in self.mixids_to_list(mixids)])
+    def total_samples(self, m_ids: GeneralizedIDs = '*') -> int:
+        return sum([self.mixture(m_id).samples for m_id in self.mixids_to_list(m_ids)])
 
-    def total_transform_frames(self, mixids: GeneralizedIDs = '*') -> int:
-        return self.total_samples(mixids) // self.ft_config.R
+    def total_transform_frames(self, m_ids: GeneralizedIDs = '*') -> int:
+        return self.total_samples(m_ids) // self.ft_config.R
 
-    def total_feature_frames(self, mixids: GeneralizedIDs = '*') -> int:
-        return self.total_samples(mixids) // self.feature_step_samples
+    def total_feature_frames(self, m_ids: GeneralizedIDs = '*') -> int:
+        return self.total_samples(m_ids) // self.feature_step_samples
 
     def mixture_transform_frames(self, samples: int) -> int:
         return samples // self.ft_config.R
@@ -307,24 +221,15 @@ class MixtureDatabase:
     def mixture_feature_frames(self, samples: int) -> int:
         return samples // self.feature_step_samples
 
-    def mixids_to_list(self, mixids: Optional[GeneralizedIDs] = None) -> list[int]:
+    def mixids_to_list(self, m_ids: Optional[GeneralizedIDs] = None) -> list[int]:
         """Resolve generalized mixture IDs to a list of integers
 
-        :param mixids: Generalized mixture IDs
+        :param m_ids: Generalized mixture IDs
         :return: List of mixture ID integers
         """
         from .helpers import generic_ids_to_list
 
-        return generic_ids_to_list(self.num_mixtures, mixids)
-
-    @cached_property
-    def asr_manifests(self) -> list[str]:
-        """Get ASR manifests from db
-
-        :return: ASR manifests
-        """
-        with self.db() as c:
-            return [str(item[0]) for item in c.execute("SELECT asr_manifest.manifest FROM asr_manifest").fetchall()]
+        return generic_ids_to_list(self.num_mixtures, m_ids)
 
     @cached_property
     def class_labels(self) -> list[str]:
@@ -377,14 +282,16 @@ class MixtureDatabase:
 
         :return: Spectral masks
         """
+        from .db_datatypes import SpectralMaskRecord
+
         with self.db() as c:
-            results = c.execute(
-                "SELECT spectral_mask.f_max_width, f_num, t_max_width, t_num, t_max_percent FROM spectral_mask")
-            return [SpectralMask(f_max_width=spectral_mask[0],
-                                 f_num=spectral_mask[1],
-                                 t_max_width=spectral_mask[2],
-                                 t_num=spectral_mask[3],
-                                 t_max_percent=spectral_mask[4]) for spectral_mask in results.fetchall()]
+            spectral_masks = [SpectralMaskRecord(*result) for result in
+                              c.execute("SELECT * FROM spectral_mask").fetchall()]
+            return [SpectralMask(f_max_width=spectral_mask.f_max_width,
+                                 f_num=spectral_mask.f_num,
+                                 t_max_width=spectral_mask.t_max_width,
+                                 t_num=spectral_mask.t_num,
+                                 t_max_percent=spectral_mask.t_max_percent) for spectral_mask in spectral_masks]
 
     def spectral_mask(self, sm_id: int) -> SpectralMask:
         """Get spectral mask with ID from db
@@ -404,25 +311,29 @@ class MixtureDatabase:
 
         from .datatypes import TruthSetting
         from .datatypes import TruthSettings
+        from .db_datatypes import TargetFileRecord
 
         with self.db() as c:
             target_files: TargetFiles = []
-            for target in c.execute("SELECT target_file.name, samples, level_type, id FROM target_file").fetchall():
+            target_file_records = [TargetFileRecord(*result) for result in
+                                   c.execute("SELECT * FROM target_file").fetchall()]
+            for target_file_record in target_file_records:
                 truth_settings: TruthSettings = []
-                for ts in c.execute(
+                for truth_setting_records in c.execute(
                         "SELECT truth_setting.setting " +
                         "FROM truth_setting, target_file_truth_setting " +
                         "WHERE ? = target_file_truth_setting.target_file_id " +
                         "AND truth_setting.id = target_file_truth_setting.truth_setting_id",
-                        (target[3],)).fetchall():
-                    entry = json.loads(ts[0])
-                    truth_settings.append(TruthSetting(config=entry.get('config', None),
-                                                       function=entry.get('function', None),
-                                                       index=entry.get('index', None)))
-                target_files.append(TargetFile(name=target[0],
-                                               samples=target[1],
-                                               level_type=target[2],
-                                               truth_settings=truth_settings))
+                        (target_file_record.id,)).fetchall():
+                    truth_setting = json.loads(truth_setting_records[0])
+                    truth_settings.append(TruthSetting(config=truth_setting.get('config', None),
+                                                       function=truth_setting.get('function', None),
+                                                       index=truth_setting.get('index', None)))
+                target_files.append(TargetFile(name=target_file_record.name,
+                                               samples=target_file_record.samples,
+                                               level_type=target_file_record.level_type,
+                                               truth_settings=truth_settings,
+                                               speaker_id=target_file_record.speaker_id))
             return target_files
 
     @cached_property
@@ -532,18 +443,16 @@ class MixtureDatabase:
         """
         from .helpers import to_mixture
         from .helpers import to_target
+        from .db_datatypes import MixtureRecord
+        from .db_datatypes import TargetRecord
 
         with self.db() as c:
             mixtures: Mixtures = []
-            for mixture in c.execute(
-                    "SELECT 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, id " +
-                    "FROM mixture").fetchall():
-                targets = [to_target(target) for target in c.execute(
-                    "SELECT target.file_id, augmentation, gain " +
-                    "FROM target, mixture_target " +
+            for mixture in [MixtureRecord(*record) for record in c.execute("SELECT * FROM mixture").fetchall()]:
+                targets = [to_target(TargetRecord(*target)) for target in c.execute(
+                    "SELECT target.* FROM target, mixture_target " +
                     "WHERE ? = mixture_target.mixture_id AND target.id = mixture_target.target_id",
-                    (mixture[11],)).fetchall()]
+                    (mixture.id,)).fetchall()]
                 mixtures.append(to_mixture(mixture, targets))
             return mixtures
 
@@ -567,7 +476,7 @@ class MixtureDatabase:
     @cached_property
     def mixid_width(self) -> int:
         with self.db() as c:
-            return int(c.execute("SELECT top.mixid_width from top").fetchone()[0])
+            return int(c.execute("SELECT top.mixid_width FROM top").fetchone()[0])
 
     def location_filename(self, name: str) -> str:
         """Add the location to the given file name
@@ -719,7 +628,7 @@ class MixtureDatabase:
 
         :param m_id: Zero-based mixture ID
         :param targets: List of augmented target audio data (one per target in the mixup)
-        :param target: Augmented target audio for the given mixid
+        :param target: Augmented target audio for the given m_id
         :param force: Force computing data from original sources regardless of whether cached data exists
         :return: Augmented target transform data
         """
@@ -1077,97 +986,298 @@ class MixtureDatabase:
         return class_count
 
     @cached_property
-    def _speech_metadata(self) -> dict[str, dict[str, SpeechMetadata]]:
-        """Speech metadata is a nested dictionary.
+    def speaker_metadata_tiers(self) -> list[str]:
+        import json
 
-        data['target_file_name'] = { 'tier': SpeechMetadata, ... }
-        """
-        data: dict[str, dict[str, SpeechMetadata]] = {}
-        for file in self.target_files:
-            data[file.name] = {}
-            file_name, _ = tokenized_expand(file.name)
-            tg_file = Path(file_name).with_suffix('.TextGrid')
-            if tg_file.exists():
-                tg = textgrid.openTextgrid(str(tg_file), includeEmptyIntervals=False)
-                for tier in tg.tierNames:
-                    entries = tg.getTier(tier).entries
-                    if len(entries) > 1:
-                        data[file.name][tier] = entries
-                    else:
-                        data[file.name][tier] = entries[0].label
+        with self.db() as c:
+            return json.loads(c.execute("SELECT speaker_metadata_tiers FROM top WHERE 1 = id").fetchone()[0])
 
-        return data
+    @cached_property
+    def textgrid_metadata_tiers(self) -> list[str]:
+        import json
+
+        with self.db() as c:
+            return json.loads(c.execute("SELECT textgrid_metadata_tiers FROM top WHERE 1 = id").fetchone()[0])
 
     @cached_property
     def speech_metadata_tiers(self) -> list[str]:
-        return sorted(list(set([key for value in self._speech_metadata.values() for key in value.keys()])))
+        return sorted(set(self.speaker_metadata_tiers + self.textgrid_metadata_tiers))
+
+    def speaker(self, s_id: int | None, tier: str) -> Optional[str]:
+        return _speaker(self.db, s_id, tier)
+
+    def speech_metadata(self, tier: str) -> list[str]:
+        from .helpers import get_textgrid_tier_from_target_file
+
+        results: set[str] = set()
+        if tier in self.textgrid_metadata_tiers:
+            for target_file in self.target_files:
+                data = get_textgrid_tier_from_target_file(target_file.name, tier)
+                if data is None:
+                    continue
+                if isinstance(data, list):
+                    for item in data:
+                        results.add(item.label)
+                else:
+                    results.add(data)
+        elif tier in self.speaker_metadata_tiers:
+            for target_file in self.target_files:
+                data = self.speaker(target_file.speaker_id, tier)
+                if data is not None:
+                    results.add(data)
+
+        return sorted(results)
+
+    def mixture_speech_metadata(self, mixid: int, tier: str) -> list[SpeechMetadata]:
+        from praatio.utilities.constants import Interval
+
+        from .helpers import get_textgrid_tier_from_target_file
+
+        results: list[SpeechMetadata] = []
+        is_textgrid = tier in self.textgrid_metadata_tiers
+        if is_textgrid:
+            for target in self.mixture(mixid).targets:
+                data = get_textgrid_tier_from_target_file(self.target_file(target.file_id).name, tier)
+                if data is not None:
+                    if isinstance(data, list):
+                        # Check for tempo augmentation and adjust Interval start and end data as needed
+                        entries = []
+                        for entry in data:
+                            if target.augmentation.tempo is not None:
+                                entries.append(Interval(entry.start / target.augmentation.tempo,
+                                                        entry.end / target.augmentation.tempo,
+                                                        entry.label))
+                            else:
+                                entries.append(entry)
+                        results.append(entries)
+                    else:
+                        results.append(data)
+        else:
+            for target in self.mixture(mixid).targets:
+                data = self.speaker(self.target_file(target.file_id).speaker_id, tier)
+                if data is not None:
+                    results.append(data)
 
-    def speech_metadata_all(self, tier: str) -> list[SpeechMetadata]:
-        results = sorted(
-            set([value.get(tier) for value in self._speech_metadata.values() if isinstance(value.get(tier), str)]))
-        return results
+        return sorted(results)
 
     def mixids_for_speech_metadata(self,
                                    tier: str,
-                                   value: str,
+                                   value: str | None,
                                    predicate: Callable[[str], bool] = None) -> list[int]:
-        """Get a list of mixids for the given speech metadata tier.
+        """Get a list of mixture IDs for the given speech metadata tier.
 
-        If 'predicate' is None, then include mixids whose tier values are equal to the given 'value'. If 'predicate' is
-        not None, then ignore 'value' and use the given callable to determine which entries to include.
+        If 'predicate' is None, then include mixture IDs whose tier values are equal to the given 'value'.
+        If 'predicate' is not None, then ignore 'value' and use the given callable to determine which entries
+        to include.
 
         Examples:
+        >>> mixdb = MixtureDatabase('/mixdb_location')
 
         >>> mixids = mixdb.mixids_for_speech_metadata('speaker_id', 'TIMIT_ARC0')
-        Get mixids for mixtures with speakers whose speaker_ids are 'TIMIT_ARC0'.
+        Get mixutre IDs for mixtures with speakers whose speaker_ids are 'TIMIT_ARC0'.
 
         >>> mixids = mixdb.mixids_for_speech_metadata('age', '', lambda x: int(x) < 25)
-        Get mixids for mixtures with speakers whose ages are less than 25.
+        Get mixture IDs for mixtures with speakers whose ages are less than 25.
 
         >>> mixids = mixdb.mixids_for_speech_metadata('dialect', '', lambda x: x in ['New York City', 'Northern'])
-        Get mixids for mixtures with speakers whose dialects are either 'New York City' or 'Northern'.
+        Get mixture IDs for mixtures with speakers whose dialects are either 'New York City' or 'Northern'.
         """
+        from .helpers import get_textgrid_tier_from_target_file
+
         if predicate is None:
-            def predicate(x: str) -> bool:
+            def predicate(x: str | None) -> bool:
                 return x == value
 
         # First get list of matching target files
-        target_files = [k for k, v in self._speech_metadata.items() if
-                        isinstance(v.get(tier), str) and predicate(str(v.get(tier)))]
+        target_file_ids: list[int] = []
+        is_textgrid = tier in self.textgrid_metadata_tiers
+        for target_file_id, target_file in enumerate(self.target_files):
+            if is_textgrid:
+                metadata = get_textgrid_tier_from_target_file(target_file.name, tier)
+            else:
+                metadata = self.speaker(target_file.speaker_id, tier)
 
-        # Next get list of mixids that contain those target files
-        mixids: list[int] = []
-        for mixid in self.mixids_to_list():
-            mixid_target_files = [self.target_file(target.file_id).name for target in self.mixture(mixid).targets]
-            for mixid_target_file in mixid_target_files:
-                if mixid_target_file in target_files:
-                    mixids.append(mixid)
+            if not isinstance(metadata, list) and predicate(metadata):
+                target_file_ids.append(target_file_id + 1)
 
-        # Return sorted, unique list of mixids
-        return sorted(list(set(mixids)))
+        # Next get list of mixture IDs that contain those target files
+        with self.db() as c:
+            m_ids = c.execute("SELECT mixture_id FROM mixture_target " +
+                               f"WHERE mixture_target.target_id IN ({','.join(map(str, target_file_ids))})").fetchall()
+        return [x[0] - 1 for x in m_ids]
 
-    def get_speech_metadata(self, mixid: int, tier: str) -> list[SpeechMetadata]:
-        results: list[SpeechMetadata] = []
-        for target in self.mixture(mixid).targets:
-            data = self._speech_metadata[self.target_file(target.file_id).name].get(tier)
-
-            if data is None:
-                results.append(None)
-            elif isinstance(data, list):
-                # Check for tempo augmentation and adjust Interval start and end data as needed
-                entries = []
-                for entry in data:
-                    if target.augmentation.tempo is not None:
-                        entries.append(Interval(entry.start / target.augmentation.tempo,
-                                                entry.end / target.augmentation.tempo,
-                                                entry.label))
-                    else:
-                        entries.append(entry)
+    def mixture_all_speech_metadata(self, m_id: int) -> list[dict[str, SpeechMetadata]]:
+        from .helpers import mixture_all_speech_metadata
 
-            else:
-                results.append(data)
+        return mixture_all_speech_metadata(self, self.mixture(m_id))
 
-        return results
+    def mixture_metric(self, m_id: int, metric: str, force: bool = False) -> Any:
+        """Get metric data for the given mixture ID
+
+        :param m_id: Zero-based mixture ID
+        :param metric: Metric data to retrieve
+        :param force: Force computing data from original sources regardless of whether cached data exists
+        :return: Metric data
+        """
+        from sonusai import SonusAIError
+
+        supported_metrics = (
+            'MXSNR',
+            'MXSSNRAVG',
+            'MXSSNRSTD',
+            'MXSSNRDAVG',
+            'MXSSNRDSTD',
+            'MXPESQ',
+            'MXWSDR',
+            'MXPD',
+            'MXSTOI',
+            'MXCSIG',
+            'MXCBAK',
+            'MXCOVL',
+            'TDCO',
+            'TMIN',
+            'TMAX',
+            'TPKDB',
+            'TLRMS',
+            'TPKR',
+            'TTR',
+            'TCR',
+            'TFL',
+            'TPKC',
+            'NDCO',
+            'NMIN',
+            'NMAX',
+            'NPKDB',
+            'NLRMS',
+            'NPKR',
+            'NTR',
+            'NCR',
+            'NFL',
+            'NPKC',
+            'SEDAVG',
+            'SEDCNT',
+            'SEDTOPN',
+        )
+
+        if not (metric in supported_metrics or metric.startswith('MXWER')):
+            raise ValueError(f'Unsupported metric: {metric}')
+
+        if not force:
+            result = self.read_mixture_data(m_id, metric)
+            if result is not None:
+                return result
+
+        mixture = self.mixture(m_id)
+        if mixture is None:
+            raise SonusAIError(f'Could not find mixture for m_id: {m_id}')
+
+        if metric.startswith('MXWER'):
+            return None
+
+        if metric == 'MXSNR':
+            return self.snrs
+
+        if metric == 'MXSSNRAVG':
+            return None
+
+        if metric == 'MXSSNRSTD':
+            return None
+
+        if metric == 'MXSSNRDAVG':
+            return None
+
+        if metric == 'MXSSNRDSTD':
+            return None
+
+        if metric == 'MXPESQ':
+            return None
+
+        if metric == 'MXWSDR':
+            return None
+
+        if metric == 'MXPD':
+            return None
+
+        if metric == 'MXSTOI':
+            return None
+
+        if metric == 'MXCSIG':
+            return None
+
+        if metric == 'MXCBAK':
+            return None
+
+        if metric == 'MXCOVL':
+            return None
+
+        if metric == 'TDCO':
+            return None
+
+        if metric == 'TMIN':
+            return None
+
+        if metric == 'TMAX':
+            return None
+
+        if metric == 'TPKDB':
+            return None
+
+        if metric == 'TLRMS':
+            return None
+
+        if metric == 'TPKR':
+            return None
+
+        if metric == 'TTR':
+            return None
+
+        if metric == 'TCR':
+            return None
+
+        if metric == 'TFL':
+            return None
+
+        if metric == 'TPKC':
+            return None
+
+        if metric == 'NDCO':
+            return None
+
+        if metric == 'NMIN':
+            return None
+
+        if metric == 'NMAX':
+            return None
+
+        if metric == 'NPKDB':
+            return None
+
+        if metric == 'NLRMS':
+            return None
+
+        if metric == 'NPKR':
+            return None
+
+        if metric == 'NTR':
+            return None
+
+        if metric == 'NCR':
+            return None
+
+        if metric == 'NFL':
+            return None
+
+        if metric == 'NPKC':
+            return None
+
+        if metric == 'SEDAVG':
+            return None
+
+        if metric == 'SEDCNT':
+            return None
+
+        if metric == 'SEDTOPN':
+            return None
 
 
 @lru_cache
@@ -1178,17 +1288,16 @@ def _spectral_mask(db: partial, sm_id: int) -> SpectralMask:
     :param sm_id: Spectral mask ID
     :return: Spectral mask
     """
+    from .db_datatypes import SpectralMaskRecord
+
     with db() as c:
-        spectral_mask = c.execute(
-            "SELECT spectral_mask.f_max_width, f_num, t_max_width, t_num, t_max_percent " +
-            "FROM spectral_mask " +
-            "WHERE ? = spectral_mask.id",
-            (sm_id,)).fetchone()
-        return SpectralMask(f_max_width=spectral_mask[0],
-                            f_num=spectral_mask[1],
-                            t_max_width=spectral_mask[2],
-                            t_num=spectral_mask[3],
-                            t_max_percent=spectral_mask[4])
+        spectral_mask = SpectralMaskRecord(*c.execute("SELECT * FROM spectral_mask WHERE ? = spectral_mask.id",
+                                                      (sm_id,)).fetchone())
+        return SpectralMask(f_max_width=spectral_mask.f_max_width,
+                            f_num=spectral_mask.f_num,
+                            t_max_width=spectral_mask.t_max_width,
+                            t_num=spectral_mask.t_num,
+                            t_max_percent=spectral_mask.t_max_percent)
 
 
 @lru_cache
@@ -1203,10 +1312,11 @@ def _target_file(db: partial, t_id: int) -> TargetFile:
 
     from .datatypes import TruthSetting
     from .datatypes import TruthSettings
+    from .db_datatypes import TargetFileRecord
 
     with db() as c:
-        target = c.execute("SELECT target_file.name, samples, level_type FROM target_file WHERE ? = target_file.id",
-                           (t_id,)).fetchone()
+        target_file = TargetFileRecord(
+            *c.execute("SELECT * FROM target_file WHERE ? = target_file.id", (t_id,)).fetchone())
 
         truth_settings: TruthSettings = []
         for ts in c.execute(
@@ -1219,10 +1329,11 @@ def _target_file(db: partial, t_id: int) -> TargetFile:
             truth_settings.append(TruthSetting(config=entry.get('config', None),
                                                function=entry.get('function', None),
                                                index=entry.get('index', None)))
-        return TargetFile(name=target[0],
-                          samples=target[1],
-                          level_type=target[2],
-                          truth_settings=truth_settings)
+        return TargetFile(name=target_file.name,
+                          samples=target_file.samples,
+                          level_type=target_file.level_type,
+                          truth_settings=truth_settings,
+                          speaker_id=target_file.speaker_id)
 
 
 @lru_cache
@@ -1263,19 +1374,29 @@ def _mixture(db: partial, m_id: int) -> Mixture:
     """
     from .helpers import to_mixture
     from .helpers import to_target
+    from .db_datatypes import MixtureRecord
+    from .db_datatypes import TargetRecord
 
     with db() as c:
-        mixture = c.execute(
-            "SELECT 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, id " +
-            "FROM mixture " +
-            "WHERE ? = mixture.id",
-            (m_id + 1,)).fetchone()
-
-        targets = [to_target(target) for target in c.execute(
-            "SELECT target.file_id, augmentation, gain " +
+        mixture = MixtureRecord(*c.execute("SELECT * FROM mixture WHERE ? = mixture.id", (m_id + 1,)).fetchone())
+        targets = [to_target(TargetRecord(*target)) for target in c.execute(
+            "SELECT target.* " +
             "FROM target, mixture_target " +
             "WHERE ? = mixture_target.mixture_id AND target.id = mixture_target.target_id",
-            (mixture[11],)).fetchall()]
+            (mixture.id,)).fetchall()]
 
         return to_mixture(mixture, targets)
+
+
+@lru_cache
+def _speaker(db: partial, s_id: int | None, tier: str) -> Optional[str]:
+    if s_id is None:
+        return None
+
+    with db() as c:
+        data = c.execute(f'SELECT {tier} FROM speaker WHERE ? = id', (s_id,)).fetchone()
+        if data is None:
+            return None
+        if data[0] is None:
+            return None
+        return data[0]