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

sonusai/lsdb.py

@@ -1,12 +1,12 @@
 """sonusai lsdb
 
-usage: lsdb [-hta] [-i MIXID] [-c CID] LOC
+usage: lsdb [-hsa] [-i MIXID] [-c CID] LOC
 
 Options:
     -h, --help
     -i MIXID, --mixid MIXID         Mixture ID(s) to analyze. [default: *].
     -c CID, --class_index CID       Analyze mixtures that contain this class index.
-    -t, --targets                   List all target files.
+    -s, --sources                   List all source files.
     -a, --all_class_counts          List all class counts.
 
 List mixture data information from a SonusAI mixture database.
@@ -16,25 +16,10 @@ Inputs:
 
 """
 
-import signal
-
-from sonusai import logger
-from sonusai.mixture import GeneralizedIDs
+from sonusai.datatypes import GeneralizedIDs
 from sonusai.mixture import MixtureDatabase
 
 
-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 lsdb(
     mixdb: MixtureDatabase,
     mixids: GeneralizedIDs = "*",
@@ -42,7 +27,8 @@ def lsdb(
     list_targets: bool = False,
     all_class_counts: bool = False,
 ) -> None:
-    from sonusai.mixture import SAMPLE_RATE
+    from sonusai import logger
+    from sonusai.constants import SAMPLE_RATE
     from sonusai.queries import get_mixids_from_class_indices
     from sonusai.utils import consolidate_range
     from sonusai.utils import max_text_width
@@ -54,38 +40,36 @@ def lsdb(
     total_samples = mixdb.total_samples()
     total_duration = total_samples / SAMPLE_RATE
 
-    logger.info(f'{"Mixtures":{desc_len}} {mixdb.num_mixtures}')
-    logger.info(f'{"Duration":{desc_len}} {seconds_to_hms(seconds=total_duration)}')
-    logger.info(f'{"Targets":{desc_len}} {mixdb.num_target_files}')
-    logger.info(f'{"Noises":{desc_len}} {mixdb.num_noise_files}')
-    logger.info(f'{"Feature":{desc_len}} {mixdb.feature}')
+    logger.info(f"{'Mixtures':{desc_len}} {mixdb.num_mixtures}")
+    logger.info(f"{'Duration':{desc_len}} {seconds_to_hms(seconds=total_duration)}")
+    logger.info(f"{'Sources':{desc_len}} {mixdb.num_source_files}")
+    logger.info(f"{'Feature':{desc_len}} {mixdb.feature}")
     logger.info(
-        f'{"Feature shape":{desc_len}} {mixdb.fg_stride} x {mixdb.feature_parameters} '
-        f'({mixdb.fg_stride * mixdb.feature_parameters} total params)'
+        f"{'Feature shape':{desc_len}} {mixdb.fg_stride} x {mixdb.feature_parameters} "
+        f"({mixdb.fg_stride * mixdb.feature_parameters} total params)"
     )
-    logger.info(f'{"Feature samples":{desc_len}} {mixdb.feature_samples} samples ({mixdb.feature_ms} ms)')
+    logger.info(f"{'Feature samples':{desc_len}} {mixdb.feature_samples} samples ({mixdb.feature_ms} ms)")
     logger.info(
-        f'{"Feature step samples":{desc_len}} {mixdb.feature_step_samples} samples ' f'({mixdb.feature_step_ms} ms)'
+        f"{'Feature step samples':{desc_len}} {mixdb.feature_step_samples} samples ({mixdb.feature_step_ms} ms)"
     )
-    logger.info(f'{"Feature overlap":{desc_len}} {mixdb.fg_step / mixdb.fg_stride} ({mixdb.feature_step_ms} ms)')
-    logger.info(f'{"SNRs":{desc_len}} {mixdb.snrs}')
-    logger.info(f'{"Random SNRs":{desc_len}} {mixdb.random_snrs}')
-    logger.info(f'{"Classes":{desc_len}} {mixdb.num_classes}')
+    logger.info(f"{'Feature overlap':{desc_len}} {mixdb.fg_step / mixdb.fg_stride} ({mixdb.feature_step_ms} ms)")
+    logger.info(f"{'SNRs':{desc_len}} {mixdb.snrs}")
+    logger.info(f"{'Random SNRs':{desc_len}} {mixdb.random_snrs}")
+    logger.info(f"{'Classes':{desc_len}} {mixdb.num_classes}")
     # TODO: fix class count
-    logger.info(f'{"Class count":{desc_len}} not supported')
+    logger.info(f"{'Class count':{desc_len}} not supported")
     # print_class_count(class_count=class_count, length=desc_len, print_fn=logger.info)
     # TODO: add class weight calculations here
     logger.info("")
 
     if list_targets:
-        logger.info("Target details:")
-        idx_len = max_text_width(mixdb.num_target_files)
-        for idx, target in enumerate(mixdb.target_files):
-            desc = f"  {idx:{idx_len}} Name"
-            logger.info(f"{desc:{desc_len}} {target.name}")
-            desc = f"  {idx:{idx_len}} Truth index"
-            logger.info(f"{desc:{desc_len}} {target.class_indices}")
-        logger.info("")
+        logger.info("Source details:")
+        for category, sources in mixdb.source_files.items():
+            print(f"  {category}:")
+            for source in sources:
+                logger.info(f"{'    Name':{desc_len}} {source.name}")
+                logger.info(f"{'    Truth index':{desc_len}} {source.class_indices}")
+            logger.info("")
 
     if class_index is not None:
         if 0 <= class_index > mixdb.num_classes:
@@ -104,7 +88,7 @@ def lsdb(
             # print_class_count(class_count=class_count, length=desc_len, print_fn=logger.info, all_class_counts=True)
     else:
         logger.info(
-            f"Calculating statistics from truth_f files for {len(mixids):,} mixtures" f" ({consolidate_range(mixids)})"
+            f"Calculating statistics from truth_f files for {len(mixids):,} mixtures ({consolidate_range(mixids)})"
         )
         logger.info("Not supported")
 
@@ -112,13 +96,10 @@ def lsdb(
 def main() -> None:
     from docopt import docopt
 
-    import sonusai
-    from sonusai import create_file_handler
-    from sonusai import initial_log_messages
-    from sonusai import update_console_handler
+    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)
 
     mixid = args["--mixid"]
     class_index = args["--class_index"]
@@ -126,6 +107,11 @@ def main() -> None:
     all_class_counts = args["--all_class_counts"]
     location = args["LOC"]
 
+    from sonusai import create_file_handler
+    from sonusai import initial_log_messages
+    from sonusai import logger
+    from sonusai import update_console_handler
+
     if class_index is not None:
         class_index = int(class_index)
 
@@ -146,4 +132,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)

sonusai/main.py

@@ -10,21 +10,6 @@ for more information on a specific command.
 
 """
 
-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 main() -> None:
     from importlib import import_module
     from pkgutil import iter_modules
@@ -44,13 +29,13 @@ def main() -> None:
 
     from docopt import docopt
 
-    from sonusai import __version__
+    from sonusai import __version__ as sai_version
     from sonusai.utils import add_commands_to_docstring
     from sonusai.utils import trim_docstring
 
     args = docopt(
         trim_docstring(add_commands_to_docstring(__doc__, plugin_docstrings)),
-        version=__version__,
+        version=sai_version,
         options_first=True,
     )
 
@@ -61,15 +46,16 @@ def main() -> None:
     from os.path import join
     from subprocess import call
 
-    import sonusai
+    from sonusai import BASEDIR
+    from sonusai import commands_list
     from sonusai import logger
 
-    base_commands = sonusai.commands_list()
+    base_commands = commands_list()
     if command == "help":
         if not argv:
             exit(call(["sonusai", "-h"]))  # noqa: S603, S607
         elif argv[0] in base_commands:
-            exit(call(["python", f"{join(sonusai.BASEDIR, argv[0])}.py", "-h"]))  # noqa: S603, S607
+            exit(call(["python", f"{join(BASEDIR, argv[0])}.py", "-h"]))  # noqa: S603, S607
 
         for data in plugins.values():
             if argv[0] in data["commands"]:
@@ -79,7 +65,7 @@ def main() -> None:
         sys.exit(1)
 
     if command in base_commands:
-        exit(call(["python", f"{join(sonusai.BASEDIR, command)}.py", *argv]))  # noqa: S603, S607
+        exit(call(["python", f"{join(BASEDIR, command)}.py", *argv]))  # noqa: S603, S607
 
     for data in plugins.values():
         if command in data["commands"]:
@@ -90,4 +76,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)

sonusai/metrics/calc_audio_stats.py

@@ -1,10 +1,5 @@
-from pathlib import Path
-
-import numpy as np
-from sox import Transformer as SoxTransformer
-
-from sonusai.mixture.datatypes import AudioStatsMetrics
-from sonusai.mixture.datatypes import AudioT
+from ..datatypes import AudioStatsMetrics
+from ..datatypes import AudioT
 
 
 def _convert_str_with_factors_to_int(x: str) -> int:
@@ -16,21 +11,9 @@ def _convert_str_with_factors_to_int(x: str) -> int:
 
 
 def calc_audio_stats(audio: AudioT, win_len: float | None = None) -> AudioStatsMetrics:
-    from sonusai.mixture import SAMPLE_RATE
-
-    args = ["stats"]
-    if win_len is not None:
-        args.extend(["-w", str(win_len)])
-
-    tfm = Transformer()
+    from ..mixture.sox_effects import sox_stats
 
-    _, _, out = tfm.build(
-        input_array=audio,
-        sample_rate_in=SAMPLE_RATE,
-        output_filepath="-n",
-        extra_args=args,
-        return_output=True,
-    )
+    out = sox_stats(audio, win_len)
 
     if out is None:
         raise SystemError("Call to sox failed")
@@ -57,275 +40,3 @@ def calc_audio_stats(audio: AudioT, win_len: float | None = None) -> AudioStatsM
         fl=float(stats["Flat factor"]),
         pkc=_convert_str_with_factors_to_int(stats["Pk count"]),
     )
-
-
-class Transformer(SoxTransformer):
-    """Override certain sox.Transformer methods"""
-
-    def build(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self,
-        input_filepath: str | Path | None = None,
-        output_filepath: str | Path | None = None,
-        input_array: np.ndarray | None = None,
-        sample_rate_in: float | None = None,
-        extra_args: list[str] | None = None,
-        return_output: bool = False,
-    ) -> tuple[bool, str | None, str | None]:
-        """Given an input file or array, creates an output_file on disk by
-        executing the current set of commands. This function returns True on
-        success. If return_output is True, this function returns a triple of
-        (status, out, err), giving the success state, along with stdout and
-        stderr returned by sox.
-
-        Parameters
-        ----------
-        input_filepath : str or None
-            Either path to input audio file or None for array input.
-        output_filepath : str
-            Path to desired output file. If a file already exists at
-            the given path, the file will be overwritten.
-            If '-n', no file is created.
-        input_array : np.ndarray or None
-            An np.ndarray of an waveform with shape (n_samples, n_channels).
-            sample_rate_in must also be provided.
-            If None, input_filepath must be specified.
-        sample_rate_in : int
-            Sample rate of input_array.
-            This argument is ignored if input_array is None.
-        extra_args : list or None, default=None
-            If a list is given, these additional arguments are passed to SoX
-            at the end of the list of effects.
-            Don't use this argument unless you know exactly what you're doing!
-        return_output : bool, default=False
-            If True, returns the status and information sent to stderr and
-            stdout as a tuple (status, stdout, stderr).
-            If output_filepath is None, return_output=True by default.
-            If False, returns True on success.
-
-        Returns
-        -------
-        status : bool
-            True on success.
-        out : str (optional)
-            This is not returned unless return_output is True.
-            When returned, captures the stdout produced by sox.
-        err : str (optional)
-            This is not returned unless return_output is True.
-            When returned, captures the stderr produced by sox.
-
-        Examples
-        --------
-        > import numpy as np
-        > import sox
-        > tfm = sox.Transformer()
-        > sample_rate = 44100
-        > y = np.sin(2 * np.pi * 440.0 * np.arange(sample_rate * 1.0) / sample_rate)
-
-        file in, file out - basic usage
-
-        > status = tfm.build('path/to/input.wav', 'path/to/output.mp3')
-
-        file in, file out - equivalent usage
-
-        > status = tfm.build(
-                input_filepath='path/to/input.wav',
-                output_filepath='path/to/output.mp3'
-            )
-
-        array in, file out
-
-        > status = tfm.build(
-                input_array=y, sample_rate_in=sample_rate,
-                output_filepath='path/to/output.mp3'
-            )
-
-        """
-        from sox import file_info
-        from sox.core import SoxError
-        from sox.core import sox
-        from sox.log import logger
-
-        input_format, input_filepath = self._parse_inputs(input_filepath, input_array, sample_rate_in)
-
-        if output_filepath is None:
-            raise ValueError("output_filepath is not specified!")
-
-        # set output parameters
-        if input_filepath == output_filepath:
-            raise ValueError("input_filepath must be different from output_filepath.")
-        file_info.validate_output_file(output_filepath)
-
-        args = []
-        args.extend(self.globals)
-        args.extend(self._input_format_args(input_format))
-        args.append(input_filepath)
-        args.extend(self._output_format_args(self.output_format))
-        args.append(output_filepath)
-        args.extend(self.effects)
-
-        if extra_args is not None:
-            if not isinstance(extra_args, list):
-                raise ValueError("extra_args must be a list.")
-            args.extend(extra_args)
-
-        status, out, err = sox(args, input_array, True)
-        if status != 0:
-            raise SoxError(f"Stdout: {out}\nStderr: {err}")
-
-        logger.info("Created %s with effects: %s", output_filepath, " ".join(self.effects_log))
-
-        if return_output:
-            return status, out, err  # pyright: ignore [reportReturnType]
-
-        return True, None, None
-
-    def build_array(  # pyright: ignore [reportIncompatibleMethodOverride]
-        self,
-        input_filepath: str | Path | None = None,
-        input_array: np.ndarray | None = None,
-        sample_rate_in: int | None = None,
-        extra_args: list[str] | None = None,
-    ) -> np.ndarray:
-        """Given an input file or array, returns the output as a numpy array
-        by executing the current set of commands. By default, the array will
-        have the same sample rate as the input file unless otherwise specified
-        using set_output_format. Functions such as channels and convert
-        will be ignored!
-
-        The SonusAI override does not generate a warning for rate transforms.
-
-        Parameters
-        ----------
-        input_filepath : str, Path or None
-            Either path to input audio file or None.
-        input_array : np.ndarray or None
-            A np.ndarray of a waveform with shape (n_samples, n_channels).
-            If this argument is passed, sample_rate_in must also be provided.
-            If None, input_filepath must be specified.
-        sample_rate_in : int
-            Sample rate of input_array.
-            This argument is ignored if input_array is None.
-        extra_args : list or None, default=None
-            If a list is given, these additional arguments are passed to SoX
-            at the end of the list of effects.
-            Don't use this argument unless you know exactly what you're doing!
-
-        Returns
-        -------
-        output_array : np.ndarray
-            Output audio as a numpy array
-
-        Examples
-        --------
-
-        > import numpy as np
-        > import sox
-        > tfm = sox.Transformer()
-        > sample_rate = 44100
-        > y = np.sin(2 * np.pi * 440.0 * np.arange(sample_rate * 1.0) / sample_rate)
-
-        file in, array out
-
-        > output_array = tfm.build(input_filepath='path/to/input.wav')
-
-        array in, array out
-
-        > output_array = tfm.build(input_array=y, sample_rate_in=sample_rate)
-
-        specifying the output sample rate
-
-        > tfm.set_output_format(rate=8000)
-        > output_array = tfm.build(input_array=y, sample_rate_in=sample_rate)
-
-        if an effect changes the number of channels, you must explicitly
-        specify the number of output channels
-
-        > tfm.remix(remix_dictionary={1: [1], 2: [1], 3: [1]})
-        > tfm.set_output_format(channels=3)
-        > output_array = tfm.build(input_array=y, sample_rate_in=sample_rate)
-
-
-        """
-        from sox.core import SoxError
-        from sox.core import sox
-        from sox.log import logger
-        from sox.transform import ENCODINGS_MAPPING
-
-        input_format, input_filepath = self._parse_inputs(input_filepath, input_array, sample_rate_in)
-
-        # check if any of the below commands are part of the effects chain
-        ignored_commands = ["channels", "convert"]
-        if set(ignored_commands) & set(self.effects_log):
-            logger.warning(
-                "When outputting to an array, channels and convert "
-                + "effects may be ignored. Use set_output_format() to "
-                + "specify output formats."
-            )
-
-        output_filepath = "-"
-
-        if input_format.get("file_type") is None:
-            encoding_out = np.int16
-        else:
-            encoding_out = next(k for k, v in ENCODINGS_MAPPING.items() if input_format["file_type"] == v)
-
-        n_bits = np.dtype(encoding_out).itemsize * 8
-
-        output_format = {
-            "file_type": "raw",
-            "rate": sample_rate_in,
-            "bits": n_bits,
-            "channels": input_format["channels"],
-            "encoding": None,
-            "comments": None,
-            "append_comments": True,
-        }
-
-        if self.output_format.get("rate") is not None:
-            output_format["rate"] = self.output_format["rate"]
-
-        if self.output_format.get("channels") is not None:
-            output_format["channels"] = self.output_format["channels"]
-
-        if self.output_format.get("bits") is not None:
-            n_bits = self.output_format["bits"]
-            output_format["bits"] = n_bits
-
-        match n_bits:
-            case 8:
-                encoding_out = np.int8  # type: ignore[assignment]
-            case 16:
-                encoding_out = np.int16
-            case 32:
-                encoding_out = np.float32  # type: ignore[assignment]
-            case 64:
-                encoding_out = np.float64  # type: ignore[assignment]
-            case _:
-                raise ValueError(f"invalid n_bits {n_bits}")
-
-        args = []
-        args.extend(self.globals)
-        args.extend(self._input_format_args(input_format))
-        args.append(input_filepath)
-        args.extend(self._output_format_args(output_format))
-        args.append(output_filepath)
-        args.extend(self.effects)
-
-        if extra_args is not None:
-            if not isinstance(extra_args, list):
-                raise ValueError("extra_args must be a list.")
-            args.extend(extra_args)
-
-        status, out, err = sox(args, input_array, False)
-        if status != 0:
-            raise SoxError(f"Stdout: {out}\nStderr: {err}")
-
-        out = np.frombuffer(out, dtype=encoding_out)  # pyright: ignore [reportArgumentType, reportCallIssue]
-        if output_format["channels"] > 1:
-            out = out.reshape(
-                (output_format["channels"], int(len(out) / output_format["channels"])),
-                order="F",
-            ).T
-        logger.info("Created array with effects: %s", " ".join(self.effects_log))
-
-        return out

sonusai/metrics/calc_class_weights.py

@@ -1,8 +1,8 @@
 import numpy as np
 
-from sonusai.mixture.datatypes import GeneralizedIDs
-from sonusai.mixture.datatypes import Truth
-from sonusai.mixture.mixdb import MixtureDatabase
+from ..datatypes import GeneralizedIDs
+from ..datatypes import Truth
+from ..mixture.mixdb import MixtureDatabase
 
 
 def calc_class_weights_from_truth(truth: Truth, other_weight: float | None = None, other_index: int = -1) -> np.ndarray:
@@ -74,7 +74,7 @@ def calc_class_weights_from_mixdb(
         weights: Class weights. [num_classes, 1]
             Note: for Keras use dict(enumerate(weights))
     """
-    from sonusai.mixture import get_class_count_from_mixids
+    from ..mixture.class_count import get_class_count_from_mixids
 
     count = np.ceil(np.array(get_class_count_from_mixids(mixdb=mixdb, mixids=mixids)) / mixdb.feature_step_samples)
     total_features = sum(count)

sonusai/metrics/calc_optimal_thresholds.py

@@ -1,11 +1,14 @@
 import numpy as np
 
-from sonusai.mixture.datatypes import Predict
-from sonusai.mixture.datatypes import Truth
+from ..datatypes import Predict
+from ..datatypes import Truth
 
 
 def calc_optimal_thresholds(
-    truth: Truth, predict: Predict, timesteps: int = 0, truth_thr: float = 0.5
+    truth: Truth,
+    predict: Predict,
+    timesteps: int = 0,
+    truth_thr: float = 0.5,
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """Calculates optimal thresholds for each class from one-hot prediction and truth data where both are
     one-hot probabilities (or quantized decisions) with size [frames, num_classes] or [frames, timesteps, num_classes].
@@ -24,8 +27,8 @@ def calc_optimal_thresholds(
     from sklearn.metrics import roc_auc_score
     from sklearn.metrics import roc_curve
 
-    from sonusai.utils import get_num_classes_from_predict
-    from sonusai.utils import reshape_outputs
+    from ..utils.reshape import get_num_classes_from_predict
+    from ..utils.reshape import reshape_outputs
 
     if truth.shape != predict.shape:
         raise ValueError("truth and predict are not the same shape")

sonusai/metrics/calc_pesq.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from sonusai.mixture.constants import SAMPLE_RATE
+from ..constants import SAMPLE_RATE
 
 
 def calc_pesq(
@@ -23,7 +23,7 @@ def calc_pesq(
 
     from pesq import pesq
 
-    from sonusai import logger
+    from .. import logger
 
     try:
         with warnings.catch_warnings():

sonusai/metrics/calc_segsnr_f.py

@@ -1,9 +1,9 @@
 import numpy as np
 
-from sonusai.mixture.datatypes import AudioF
-from sonusai.mixture.datatypes import Segsnr
-from sonusai.mixture.datatypes import SnrFBinMetrics
-from sonusai.mixture.datatypes import SnrFMetrics
+from ..datatypes import AudioF
+from ..datatypes import Segsnr
+from ..datatypes import SnrFBinMetrics
+from ..datatypes import SnrFMetrics
 
 
 def calc_segsnr_f(segsnr_f: Segsnr) -> SnrFMetrics: