sonusai 0.17.3__py3-none-any.whl → 0.18.0__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,
@@ -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]:
@@ -407,7 +312,8 @@ class MixtureDatabase:
 
         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():
+            for target in c.execute(
+                    "SELECT target_file.name, samples, level_type, id, speaker_id FROM target_file").fetchall():
                 truth_settings: TruthSettings = []
                 for ts in c.execute(
                         "SELECT truth_setting.setting " +
@@ -422,7 +328,8 @@ class MixtureDatabase:
                 target_files.append(TargetFile(name=target[0],
                                                samples=target[1],
                                                level_type=target[2],
-                                               truth_settings=truth_settings))
+                                               truth_settings=truth_settings,
+                                               speaker_id=target[4]))
             return target_files
 
     @cached_property
@@ -719,7 +626,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 +984,312 @@ 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 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
+    def speaker(self, speaker_id: int | None, tier: str) -> Optional[str]:
+        if speaker_id is None:
+            return None
+
+        with self.db() as c:
+            data = c.execute(f'SELECT {tier} FROM speaker WHERE ? = id', (speaker_id,)).fetchone()
+            if data is None:
+                return None
+            if data[0] is None:
+                return None
+            return data[0]
+
+    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)
+
+        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_files: list[str] = []
+        is_textgrid = tier in self.textgrid_metadata_tiers
+        for target_file in 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]
+            if not isinstance(metadata, list) and predicate(metadata):
+                target_files.append(target_file.name)
+
+        # Next get list of mixture IDs that contain those target files
+        m_ids: list[int] = []
+        for m_id in self.mixids_to_list():
+            mixid_target_files = [self.target_file(target.file_id).name for target in self.mixture(m_id).targets]
             for mixid_target_file in mixid_target_files:
                 if mixid_target_file in target_files:
-                    mixids.append(mixid)
+                    m_ids.append(m_id)
 
-        # Return sorted, unique list of mixids
-        return sorted(list(set(mixids)))
+        # Return sorted, unique list of mixture IDs
+        return sorted(list(set(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)
+    def mixture_all_speech_metadata(self, m_id: int) -> list[dict[str, SpeechMetadata]]:
+        from .helpers import mixture_all_speech_metadata
 
-            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)
+        return mixture_all_speech_metadata(self, self.mixture(m_id))
 
-            else:
-                results.append(data)
+    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
 
-        return results
+        if metric == 'SEDTOPN':
+            return None
 
 
 @lru_cache
@@ -1205,8 +1327,9 @@ def _target_file(db: partial, t_id: int) -> TargetFile:
     from .datatypes import TruthSettings
 
     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 = c.execute(
+            "SELECT target_file.name, samples, level_type, speaker_id FROM target_file WHERE ? = target_file.id",
+            (t_id,)).fetchone()
 
         truth_settings: TruthSettings = []
         for ts in c.execute(
@@ -1222,7 +1345,8 @@ def _target_file(db: partial, t_id: int) -> TargetFile:
         return TargetFile(name=target[0],
                           samples=target[1],
                           level_type=target[2],
-                          truth_settings=truth_settings)
+                          truth_settings=truth_settings,
+                          speaker_id=target[3])
 
 
 @lru_cache

sonusai/mixture/tokenized_shell_vars.py

@@ -1,4 +1,7 @@
-def tokenized_expand(name: str | bytes) -> tuple[str, dict[str, str]]:
+from pathlib import Path
+
+
+def tokenized_expand(name: str | bytes | Path) -> tuple[str, dict[str, str]]:
     """Expand shell variables of the forms $var, ${var} and %var%.
     Unknown variables are left unchanged.
 
@@ -25,6 +28,9 @@ def tokenized_expand(name: str | bytes) -> tuple[str, dict[str, str]]:
     if isinstance(name, bytes):
         name = name.decode('utf-8')
 
+    if isinstance(name, Path):
+        name = name.as_posix()
+
     name = os.fspath(name)
     token_map: dict = {}
 
@@ -121,6 +127,7 @@ def tokenized_expand(name: str | bytes) -> tuple[str, dict[str, str]]:
         else:
             result += c
         index += 1
+
     return result, token_map
 
 

sonusai/speech/textgrid.py

@@ -6,37 +6,19 @@ from praatio.utilities.constants import Interval
 from .types import TimeAlignedType
 
 
-def _get_duration(name: str) -> float:
-    from pydub import AudioSegment
-
-    from sonusai import SonusAIError
-
-    try:
-        return AudioSegment.from_file(name).duration_seconds
-    except Exception as e:
-        raise SonusAIError(f'Error reading {name}: {e}')
-
-
 def create_textgrid(prompt: Path,
-                    speaker_id: str,
-                    speaker: dict,
                     output_dir: Path,
                     text: TimeAlignedType = None,
                     words: list[TimeAlignedType] = None,
                     phonemes: list[TimeAlignedType] = None) -> None:
-    if text is not None or words is not None or phonemes is not None:
-        min_t, max_t = _get_min_max({'phonemes': phonemes,
-                                     'text':     [text],
-                                     'words':    words})
-    else:
-        min_t = 0
-        max_t = _get_duration(str(prompt))
+    if text is None and words is None and phonemes is None:
+        return
 
-    tg = textgrid.Textgrid()
+    min_t, max_t = _get_min_max({'phonemes': phonemes,
+                                 'text':     [text],
+                                 'words':    words})
 
-    tg.addTier(textgrid.IntervalTier('speaker_id', [Interval(min_t, max_t, speaker_id)], min_t, max_t))
-    for tier in speaker.keys():
-        tg.addTier(textgrid.IntervalTier(tier, [Interval(min_t, max_t, str(speaker[tier]))], min_t, max_t))
+    tg = textgrid.Textgrid()
 
     if text is not None:
         entries = [Interval(text.start, text.end, text.text)]