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

sonusai/mixture/mixdb.py

@@ -61,7 +61,7 @@ def db_connection(
     if not create and readonly:
         name += "?mode=ro"
 
-    connection = sqlite3.connect("file:" + name, uri=True)
+    connection = sqlite3.connect("file:" + name, uri=True, timeout=20)
 
     if verbose:
         connection.set_trace_callback(print)
@@ -84,7 +84,7 @@ class SQLiteContextManager:
 
 
 class MixtureDatabase:
-    def __init__(self, location: str, test: bool = False) -> None:
+    def __init__(self, location: str, test: bool = False, use_cache: bool = True) -> None:
         import json
         from os.path import exists
 
@@ -92,6 +92,7 @@ class MixtureDatabase:
 
         self.location = location
         self.test = test
+        self.use_cache = use_cache
 
         if not exists(db_file(self.location, self.test)):
             raise OSError(f"Could not find mixture database in {self.location}")
@@ -121,7 +122,7 @@ class MixtureDatabase:
             class_weights_threshold=self.class_weights_thresholds,
             feature=self.feature,
             impulse_response_files=self.impulse_response_files,
-            mixtures=self.mixtures,
+            mixtures=self.mixtures(),
             noise_mix_mode=self.noise_mix_mode,
             noise_files=self.noise_files,
             num_classes=self.num_classes,
@@ -254,6 +255,16 @@ class MixtureDatabase:
                     "Predicted rating of overall quality of mixture versus true targets",
                 ),
                 MetricDoc("Mixture Metrics", "ssnr", "Segmental SNR"),
+                MetricDoc("Mixture Metrics", "mxdco", "Mixture DC offset"),
+                MetricDoc("Mixture Metrics", "mxmin", "Mixture min level"),
+                MetricDoc("Mixture Metrics", "mxmax", "Mixture max levl"),
+                MetricDoc("Mixture Metrics", "mxpkdb", "Mixture Pk lev dB"),
+                MetricDoc("Mixture Metrics", "mxlrms", "Mixture RMS lev dB"),
+                MetricDoc("Mixture Metrics", "mxpkr", "Mixture RMS Pk dB"),
+                MetricDoc("Mixture Metrics", "mxtr", "Mixture RMS Tr dB"),
+                MetricDoc("Mixture Metrics", "mxcr", "Mixture Crest factor"),
+                MetricDoc("Mixture Metrics", "mxfl", "Mixture Flat factor"),
+                MetricDoc("Mixture Metrics", "mxpkc", "Mixture Pk count"),
                 MetricDoc("Mixture Metrics", "mxtdco", "Mixture target DC offset"),
                 MetricDoc("Mixture Metrics", "mxtmin", "Mixture target min level"),
                 MetricDoc("Mixture Metrics", "mxtmax", "Mixture target max levl"),
@@ -488,7 +499,7 @@ class MixtureDatabase:
             return truth_configs
 
     def target_truth_configs(self, t_id: int) -> TruthConfigs:
-        return _target_truth_configs(self.db, t_id)
+        return _target_truth_configs(self.db, t_id, self.use_cache)
 
     @cached_property
     def random_snrs(self) -> list[float]:
@@ -556,7 +567,7 @@ class MixtureDatabase:
         :param sm_id: Spectral mask ID
         :return: Spectral mask
         """
-        return _spectral_mask(self.db, sm_id)
+        return _spectral_mask(self.db, sm_id, self.use_cache)
 
     @cached_property
     def target_files(self) -> list[TargetFile]:
@@ -619,7 +630,7 @@ class MixtureDatabase:
         :param t_id: Target file ID
         :return: Target file
         """
-        return _target_file(self.db, t_id)
+        return _target_file(self.db, t_id, self.use_cache)
 
     @cached_property
     def num_target_files(self) -> int:
@@ -657,7 +668,7 @@ class MixtureDatabase:
         :param n_id: Noise file ID
         :return: Noise file
         """
-        return _noise_file(self.db, n_id)
+        return _noise_file(self.db, n_id, self.use_cache)
 
     @cached_property
     def num_noise_files(self) -> int:
@@ -680,7 +691,7 @@ class MixtureDatabase:
 
         with self.db() as c:
             return [
-                ImpulseResponseFile(impulse_response[1], json.loads(impulse_response[2]))
+                ImpulseResponseFile(impulse_response[1], json.loads(impulse_response[2]), impulse_response[3])
                 for impulse_response in c.execute(
                     "SELECT impulse_response_file.* FROM impulse_response_file"
                 ).fetchall()
@@ -699,14 +710,24 @@ class MixtureDatabase:
             ]
 
     def impulse_response_file(self, ir_id: int | None) -> str | None:
-        """Get impulse response file with ID from db
+        """Get impulse response file name with ID from db
+
+        :param ir_id: Impulse response file ID
+        :return: Impulse response file name
+        """
+        if ir_id is None:
+            return None
+        return _impulse_response_file(self.db, ir_id, self.use_cache)
+
+    def impulse_response_delay(self, ir_id: int | None) -> int | None:
+        """Get impulse response delay with ID from db
 
         :param ir_id: Impulse response file ID
-        :return: Noise
+        :return: Impulse response delay
         """
         if ir_id is None:
             return None
-        return _impulse_response_file(self.db, ir_id)
+        return _impulse_response_delay(self.db, ir_id, self.use_cache)
 
     @cached_property
     def num_impulse_response_files(self) -> int:
@@ -717,7 +738,6 @@ class MixtureDatabase:
         with self.db() as c:
             return int(c.execute("SELECT count(impulse_response_file.id) FROM impulse_response_file").fetchone()[0])
 
-    @cached_property
     def mixtures(self) -> list[Mixture]:
         """Get mixtures from db
 
@@ -760,7 +780,7 @@ class MixtureDatabase:
         :param m_id: Zero-based mixture ID
         :return: Mixture record
         """
-        return _mixture(self.db, m_id)
+        return _mixture(self.db, m_id, self.use_cache)
 
     @cached_property
     def mixid_width(self) -> int:
@@ -805,7 +825,7 @@ class MixtureDatabase:
         """
         from .audio import read_audio
 
-        return read_audio(self.target_file(t_id).name)
+        return read_audio(self.target_file(t_id).name, self.use_cache)
 
     def augmented_noise_audio(self, mixture: Mixture) -> AudioT:
         """Get augmented noise audio
@@ -814,18 +834,11 @@ class MixtureDatabase:
         :return: Augmented noise audio
         """
         from .audio import read_audio
-        from .audio import read_ir
         from .augmentation import apply_augmentation
-        from .augmentation import apply_impulse_response
 
         noise = self.noise_file(mixture.noise.file_id)
-        audio = read_audio(noise.name)
-        audio = apply_augmentation(audio, mixture.noise.augmentation)
-        if mixture.noise.augmentation.ir is not None:
-            audio = apply_impulse_response(
-                audio,
-                read_ir(self.impulse_response_file(mixture.noise.augmentation.ir)),
-            )
+        audio = read_audio(noise.name, self.use_cache)
+        audio = apply_augmentation(self, audio, mixture.noise.augmentation.pre)
 
         return audio
 
@@ -859,8 +872,9 @@ class MixtureDatabase:
         for target in mixture.targets:
             target_audio = self.read_target_audio(target.file_id)
             target_audio = apply_augmentation(
+                mixdb=self,
                 audio=target_audio,
-                augmentation=target.augmentation,
+                augmentation=target.augmentation.pre,
                 frame_length=self.feature_step_samples,
             )
             target_audio = apply_gain(audio=target_audio, gain=mixture.target_snr_gain)
@@ -1119,8 +1133,7 @@ class MixtureDatabase:
         offsets = range(0, mixture.samples, self.ft_config.overlap)
         if len(target_energy) != len(offsets):
             raise ValueError(
-                f"Number of frames in energy, {len(target_energy)},"
-                f" is not number of frames in mixture, {len(offsets)}"
+                f"Number of frames in energy, {len(target_energy)}, is not number of frames in mixture, {len(offsets)}"
             )
 
         for idx, offset in enumerate(offsets):
@@ -1332,7 +1345,7 @@ class MixtureDatabase:
         return sorted(set(self.speaker_metadata_tiers + self.textgrid_metadata_tiers))
 
     def speaker(self, s_id: int | None, tier: str) -> str | None:
-        return _speaker(self.db, s_id, tier)
+        return _speaker(self.db, s_id, tier, self.use_cache)
 
     def speech_metadata(self, tier: str) -> list[str]:
         from .helpers import get_textgrid_tier_from_target_file
@@ -1370,11 +1383,11 @@ class MixtureDatabase:
                     # 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:
+                        if target.augmentation.pre.tempo is not None:
                             entries.append(
                                 Interval(
-                                    entry.start / target.augmentation.tempo,
-                                    entry.end / target.augmentation.tempo,
+                                    entry.start / target.augmentation.pre.tempo,
+                                    entry.end / target.augmentation.pre.tempo,
                                     entry.label,
                                 )
                             )
@@ -1464,7 +1477,7 @@ class MixtureDatabase:
 
         return sorted(result)
 
-    def mixture_metrics(self, m_id: int, metrics: list[str], force: bool = False) -> list[Any]:
+    def mixture_metrics(self, m_id: int, metrics: list[str], force: bool = False) -> dict[str, Any]:
         """Get metrics data for the given mixture ID
 
         :param m_id: Zero-based mixture ID
@@ -1595,6 +1608,19 @@ class MixtureDatabase:
 
         speech = create_speech()
 
+        def create_mixture_stats() -> Callable[[], AudioStatsMetrics]:
+            state: AudioStatsMetrics | None = None
+
+            def get() -> AudioStatsMetrics:
+                nonlocal state
+                if state is None:
+                    state = calc_audio_stats(mixture_audio(), self.fg_info.ft_config.length / SAMPLE_RATE)
+                return state
+
+            return get
+
+        mixture_stats = create_mixture_stats()
+
         def create_targets_stats() -> Callable[[], list[AudioStatsMetrics]]:
             state: list[AudioStatsMetrics] | None = None
 
@@ -1803,6 +1829,36 @@ class MixtureDatabase:
                     extended=False,
                 )
 
+            if m == "mxdco":
+                return mixture_stats().dco
+
+            if m == "mxmin":
+                return mixture_stats().min
+
+            if m == "mxmax":
+                return mixture_stats().max
+
+            if m == "mxpkdb":
+                return mixture_stats().pkdb
+
+            if m == "mxlrms":
+                return mixture_stats().lrms
+
+            if m == "mxpkr":
+                return mixture_stats().pkr
+
+            if m == "mxtr":
+                return mixture_stats().tr
+
+            if m == "mxcr":
+                return mixture_stats().cr
+
+            if m == "mxfl":
+                return mixture_stats().fl
+
+            if m == "mxpkc":
+                return mixture_stats().pkc
+
             if m == "mxtdco":
                 return target_stats().dco
 
@@ -1916,21 +1972,34 @@ class MixtureDatabase:
 
             raise AttributeError(f"Unrecognized metric: '{m}'")
 
-        result: list[float | int | str | Segsnr | None] = []
+        result: dict[str, Any] = {}
         for metric in metrics:
-            result.append(calc(metric))
+            result[metric] = calc(metric)
+
+            # Check for metrics dependencies and add them even if not explicitly requested.
+            if metric.startswith("mxwer"):
+                dependencies = ("mxasr." + metric[6:], "tasr." + metric[6:])
+                for dependency in dependencies:
+                    result[dependency] = calc(dependency)
 
         return result
 
 
-@lru_cache
-def _spectral_mask(db: partial, sm_id: int) -> SpectralMask:
+def _spectral_mask(db: partial, sm_id: int, use_cache: bool = True) -> SpectralMask:
     """Get spectral mask with ID from db
 
     :param db: Database context
     :param sm_id: Spectral mask ID
+    :param use_cache: If true, use LRU caching
     :return: Spectral mask
     """
+    if use_cache:
+        return __spectral_mask(db, sm_id)
+    return __spectral_mask.__wrapped__(db, sm_id)
+
+
+@lru_cache
+def __spectral_mask(db: partial, sm_id: int) -> SpectralMask:
     from .db_datatypes import SpectralMaskRecord
 
     with db() as c:
@@ -1953,12 +2022,26 @@ def _spectral_mask(db: partial, sm_id: int) -> SpectralMask:
         )
 
 
+def _target_file(db: partial, t_id: int, use_cache: bool = True) -> TargetFile:
+    """Get target file with ID from db
+
+    :param db: Database context
+    :param t_id: Target file ID
+    :param use_cache: If true, use LRU caching
+    :return: Target file
+    """
+    if use_cache:
+        return __target_file(db, t_id, use_cache)
+    return __target_file.__wrapped__(db, t_id, use_cache)
+
+
 @lru_cache
-def _target_file(db: partial, t_id: int) -> TargetFile:
+def __target_file(db: partial, t_id: int, use_cache: bool = True) -> TargetFile:
     """Get target file with ID from db
 
     :param db: Database context
     :param t_id: Target file ID
+    :param use_cache: If true, use LRU caching
     :return: Target file
     """
     import json
@@ -1982,19 +2065,26 @@ def _target_file(db: partial, t_id: int) -> TargetFile:
             samples=target_file.samples,
             class_indices=json.loads(target_file.class_indices),
             level_type=target_file.level_type,
-            truth_configs=_target_truth_configs(db, t_id),
+            truth_configs=_target_truth_configs(db, t_id, use_cache),
             speaker_id=target_file.speaker_id,
         )
 
 
-@lru_cache
-def _noise_file(db: partial, n_id: int) -> NoiseFile:
+def _noise_file(db: partial, n_id: int, use_cache: bool = True) -> NoiseFile:
     """Get noise file with ID from db
 
     :param db: Database context
     :param n_id: Noise file ID
+    :param use_cache: If true, use LRU caching
     :return: Noise file
     """
+    if use_cache:
+        return __noise_file(db, n_id)
+    return __noise_file.__wrapped__(db, n_id)
+
+
+@lru_cache
+def __noise_file(db: partial, n_id: int) -> NoiseFile:
     with db() as c:
         noise = c.execute(
             """
@@ -2007,14 +2097,21 @@ def _noise_file(db: partial, n_id: int) -> NoiseFile:
         return NoiseFile(name=noise[0], samples=noise[1])
 
 
-@lru_cache
-def _impulse_response_file(db: partial, ir_id: int) -> str:
-    """Get impulse response file with ID from db
+def _impulse_response_file(db: partial, ir_id: int, use_cache: bool = True) -> str:
+    """Get impulse response file name with ID from db
 
     :param db: Database context
     :param ir_id: Impulse response file ID
-    :return: Noise
+    :param use_cache: If true, use LRU caching
+    :return: Impulse response file name
     """
+    if use_cache:
+        return __impulse_response_file(db, ir_id)
+    return __impulse_response_file.__wrapped__(db, ir_id)
+
+
+@lru_cache
+def __impulse_response_file(db: partial, ir_id: int) -> str:
     with db() as c:
         return str(
             c.execute(
@@ -2028,14 +2125,49 @@ def _impulse_response_file(db: partial, ir_id: int) -> str:
         )
 
 
+def _impulse_response_delay(db: partial, ir_id: int, use_cache: bool = True) -> int:
+    """Get impulse response delay with ID from db
+
+    :param db: Database context
+    :param ir_id: Impulse response file ID
+    :param use_cache: If true, use LRU caching
+    :return: Impulse response delay
+    """
+    if use_cache:
+        return __impulse_response_delay(db, ir_id)
+    return __impulse_response_delay.__wrapped__(db, ir_id)
+
+
 @lru_cache
-def _mixture(db: partial, m_id: int) -> Mixture:
+def __impulse_response_delay(db: partial, ir_id: int) -> int:
+    with db() as c:
+        return int(
+            c.execute(
+                """
+                SELECT impulse_response_file.delay
+                FROM impulse_response_file
+                WHERE ? = impulse_response_file.id
+                """,
+                (ir_id + 1,),
+            ).fetchone()[0]
+        )
+
+
+def _mixture(db: partial, m_id: int, use_cache: bool = True) -> Mixture:
     """Get mixture record with ID from db
 
     :param db: Database context
     :param m_id: Zero-based mixture ID
+    :param use_cache: If true, use LRU caching
     :return: Mixture record
     """
+    if use_cache:
+        return __mixture(db, m_id)
+    return __mixture.__wrapped__(db, m_id)
+
+
+@lru_cache
+def __mixture(db: partial, m_id: int) -> Mixture:
     from .db_datatypes import MixtureRecord
     from .db_datatypes import TargetRecord
     from .helpers import to_mixture
@@ -2068,8 +2200,14 @@ def _mixture(db: partial, m_id: int) -> Mixture:
         return to_mixture(mixture, targets)
 
 
+def _speaker(db: partial, s_id: int | None, tier: str, use_cache: bool = True) -> str | None:
+    if use_cache:
+        return __speaker(db, s_id, tier)
+    return __speaker.__wrapped__(db, s_id, tier)
+
+
 @lru_cache
-def _speaker(db: partial, s_id: int | None, tier: str) -> str | None:
+def __speaker(db: partial, s_id: int | None, tier: str) -> str | None:
     if s_id is None:
         return None
 
@@ -2082,8 +2220,14 @@ def _speaker(db: partial, s_id: int | None, tier: str) -> str | None:
         return data[0]
 
 
+def _target_truth_configs(db: partial, t_id: int, use_cache: bool = True) -> TruthConfigs:
+    if use_cache:
+        return __target_truth_configs(db, t_id)
+    return __target_truth_configs.__wrapped__(db, t_id)
+
+
 @lru_cache
-def _target_truth_configs(db: partial, t_id: int) -> TruthConfigs:
+def __target_truth_configs(db: partial, t_id: int) -> TruthConfigs:
     import json
 
     from .datatypes import TruthConfig

sonusai/mixture/targets.py

@@ -16,14 +16,11 @@ def get_augmented_targets(
 
     augmented_targets: list[AugmentedTarget] = []
     for mixup in mixups:
-        augmentation_indices = get_augmentation_indices_for_mixup(target_augmentations, mixup)
+        target_augmentation_indices = get_augmentation_indices_for_mixup(target_augmentations, mixup)
         for target_index in range(len(target_files)):
-            for augmentation_index in augmentation_indices:
+            for target_augmentation_index in target_augmentation_indices:
                 augmented_targets.append(
-                    AugmentedTarget(
-                        target_id=target_index,
-                        target_augmentation_id=augmentation_index,
-                    )
+                    AugmentedTarget(target_id=target_index, target_augmentation_id=target_augmentation_index)
                 )
 
     return augmented_targets

sonusai/mixture/truth_functions/energy.py

@@ -13,6 +13,7 @@ def _core(
     parameters: int,
     mapped: bool,
     snr: bool,
+    use_cache: bool = True,
 ) -> Truth:
     from os.path import join
 
@@ -50,8 +51,8 @@ def _core(
         tmp = np.nan_to_num(tmp, nan=-np.inf, posinf=np.inf, neginf=-np.inf)
 
         if mapped:
-            snr_db_mean = load_object(join(mixdb.location, config["snr_db_mean"]))
-            snr_db_std = load_object(join(mixdb.location, config["snr_db_std"]))
+            snr_db_mean = load_object(join(mixdb.location, config["snr_db_mean"]), use_cache)
+            snr_db_std = load_object(join(mixdb.location, config["snr_db_std"]), use_cache)
             tmp = _calculate_mapped_snr_f(tmp, snr_db_mean, snr_db_std)
 
         truth[frame] = tmp
@@ -85,7 +86,7 @@ def energy_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
     return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
 
-def energy_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def energy_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain energy truth generation function
 
     Calculates the true energy per bin:
@@ -104,6 +105,7 @@ def energy_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict)
         parameters=energy_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=False,
         snr=False,
+        use_cache=use_cache,
     )
 
 
@@ -118,7 +120,7 @@ def snr_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
     return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
 
-def snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain SNR truth function documentation
 
     Calculates the true SNR per bin:
@@ -137,6 +139,7 @@ def snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) ->
         parameters=snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=False,
         snr=True,
+        use_cache=use_cache,
     )
 
 
@@ -156,7 +159,7 @@ def mapped_snr_f_parameters(feature: str, _num_classes: int, _config: dict) -> i
     return ForwardTransform(**feature_forward_transform_config(feature)).bins
 
 
-def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain mapped SNR truth function documentation
 
     Output shape: [:, bins]
@@ -169,6 +172,7 @@ def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: d
         parameters=mapped_snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=True,
         snr=True,
+        use_cache=use_cache,
     )
 
 

sonusai/mixture/truth_functions/metrics.py

@@ -25,4 +25,4 @@ def metrics(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict)
         m = [config["metric"]]
     else:
         m = config["metric"]
-    return mixdb.mixture_metrics(m_id, m)[0][target_index]
+    return mixdb.mixture_metrics(m_id, m)[m[0]][target_index]

sonusai/mkwav.py

@@ -63,7 +63,7 @@ def _process_mixture(m_id: int, location: str, write_target: bool, write_targets
     if write_noise:
         write_audio(name=join(location, "noise.wav"), audio=float_to_int16(mixdb.mixture_noise(m_id)))
 
-    write_mixture_metadata(mixdb, m_id)
+    write_mixture_metadata(mixdb, m_id=m_id)
 
 
 def main() -> None:

sonusai/onnx_predict.py

@@ -193,7 +193,7 @@ def main() -> None:
             # run inference, ort session wants i.e. batch x timesteps x feat_params, outputs numpy BxTxFP or BxFP
             predict = session.run(out_names, {in0name: feature})[0]
             # predict, _ = reshape_outputs(predict=predict[0], timesteps=frames)  # frames x feat_params
-            output_fname = join(output_dir, mixdb.mixtures[mixid].name)
+            output_fname = join(output_dir, mixdb.mixture(mixid).name)
             with h5py.File(output_fname, "a") as f:
                 if "predict" in f:
                     del f["predict"]

sonusai/queries/queries.py

@@ -178,7 +178,7 @@ def get_mixids_from_snr(
     result: dict[float, list[int]] = {}
     for snr in snrs:
         # Get a list of mixids for each SNR
-        result[snr] = sorted([i for i, mixture in enumerate(mixdb.mixtures) if mixture.snr == snr and i in mixid_out])
+        result[snr] = sorted([i for i, mixture in enumerate(mixdb.mixtures()) if mixture.snr == snr and i in mixid_out])
 
     return result
 

sonusai/utils/__init__.py

@@ -1,5 +1,6 @@
 # SonusAI general utilities
 # ruff: noqa: F401
+
 from .asl_p56 import asl_p56
 from .asr import ASRResult
 from .asr import calc_asr
@@ -53,5 +54,6 @@ from .stacked_complex import stacked_complex_imag
 from .stacked_complex import stacked_complex_real
 from .stacked_complex import unstack_complex
 from .stratified_shuffle_split import stratified_shuffle_split_mixid
+from .temp_seed import temp_seed
 from .write_audio import write_audio
 from .yes_or_no import yes_or_no

sonusai/utils/asr.py

@@ -65,7 +65,7 @@ def calc_asr(audio: AudioT | str, engine: str, **config) -> ASRResult:
     from sonusai.mixture import read_audio
 
     if not isinstance(audio, np.ndarray):
-        audio = copy(read_audio(audio))
+        audio = copy(read_audio(audio, config.get("use_cache", True)))
 
     return _asr_fn(engine)(audio, **config)
 

sonusai/utils/load_object.py

@@ -2,9 +2,15 @@ from functools import lru_cache
 from typing import Any
 
 
+def load_object(name: str, use_cache: bool = True) -> Any:
+    """Load an object from a pickle file"""
+    if use_cache:
+        return _load_object(name)
+    return _load_object.__wrapped__(name)
+
+
 @lru_cache
-def load_object(name: str) -> Any:
-    """Load an object from a pickle file (with LRU caching)"""
+def _load_object(name: str) -> Any:
     import pickle
     from os.path import exists
 

sonusai/utils/stratified_shuffle_split.py

@@ -42,7 +42,7 @@ def stratified_shuffle_split_mixid(
         raise ValueError("vsplit must be between 0 and 1")
 
     a_class_mixid: dict[int, list[int]] = {i + 1: [] for i in range(mixdb.num_classes)}
-    for mixid, mixture in enumerate(mixdb.mixtures):
+    for mixid, mixture in enumerate(mixdb.mixtures()):
         class_count = get_class_count_from_mixids(mixdb, mixid)
         if any(class_count):
             for class_index in mixdb.target_files[mixture.targets[0].file_id].class_indices:

sonusai/utils/temp_seed.py

@@ -0,0 +1,13 @@
+import contextlib
+
+import numpy as np
+
+
+@contextlib.contextmanager
+def temp_seed(seed):
+    state = np.random.get_state()
+    np.random.seed(seed)
+    try:
+        yield
+    finally:
+        np.random.set_state(state)

{sonusai-0.19.9.dist-info → sonusai-0.20.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: sonusai
-Version: 0.19.9
+Version: 0.20.2
 Summary: Framework for building deep neural network models for sound, speech, and voice AI
 Home-page: https://aaware.com
 License: GPL-3.0-only