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

sonusai/mixture/truth.py

@@ -1,33 +1,35 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ..datatypes import Truth
+from ..datatypes import TruthsDict
+from .mixdb import MixtureDatabase
 
 
-def truth_function(mixdb: MixtureDatabase, m_id: int) -> list[Truth]:
-    from sonusai.mixture import TruthDict
-    from sonusai.mixture import truth_functions
+def truth_function(mixdb: MixtureDatabase, m_id: int) -> TruthsDict:
+    from ..datatypes import TruthDict
+    from . import truth_functions
 
-    result: list[Truth] = []
-    for target_index in range(len(mixdb.mixture(m_id).targets)):
+    result: TruthsDict = {}
+    for category, source in mixdb.mixture(m_id).all_sources.items():
         truth: TruthDict = {}
-        target_file = mixdb.target_file(mixdb.mixture(m_id).targets[target_index].file_id)
-        for name, config in target_file.truth_configs.items():
+        source_file = mixdb.source_file(source.file_id)
+        for name, config in source_file.truth_configs.items():
             try:
-                truth[name] = getattr(truth_functions, config.function)(mixdb, m_id, target_index, config.config)
+                truth[name] = getattr(truth_functions, config.function)(mixdb, m_id, category, config.config)
             except AttributeError as e:
                 raise AttributeError(f"Unsupported truth function: {config.function}") from e
             except Exception as e:
                 raise RuntimeError(f"Error in truth function '{config.function}': {e}") from e
 
-        result.append(truth)
+        if truth:
+            result[category] = truth
 
     return result
 
 
-def get_truth_indices_for_mixid(mixdb: MixtureDatabase, mixid: int) -> list[int]:
-    """Get a list of truth indices for a given mixid."""
+def get_class_indices_for_mixid(mixdb: MixtureDatabase, mixid: int) -> list[int]:
+    """Get a list of class indices for a given mixid."""
     indices: list[int] = []
-    for target_id in [target.file_id for target in mixdb.mixture(mixid).targets]:
-        indices.append(*mixdb.target_file(target_id).class_indices)
+    for source_id in [source.file_id for source in mixdb.mixture(mixid).all_sources.values()]:
+        indices.append(*mixdb.source_file(source_id).class_indices)
 
     return sorted(set(indices))
 

sonusai/mixture/truth_functions/crm.py

@@ -1,31 +1,31 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
-def _core(mixdb: MixtureDatabase, m_id: int, target_index: int, parameters: int, polar: bool) -> Truth:
+def _core(mixdb: MixtureDatabase, m_id: int, category: str, parameters: int, polar: bool) -> Truth:
     import numpy as np
     import torch
     from pyaaware import ForwardTransform
     from pyaaware import feature_forward_transform_config
     from pyaaware import feature_inverse_transform_config
 
-    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    source_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
     t_ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
     n_ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = t_ft.frames(target_audio)
-    if mixdb.mixture(m_id).target_gain(target_index) == 0:
+    frames = t_ft.frames(source_audio)
+    if mixdb.mixture(m_id).all_sources[category].snr_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
     noise_audio = torch.from_numpy(mixdb.mixture_noise(m_id))
 
     frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
 
-    frames = len(target_audio) // frame_size
+    frames = len(source_audio) // frame_size
     truth = np.empty((frames, t_ft.bins * 2), dtype=np.float32)
     for frame in range(frames):
         offset = frame * frame_size
-        target_f = t_ft.execute(target_audio[offset : offset + frame_size])[0].numpy().astype(np.complex64)
+        target_f = t_ft.execute(source_audio[offset : offset + frame_size])[0].numpy().astype(np.complex64)
         noise_f = n_ft.execute(noise_audio[offset : offset + frame_size])[0].numpy().astype(np.complex64)
         mixture_f = target_f + noise_f
 
@@ -58,7 +58,7 @@ def crm_parameters(feature: str, _num_classes: int, _config: dict) -> int:
     return ForwardTransform(**feature_forward_transform_config(feature)).bins * 2
 
 
-def crm(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def crm(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Complex ratio mask truth generation function
 
     Calculates the true complex ratio mask (CRM) truth which is a complex number
@@ -71,7 +71,7 @@ def crm(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) ->
     return _core(
         mixdb=mixdb,
         m_id=m_id,
-        target_index=target_index,
+        category=category,
         parameters=crm_parameters(mixdb.feature, mixdb.num_classes, _config),
         polar=False,
     )
@@ -88,7 +88,7 @@ def crmp_parameters(feature: str, _num_classes: int, _config: dict) -> int:
     return ForwardTransform(**feature_forward_transform_config(feature)).bins * 2
 
 
-def crmp(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def crmp(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Complex ratio mask polar truth generation function
 
     Same as the crm function except the results are magnitude and phase
@@ -99,7 +99,7 @@ def crmp(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) ->
     return _core(
         mixdb=mixdb,
         m_id=m_id,
-        target_index=target_index,
+        category=category,
         parameters=crmp_parameters(mixdb.feature, mixdb.num_classes, _config),
         polar=True,
     )

sonusai/mixture/truth_functions/energy.py

@@ -1,14 +1,14 @@
 import numpy as np
 
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
-from sonusai.utils import load_object
+from ...datatypes import Truth
+from ...utils.load_object import load_object
+from ..mixdb import MixtureDatabase
 
 
 def _core(
     mixdb: MixtureDatabase,
     m_id: int,
-    target_index: int,
+    category: str,
     config: dict,
     parameters: int,
     mapped: bool,
@@ -21,27 +21,27 @@ def _core(
     from pyaaware import ForwardTransform
     from pyaaware import feature_forward_transform_config
 
-    from sonusai.utils import compute_energy_f
+    from ...utils.energy_f import compute_energy_f
 
-    target_audio = mixdb.mixture_targets(m_id)[target_index]
+    source_audio = mixdb.mixture_sources(m_id)[category]
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = ft.frames(torch.from_numpy(target_audio))
+    frames = ft.frames(torch.from_numpy(source_audio))
 
-    if mixdb.mixture(m_id).target_gain(target_index) == 0:
+    if mixdb.mixture(m_id).all_sources[category].snr_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
     noise_audio = mixdb.mixture_noise(m_id)
 
-    target_energy = compute_energy_f(time_domain=target_audio, transform=ft)
+    source_energy = compute_energy_f(time_domain=source_audio, transform=ft)
     noise_energy = None
     if snr:
         noise_energy = compute_energy_f(time_domain=noise_audio, transform=ft)
 
-    frames = len(target_energy)
+    frames = len(source_energy)
     truth = np.empty((frames, ft.bins), dtype=np.float32)
     for frame in range(frames):
-        tmp = target_energy[frame]
+        tmp = source_energy[frame]
 
         if noise_energy is not None:
             old_err = np.seterr(divide="ignore", invalid="ignore")
@@ -86,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, use_cache: bool = True) -> Truth:
+def energy_f(mixdb: MixtureDatabase, m_id: int, category: str, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain energy truth generation function
 
     Calculates the true energy per bin:
@@ -100,7 +100,7 @@ def energy_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict,
     return _core(
         mixdb=mixdb,
         m_id=m_id,
-        target_index=target_index,
+        category=category,
         config=config,
         parameters=energy_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=False,
@@ -120,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, use_cache: bool = True) -> Truth:
+def snr_f(mixdb: MixtureDatabase, m_id: int, category: str, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain SNR truth function documentation
 
     Calculates the true SNR per bin:
@@ -134,7 +134,7 @@ def snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict, us
     return _core(
         mixdb=mixdb,
         m_id=m_id,
-        target_index=target_index,
+        category=category,
         config=config,
         parameters=snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=False,
@@ -159,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, use_cache: bool = True) -> Truth:
+def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, category: str, config: dict, use_cache: bool = True) -> Truth:
     """Frequency domain mapped SNR truth function documentation
 
     Output shape: [:, bins]
@@ -167,7 +167,7 @@ def mapped_snr_f(mixdb: MixtureDatabase, m_id: int, target_index: int, config: d
     return _core(
         mixdb=mixdb,
         m_id=m_id,
-        target_index=target_index,
+        category=category,
         config=config,
         parameters=mapped_snr_f_parameters(mixdb.feature, mixdb.num_classes, config),
         mapped=True,
@@ -184,7 +184,7 @@ def energy_t_parameters(_feature: str, _num_classes: int, _config: dict) -> int:
     return 1
 
 
-def energy_t(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def energy_t(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Time domain energy truth function documentation
 
     Calculates the true time domain energy of each frame:
@@ -210,13 +210,13 @@ def energy_t(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict
     from pyaaware import ForwardTransform
     from pyaaware import feature_forward_transform_config
 
-    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    source_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
 
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    frames = ft.frames(target_audio)
+    frames = ft.frames(source_audio)
     parameters = energy_f_parameters(mixdb.feature, mixdb.num_classes, _config)
-    if mixdb.mixture(m_id).target_gain(target_index) == 0:
+    if mixdb.mixture(m_id).all_sources[category].snr_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
-    return ft.execute_all(target_audio)[1].numpy()
+    return ft.execute_all(source_audio)[1].numpy()

sonusai/mixture/truth_functions/file.py

@@ -1,5 +1,5 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def file_validate(config: dict) -> None:
@@ -26,13 +26,13 @@ def file_parameters(_feature: str, _num_classes: int, config: dict) -> int:
     return truth.shape[-1]
 
 
-def file(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def file(mixdb: MixtureDatabase, m_id: int, category: str, config: dict) -> Truth:
     """file truth function documentation"""
     import h5py
     import numpy as np
     from pyaaware import feature_inverse_transform_config
 
-    target_audio = mixdb.mixture_targets(m_id)[target_index]
+    source_audio = mixdb.mixture_sources(m_id)[category]
 
     frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
 
@@ -42,7 +42,7 @@ def file(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) ->
     if truth.ndim != 2:
         raise ValueError("Truth file data is not 2 dimensions")
 
-    if truth.shape[0] != len(target_audio) // frame_size:
+    if truth.shape[0] != len(source_audio) // frame_size:
         raise ValueError("Truth file does not contain the right amount of frames")
 
     return truth

sonusai/mixture/truth_functions/metadata.py

@@ -1,5 +1,5 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def metadata_validate(config: dict) -> None:
@@ -16,9 +16,9 @@ def metadata_parameters(_feature: str, _num_classes: int, _config: dict) -> int
     return None
 
 
-def metadata(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def metadata(mixdb: MixtureDatabase, m_id: int, category: str, config: dict) -> Truth:
     """Metadata truth generation function
 
     Retrieves metadata from target.
     """
-    return mixdb.mixture_speech_metadata(m_id, config["tier"])[target_index]
+    return mixdb.mixture_speech_metadata(m_id, config["tier"])[category]

sonusai/mixture/truth_functions/metrics.py

@@ -1,5 +1,5 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def metrics_validate(config: dict) -> None:
@@ -16,7 +16,7 @@ def metrics_parameters(_feature: str, _num_classes: int, _config: dict) -> int |
     return None
 
 
-def metrics(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def metrics(mixdb: MixtureDatabase, m_id: int, category: str, config: dict) -> Truth:
     """Metadata truth generation function
 
     Retrieves metrics from target.
@@ -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)[m[0]][target_index]
+    return mixdb.mixture_metrics(m_id, m)[m[0]][category]

sonusai/mixture/truth_functions/phoneme.py

@@ -1,5 +1,5 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def phoneme_validate(_config: dict) -> None:
@@ -10,7 +10,7 @@ def phoneme_parameters(_feature: str, _num_classes: int, _config: dict) -> int:
     raise NotImplementedError("Truth function phoneme is not supported yet")
 
 
-def phoneme(_mixdb: MixtureDatabase, _m_id: int, _target_index: int, _config: dict) -> Truth:
+def phoneme(_mixdb: MixtureDatabase, _m_id: int, _category: str, _config: dict) -> Truth:
     """Read in .txt transcript and run a Python function to generate text grid data
     (indicating which phonemes are active). Then generate truth based on this data and put
     in the correct classes based on the index in the config.

sonusai/mixture/truth_functions/sed.py

@@ -1,5 +1,7 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from numpy.lib.utils import source
+
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def sed_validate(config: dict) -> None:
@@ -20,7 +22,7 @@ def sed_parameters(_feature: str, num_classes: int, _config: dict) -> int:
     return num_classes
 
 
-def sed(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> Truth:
+def sed(mixdb: MixtureDatabase, m_id: int, category: str, config: dict) -> Truth:
     """Sound energy detection truth generation function
 
     Calculates sound energy detection truth using simple 3 threshold
@@ -59,34 +61,30 @@ def sed(mixdb: MixtureDatabase, m_id: int, target_index: int, config: dict) -> T
     from pyaaware import feature_forward_transform_config
     from pyaaware import feature_inverse_transform_config
 
-    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    source_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
 
     frame_size = feature_inverse_transform_config(mixdb.feature)["overlap"]
 
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    if len(target_audio) % frame_size != 0:
+    if len(source_audio) % frame_size != 0:
         raise ValueError(f"Number of samples in audio is not a multiple of {frame_size}")
 
-    frames = ft.frames(target_audio)
+    frames = ft.frames(source_audio)
     parameters = sed_parameters(mixdb.feature, mixdb.num_classes, config)
-    target_gain = mixdb.mixture(m_id).target_gain(target_index)
-    if target_gain == 0:
+    if mixdb.mixture(m_id).all_sources[category].snr_gain == 0:
         return np.zeros((frames, parameters), dtype=np.float32)
 
     # SED wants 1-based indices
     s = SED(
         thresholds=config["thresholds"],
-        index=mixdb.target_file(mixdb.mixture(m_id).targets[target_index].file_id).class_indices,
+        index=mixdb.source_file(mixdb.mixture(m_id).all_sources[category].file_id).class_indices,
         frame_size=frame_size,
         num_classes=mixdb.num_classes,
     )
 
-    # Back out target gain
-    target_audio = target_audio / target_gain
-
     # Compute energy
-    target_energy = ft.execute_all(target_audio)[1].numpy()
+    target_energy = ft.execute_all(source_audio)[1].numpy()
 
     if frames != target_energy.shape[0]:
         raise ValueError("Incorrect frames calculation in sed truth function")

sonusai/mixture/truth_functions/target.py

@@ -1,5 +1,5 @@
-from sonusai.mixture import MixtureDatabase
-from sonusai.mixture import Truth
+from ...datatypes import Truth
+from ..mixdb import MixtureDatabase
 
 
 def target_f_validate(_config: dict) -> None:
@@ -18,7 +18,7 @@ def target_f_parameters(feature: str, _num_classes: int, _config: dict) -> int:
     return ft.bins * 2
 
 
-def target_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def target_f(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Frequency domain target truth function
 
     Calculates the true transform of the target using the STFT
@@ -34,7 +34,7 @@ def target_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict
 
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    target_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
 
     target_freq = ft.execute_all(target_audio)[0].numpy()
     return _stack_real_imag(target_freq, ft.ttype)
@@ -56,7 +56,7 @@ def target_mixture_f_parameters(feature: str, _num_classes: int, _config: dict)
     return ft.bins * 4
 
 
-def target_mixture_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def target_mixture_f(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Frequency domain target and mixture truth function
 
     Calculates the true transform of the target and the mixture
@@ -74,7 +74,7 @@ def target_mixture_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _conf
 
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
 
-    target_audio = torch.from_numpy(mixdb.mixture_targets(m_id)[target_index])
+    target_audio = torch.from_numpy(mixdb.mixture_sources(m_id)[category])
     mixture_audio = torch.from_numpy(mixdb.mixture_mixture(m_id))
 
     target_freq = ft.execute_all(torch.from_numpy(target_audio))[0].numpy()
@@ -98,7 +98,7 @@ def target_swin_f_parameters(feature: str, _num_classes: int, _config: dict) ->
     return ForwardTransform(**feature_forward_transform_config(feature)).bins * 2
 
 
-def target_swin_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config: dict) -> Truth:
+def target_swin_f(mixdb: MixtureDatabase, m_id: int, category: str, _config: dict) -> Truth:
     """Frequency domain target with synthesis window truth function
 
     Calculates the true transform of the target using the STFT
@@ -115,12 +115,12 @@ def target_swin_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config:
     from pyaaware import feature_forward_transform_config
     from pyaaware import feature_inverse_transform_config
 
-    from sonusai.utils import stack_complex
+    from ...utils.stacked_complex import stack_complex
 
     ft = ForwardTransform(**feature_forward_transform_config(mixdb.feature))
     it = InverseTransform(**feature_inverse_transform_config(mixdb.feature))
 
-    target_audio = mixdb.mixture_targets(m_id)[target_index]
+    target_audio = mixdb.mixture_sources(m_id)[category]
 
     truth = np.empty((len(target_audio) // ft.overlap, ft.bins * 2), dtype=np.float32)
     for idx, offset in enumerate(range(0, len(target_audio), ft.overlap)):
@@ -134,7 +134,7 @@ def target_swin_f(mixdb: MixtureDatabase, m_id: int, target_index: int, _config:
 def _stack_real_imag(data: Truth, ttype: str) -> Truth:
     import numpy as np
 
-    from sonusai.utils import stack_complex
+    from ...utils.stacked_complex import stack_complex
 
     if ttype == "tdac-co":
         return np.real(data)

sonusai/mkwav.py

@@ -6,8 +6,8 @@ options:
     -h, --help
     -v, --verbose                   Be verbose.
     -i MIXID, --mixid MIXID         Mixture ID(s) to generate. [default: *].
-    -t, --target                    Write target file.
-    -s, --targets                   Write targets files.
+    -t, --source                    Write source file.
+    -s, --sources                   Write sources files.
     -n, --noise                     Write noise file.
 
 The mkwav command creates WAV files from a SonusAI database.
@@ -19,30 +19,17 @@ Inputs:
 Outputs the following to the mixture database directory:
     <id>
         mixture.wav:        mixture
-        target.wav:         target (optional)
-        targets<n>.wav:     targets <n> (optional)
+        source.wav:         source (optional)
+        source_<c>.wav:     source <category> (optional)
         noise.wav:          noise (optional)
         metadata.txt
     mkwav.log
 
 """
 
-import signal
-
-
-def signal_handler(_sig, _frame):
-    import sys
-
-    from sonusai import logger
-
-    logger.info("Canceled due to keyboard interrupt")
-    sys.exit(1)
-
-
-signal.signal(signal.SIGINT, signal_handler)
-
 
 def _process_mixture(m_id: int, location: str, write_target: bool, write_targets: bool, write_noise: bool) -> None:
+    from os import makedirs
     from os.path import join
 
     from sonusai.mixture import MixtureDatabase
@@ -52,14 +39,16 @@ def _process_mixture(m_id: int, location: str, write_target: bool, write_targets
 
     mixdb = MixtureDatabase(location)
 
-    location = join(mixdb.location, "mixture", mixdb.mixture(m_id).name)
+    index = mixdb.mixture(m_id).name
+    location = join(mixdb.location, "mixture", index)
+    makedirs(location, exist_ok=True)
 
     write_audio(name=join(location, "mixture.wav"), audio=float_to_int16(mixdb.mixture_mixture(m_id)))
     if write_target:
-        write_audio(name=join(location, "target.wav"), audio=float_to_int16(mixdb.mixture_target(m_id)))
+        write_audio(name=join(location, "source.wav"), audio=float_to_int16(mixdb.mixture_source(m_id)))
     if write_targets:
-        for idx, target in enumerate(mixdb.mixture_targets(m_id)):
-            write_audio(name=join(location, f"targets{idx}.wav"), audio=float_to_int16(target))
+        for category, source in mixdb.mixture_sources(m_id).items():
+            write_audio(name=join(location, f"sources_{category}.wav"), audio=float_to_int16(source))
     if write_noise:
         write_audio(name=join(location, "noise.wav"), audio=float_to_int16(mixdb.mixture_noise(m_id)))
 
@@ -69,15 +58,15 @@ def _process_mixture(m_id: int, location: str, write_target: bool, write_targets
 def main() -> None:
     from docopt import docopt
 
-    import sonusai
+    from sonusai import __version__ as sai_version
     from sonusai.utils import trim_docstring
 
-    args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
+    args = docopt(trim_docstring(__doc__), version=sai_version, options_first=True)
 
     verbose = args["--verbose"]
     mixid = args["--mixid"]
-    write_target = args["--target"]
-    write_targets = args["--targets"]
+    write_source = args["--source"]
+    write_sources = args["--sources"]
     write_noise = args["--noise"]
     location = args["LOC"]
 
@@ -118,12 +107,13 @@ def main() -> None:
         partial(
             _process_mixture,
             location=location,
-            write_target=write_target,
-            write_targets=write_targets,
+            write_target=write_source,
+            write_targets=write_sources,
             write_noise=write_noise,
         ),
         mixid,
         progress=progress,
+        # no_par=True,
     )
     progress.close()
 
@@ -135,4 +125,11 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    from sonusai import exception_handler
+    from sonusai.utils import register_keyboard_interrupt
+
+    register_keyboard_interrupt()
+    try:
+        main()
+    except Exception as e:
+        exception_handler(e)