sonusai 0.20.3__py3-none-any.whl → 1.0.2__py3-none-any.whl

sonusai/mixture/constants.py

@@ -1,56 +1,52 @@
-import re
 from importlib.resources import as_file
 from importlib.resources import files
 
-REQUIRED_CONFIGS = [
+REQUIRED_CONFIGS: tuple[str, ...] = (
     "asr_configs",
     "class_balancing",
-    "class_balancing_augmentation",
+    "class_balancing_effect",
     "class_indices",
     "class_labels",
     "class_weights_threshold",
     "feature",
     "impulse_responses",
-    "noise_augmentations",
-    "noise_mix_mode",
-    "noises",
+    "level_type",
+    "mixture_effects",
     "num_classes",
-    "random_snrs",
     "seed",
-    "snrs",
+    "sources",
     "spectral_masks",
-    "target_augmentations",
-    "target_level_type",
-    "targets",
-    "truth_configs",
-]
-OPTIONAL_CONFIGS: list[str] = []
-VALID_CONFIGS = REQUIRED_CONFIGS + OPTIONAL_CONFIGS
-REQUIRED_TRUTH_CONFIGS = ["function", "stride_reduction"]
-REQUIRED_ASR_CONFIGS = ["engine"]
-VALID_AUGMENTATIONS = [
-    "normalize",
-    "gain",
-    "pitch",
-    "tempo",
-    "eq1",
-    "eq2",
-    "eq3",
-    "lpf",
-    "ir",
-]
-VALID_NOISE_MIX_MODES = ["exhaustive", "non-exhaustive", "non-combinatorial"]
-RAND_PATTERN = re.compile(r"rand\(([-+]?(\d+(\.\d*)?|\.\d+)),\s*([-+]?(\d+(\.\d*)?|\.\d+))\)")
-SAMPLE_RATE = 16000
-BIT_DEPTH = 32
-ENCODING = "floating-point"
-CHANNEL_COUNT = 1
-SAMPLE_BYTES = BIT_DEPTH // 8
-FLOAT_BYTES = 4
-MIXDB_VERSION = 2
+    "summed_source_effects",
+)
+OPTIONAL_CONFIGS: tuple[str, ...] = ()
+VALID_CONFIGS: tuple[str, ...] = REQUIRED_CONFIGS + OPTIONAL_CONFIGS
+
+REQUIRED_SOURCES_CATEGORIES: tuple[str, ...] = (
+    "primary",
+    "noise",
+)
+
+REQUIRED_SOURCE_CONFIGS: tuple[str, ...] = (
+    "effects",
+    "files",
+)
+OPTIONAL_SOURCE_CONFIGS: tuple[str, ...] = ("truth_configs",)
+REQUIRED_NON_PRIMARY_SOURCE_CONFIGS: tuple[str, ...] = (
+    "mix_rules",
+    "snrs",
+)
+VALID_PRIMARY_SOURCE_CONFIGS: tuple[str, ...] = REQUIRED_SOURCE_CONFIGS + OPTIONAL_SOURCE_CONFIGS
+VALID_NON_PRIMARY_SOURCE_CONFIGS: tuple[str, ...] = VALID_PRIMARY_SOURCE_CONFIGS + REQUIRED_NON_PRIMARY_SOURCE_CONFIGS
+
+REQUIRED_TRUTH_CONFIGS: tuple[str, ...] = (
+    "function",
+    "stride_reduction",
+)
+REQUIRED_ASR_CONFIGS: tuple[str, ...] = ("engine",)
 
-with as_file(files("sonusai.data").joinpath("whitenoise.wav")) as path:
-    DEFAULT_NOISE = str(path)
+MIXDB_VERSION = 3
+MIXDB_NAME = "mixdb.db"
+TEST_MIXDB_NAME = "mixdb_test.db"
 
 with as_file(files("sonusai.data").joinpath("genmixdb.yml")) as path:
     DEFAULT_CONFIG = str(path)

sonusai/mixture/data_io.py

@@ -13,13 +13,13 @@ def _get_pickle_name(location: str, index: str, item: str) -> str:
     return join(location, index, item + ".pkl")
 
 
-def read_hdf5_data(location: str, index: str, items: list[str] | str) -> Any:
+def read_hdf5_data(location: str, index: str, items: list[str] | str) -> dict[str, Any]:
     """Read mixture, target, or noise data from an HDF5 file
 
     :param location: Location of the file
     :param index: Mixture, target, or noise index
     :param items: String(s) of data to retrieve
-    :return: Data (or tuple of data)
+    :return: Dictionary of name: data
     """
     from os.path import exists
     from typing import Any
@@ -45,45 +45,39 @@ def read_hdf5_data(location: str, index: str, items: list[str] | str) -> Any:
     if exists(h5_name):
         try:
             with h5py.File(h5_name, "r") as f:
-                result = [_get_dataset(f, item) for item in items]
+                result = {item: _get_dataset(f, item) for item in items}
         except Exception as e:
             raise OSError(f"Error reading {h5_name}: {e}") from e
     else:
-        result = [None for _ in items]
-
-    if len(items) == 1:
-        result = result[0]
+        result = {item: None for item in items}
 
     return result
 
 
-def write_hdf5_data(location: str, index: str, items: list[tuple[str, Any]] | tuple[str, Any]) -> None:
+def write_hdf5_data(location: str, index: str, items: dict[str, Any]) -> None:
     """Write mixture, target, or noise data to an HDF5 file
 
     :param location: Location of the file
     :param index: Mixture, target, or noise index
-    :param items: Tuple(s) of (name, data)
+    :param items: Dictionary of name: data
     """
     import h5py
 
-    if not isinstance(items, list):
-        items = [items]
-
     h5_name = _get_hdf5_name(location, index)
     with h5py.File(h5_name, "a") as f:
-        for item in items:
-            if item[0] in f:
-                del f[item[0]]
-            f.create_dataset(name=item[0], data=item[1])
+        for name, data in items.items():
+            if name in f:
+                del f[name]
+            f.create_dataset(name=name, data=data)
 
 
-def read_pickle_data(location: str, index: str, items: list[str] | str) -> Any:
+def read_pickle_data(location: str, index: str, items: list[str] | str) -> dict[str, Any]:
     """Read mixture, target, or noise data from a pickle file
 
     :param location: Location of the file
     :param index: Mixture, target, or noise index
     :param items: String(s) of data to retrieve
-    :return: Data (or tuple of data)
+    :return: Dictionary of name: data
     """
     import pickle
     from os.path import exists
@@ -92,40 +86,35 @@ def read_pickle_data(location: str, index: str, items: list[str] | str) -> Any:
     if not isinstance(items, list):
         items = [items]
 
-    result: list[Any] = []
+    result: dict[str, Any] = {}
     for item in items:
         pkl_name = _get_pickle_name(location, index, item)
         if exists(pkl_name):
             with open(pkl_name, "rb") as f:
-                result.append(pickle.load(f))  # noqa: S301
+                result[item] = pickle.load(f)  # noqa: S301
         else:
-            result.append(None)
-
-    if len(items) == 1:
-        result = result[0]
+            result[item] = None
 
     return result
 
 
-def write_pickle_data(location: str, index: str, items: list[tuple[str, Any]] | tuple[str, Any]) -> None:
+def write_pickle_data(location: str, index: str, items: dict[str, Any]) -> None:
     """Write mixture, target, or noise data to a pickle file
 
     :param location: Location of the file
     :param index: Mixture, target, or noise index
-    :param items: Tuple(s) of (name, data)
+    :param items: Dictionary of name: data
     """
     import pickle
     from os import makedirs
     from os.path import join
 
-    if not isinstance(items, list):
-        items = [items]
-
-    makedirs(join(location, index), exist_ok=True)
-    for item in items:
-        pkl_name = _get_pickle_name(location, index, item[0])
+    directory = join(location, index)
+    makedirs(directory, exist_ok=True)
+    for name, data in items.items():
+        pkl_name = _get_pickle_name(location, index, name)
         with open(pkl_name, "wb") as f:
-            f.write(pickle.dumps(item[1]))
+            f.write(pickle.dumps(data))
 
 
 def clear_pickle_data(location: str, index: str, items: list[str] | str) -> None:
@@ -144,7 +133,7 @@ def clear_pickle_data(location: str, index: str, items: list[str] | str) -> None
         Path(_get_pickle_name(location, index, item)).unlink(missing_ok=True)
 
 
-def read_cached_data(location: str, name: str, index: str, items: list[str] | str) -> Any:
+def read_cached_data(location: str, name: str, index: str, items: list[str] | str) -> dict[str, Any]:
     """Read cached data from a file
 
     :param location: Location of the mixture database
@@ -158,13 +147,13 @@ def read_cached_data(location: str, name: str, index: str, items: list[str] | st
     return read_pickle_data(join(location, name), index, items)
 
 
-def write_cached_data(location: str, name: str, index: str, items: list[tuple[str, Any]] | tuple[str, Any]) -> None:
+def write_cached_data(location: str, name: str, index: str, items: dict[str, Any]) -> None:
     """Write data to a file
 
     :param location: Location of the mixture database
     :param name: Data name ('mixture', 'target', or 'noise')
     :param index: Data index (mixture, target, or noise ID)
-    :param items: Tuple(s) of (name, data)
+    :param items: Dictionary of name: data
     """
     from os.path import join
 

sonusai/mixture/db_datatypes.py

@@ -1,56 +1,92 @@
 from collections import namedtuple
 
-TruthConfigRecord = namedtuple("TruthConfigRecord", ["id", "name", "function", "stride_reduction", "config"])
-
-TruthParametersRecord = namedtuple("TruthParametersRecord", ["id", "name", "parameters"])
-
-TargetFileRecord = namedtuple("TargetFileRecord", ["id", "name", "samples", "class_indices", "level_type", "speaker_id"])
-
-NoiseFileRecord = namedtuple("NoiseFileRecord", ["id", "name", "samples"])
+SourceFileRecord = namedtuple(
+    "SourceFileRecord",
+    [
+        "id",
+        "category",
+        "class_indices",
+        "level_type",
+        "name",
+        "samples",
+        "speaker_id",
+    ],
+)
 
 TopRecord = namedtuple(
     "TopRecord",
     [
         "id",
-        "version",
         "class_balancing",
         "feature",
-        "noise_mix_mode",
+        "mixid_width",
         "num_classes",
         "seed",
-        "mixid_width",
         "speaker_metadata_tiers",
         "textgrid_metadata_tiers",
+        "version",
     ],
 )
 
-ClassLabelRecord = namedtuple("ClassLabelRecord", ["id", "label"])
+ClassLabelRecord = namedtuple(
+    "ClassLabelRecord",
+    [
+        "id",
+        "label",
+    ],
+)
 
-ClassWeightsThresholdRecord = namedtuple("ClassWeightsThresholdRecord", ["id", "threshold"])
+ClassWeightsThresholdRecord = namedtuple(
+    "ClassWeightsThresholdRecord",
+    [
+        "id",
+        "threshold",
+    ],
+)
 
-ImpulseResponseFileRecord = namedtuple("ImpulseResponseFileRecord", ["id", "file"])
+ImpulseResponseFileRecord = namedtuple(
+    "ImpulseResponseFileRecord",
+    [
+        "id",
+        "delay",
+        "name",
+    ],
+)
 
 SpectralMaskRecord = namedtuple(
     "SpectralMaskRecord",
-    ["id", "f_max_width", "f_num", "t_max_width", "t_num", "t_max_percent"],
+    [
+        "id",
+        "f_max_width",
+        "f_num",
+        "t_max_percent",
+        "t_max_width",
+        "t_num",
+    ],
 )
 
-TargetRecord = namedtuple("TargetRecord", ["id", "file_id", "augmentation"])
+SourceRecord = namedtuple(
+    "SourceRecord",
+    [
+        "id",
+        "effects",
+        "file_id",
+        "pre_tempo",
+        "repeat",
+        "snr",
+        "snr_gain",
+        "snr_random",
+        "start",
+    ],
+)
 
 MixtureRecord = namedtuple(
     "MixtureRecord",
     [
         "id",
         "name",
-        "noise_file_id",
-        "noise_augmentation",
-        "noise_offset",
-        "noise_snr_gain",
-        "random_snr",
-        "snr",
         "samples",
         "spectral_mask_id",
         "spectral_mask_seed",
-        "target_snr_gain",
     ],
 )