sonusai 0.18.9__py3-none-any.whl → 0.19.5__py3-none-any.whl

sonusai/lsdb.py

@@ -1,11 +1,11 @@
 """sonusai lsdb
 
-usage: lsdb [-hta] [-i MIXID] [-c TID] LOC
+usage: lsdb [-hta] [-i MIXID] [-c CID] LOC
 
 Options:
     -h, --help
     -i MIXID, --mixid MIXID         Mixture ID(s) to analyze. [default: *].
-    -c TID, --truth_index TID       Analyze mixtures that contain this truth index.
+    -c CID, --class_index CID       Analyze mixtures that contain this class index.
     -t, --targets                   List all target files.
     -a, --all_class_counts          List all class counts.
 
@@ -15,6 +15,7 @@ Inputs:
     LOC     A SonusAI mixture database directory.
 
 """
+
 import signal
 
 from sonusai import logger
@@ -27,26 +28,22 @@ def signal_handler(_sig, _frame):
 
     from sonusai import logger
 
-    logger.info('Canceled due to keyboard interrupt')
+    logger.info("Canceled due to keyboard interrupt")
     sys.exit(1)
 
 
 signal.signal(signal.SIGINT, signal_handler)
 
 
-def lsdb(mixdb: MixtureDatabase,
-         mixids: GeneralizedIDs = None,
-         truth_index: int = None,
-         list_targets: bool = False,
-         all_class_counts: bool = False) -> None:
-    import numpy as np
-    import h5py
-
-    from sonusai import SonusAIError
-    from sonusai.metrics import calc_snr_f
+def lsdb(
+    mixdb: MixtureDatabase,
+    mixids: GeneralizedIDs = "*",
+    class_index: int | None = None,
+    list_targets: bool = False,
+    all_class_counts: bool = False,
+) -> None:
     from sonusai.mixture import SAMPLE_RATE
-    from sonusai.mixture import get_truth_indices_for_target
-    from sonusai.queries import get_mixids_from_truth_index
+    from sonusai.queries import get_mixids_from_class_indices
     from sonusai.utils import consolidate_range
     from sonusai.utils import max_text_width
     from sonusai.utils import print_mixture_details
@@ -62,38 +59,40 @@ def lsdb(mixdb: MixtureDatabase,
     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'{"Feature shape":{desc_len}} {mixdb.fg_stride} x {mixdb.feature_parameters} '
-                f'({mixdb.fg_stride * mixdb.feature_parameters} total params)')
+    logger.info(
+        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 step samples":{desc_len}} {mixdb.feature_step_samples} samples '
-                f'({mixdb.feature_step_ms} ms)')
+    logger.info(
+        f'{"Feature step samples":{desc_len}} {mixdb.feature_step_samples} samples ' f'({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'{"Truth mutex":{desc_len}} {mixdb.truth_mutex}')
     # TODO: fix class count
     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('')
+    logger.info("")
 
     if list_targets:
-        logger.info('Target details:')
+        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}} {get_truth_indices_for_target(target)}')
-        logger.info('')
-
-    if truth_index is not None:
-        if 0 <= truth_index > mixdb.num_classes:
-            raise SonusAIError(f'Given truth_index is outside valid range of 1-{mixdb.num_classes}')
-        ids = get_mixids_from_truth_index(mixdb=mixdb, predicate=lambda x: x in [truth_index])[truth_index]
-        logger.info(f'Mixtures with truth index {truth_index}: {ids}')
-        logger.info('')
+            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("")
+
+    if class_index is not None:
+        if 0 <= class_index > mixdb.num_classes:
+            raise ValueError(f"Given class_index is outside valid range of 1-{mixdb.num_classes}")
+        ids = get_mixids_from_class_indices(mixdb=mixdb, predicate=lambda x: x in [class_index])[class_index]
+        logger.info(f"Mixtures with class index {class_index}: {ids}")
+        logger.info("")
 
     mixids = mixdb.mixids_to_list(mixids)
 
@@ -101,24 +100,13 @@ def lsdb(mixdb: MixtureDatabase,
         print_mixture_details(mixdb=mixdb, mixid=mixids[0], desc_len=desc_len, print_fn=logger.info)
         if all_class_counts:
             # TODO: fix class count
-            logger.info('All class count not supported')
+            logger.info("All class count not supported")
             # 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)})')
-        for mixid in mixids:
-            with h5py.File(mixdb.mixture_filename(mixid), 'r') as f:
-                if mixid == mixids[0]:
-                    truth_f = np.array(f['truth_f'])
-                else:
-                    truth_f = np.concatenate((truth_f, np.array(f['truth_f'])))
-
-        snr_mean, snr_std, snr_db_mean, snr_db_std = calc_snr_f(truth_f)
-
-        logger.info('Truth')
-        logger.info(f'  {"mean":^8s}  {"std":^8s}  {"db_mean":^8s}  {"db_std":^8s}')
-        for c in range(len(snr_mean)):
-            logger.info(f'  {snr_mean[c]:8.2f}  {snr_std[c]:8.2f}  {snr_db_mean[c]:8.2f}  {snr_db_std[c]:8.2f}')
+        logger.info(
+            f"Calculating statistics from truth_f files for {len(mixids):,} mixtures" f" ({consolidate_range(mixids)})"
+        )
+        logger.info("Not supported")
 
 
 def main() -> None:
@@ -132,28 +120,30 @@ def main() -> None:
 
     args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
 
-    mixid = args['--mixid']
-    truth_index = args['--truth_index']
-    list_targets = args['--targets']
-    all_class_counts = args['--all_class_counts']
-    location = args['LOC']
+    mixid = args["--mixid"]
+    class_index = args["--class_index"]
+    list_targets = args["--targets"]
+    all_class_counts = args["--all_class_counts"]
+    location = args["LOC"]
 
-    if truth_index is not None:
-        truth_index = int(truth_index)
+    if class_index is not None:
+        class_index = int(class_index)
 
-    create_file_handler('lsdb.log')
+    create_file_handler("lsdb.log")
     update_console_handler(False)
-    initial_log_messages('lsdb')
+    initial_log_messages("lsdb")
 
-    logger.info(f'Analyzing {location}')
+    logger.info(f"Analyzing {location}")
 
     mixdb = MixtureDatabase(location)
-    lsdb(mixdb=mixdb,
-         mixids=mixid,
-         truth_index=truth_index,
-         list_targets=list_targets,
-         all_class_counts=all_class_counts)
+    lsdb(
+        mixdb=mixdb,
+        mixids=mixid,
+        class_index=class_index,
+        list_targets=list_targets,
+        all_class_counts=all_class_counts,
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

sonusai/main.py

@@ -9,6 +9,7 @@ Aaware Sound and Voice Machine Learning Framework. See 'sonusai help <command>'
 for more information on a specific command.
 
 """
+
 import signal
 
 
@@ -17,7 +18,7 @@ def signal_handler(_sig, _frame):
 
     from sonusai import logger
 
-    logger.info('Canceled due to keyboard interrupt')
+    logger.info("Canceled due to keyboard interrupt")
     sys.exit(1)
 
 
@@ -33,11 +34,11 @@ def main() -> None:
     plugins = {}
     plugin_docstrings = []
     for _, name, _ in iter_modules():
-        if name.startswith('sonusai_') and not name.startswith('sonusai_asr_'):
+        if name.startswith("sonusai_") and not name.startswith("sonusai_asr_"):
             module = import_module(name)
             plugins[name] = {
-                'commands': commands_list(module.commands_doc),
-                'basedir':  module.BASEDIR,
+                "commands": commands_list(module.commands_doc),
+                "basedir": module.BASEDIR,
             }
             plugin_docstrings.append(module.commands_doc)
 
@@ -47,12 +48,14 @@ def main() -> None:
     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__,
-                  options_first=True)
+    args = docopt(
+        trim_docstring(add_commands_to_docstring(__doc__, plugin_docstrings)),
+        version=__version__,
+        options_first=True,
+    )
 
-    command = args['<command>']
-    argv = args['<args>']
+    command = args["<command>"]
+    argv = args["<args>"]
 
     import sys
     from os.path import join
@@ -62,29 +65,29 @@ def main() -> None:
     from sonusai import logger
 
     base_commands = sonusai.commands_list()
-    if command == 'help':
+    if command == "help":
         if not argv:
-            exit(call(['sonusai', '-h']))
+            exit(call(["sonusai", "-h"]))  # noqa: S603, S607
         elif argv[0] in base_commands:
-            exit(call(['python', f'{join(sonusai.BASEDIR, argv[0])}.py', '-h']))
+            exit(call(["python", f"{join(sonusai.BASEDIR, argv[0])}.py", "-h"]))  # noqa: S603, S607
 
-        for plugin, data in plugins.items():
-            if argv[0] in data['commands']:
-                exit(call(['python', f'{join(data["basedir"], argv[0])}.py', '-h']))
+        for data in plugins.values():
+            if argv[0] in data["commands"]:
+                exit(call(["python", f"{join(data['basedir'], argv[0])}.py", "-h"]))  # noqa: S603, S607
 
         logger.error(f"{argv[0]} is not a SonusAI command. See 'sonusai help'.")
         sys.exit(1)
 
     if command in base_commands:
-        exit(call(['python', f'{join(sonusai.BASEDIR, command)}.py'] + argv))
+        exit(call(["python", f"{join(sonusai.BASEDIR, command)}.py", *argv]))  # noqa: S603, S607
 
-    for plugin, data in plugins.items():
-        if command in data['commands']:
-            exit(call(['python', f'{join(data["basedir"], command)}.py'] + argv))
+    for data in plugins.values():
+        if command in data["commands"]:
+            exit(call(["python", f"{join(data['basedir'], command)}.py", *argv]))  # noqa: S603, S607
 
     logger.error(f"{command} is not a SonusAI command. See 'sonusai help'.")
     sys.exit(1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

sonusai/metrics/__init__.py

@@ -1,4 +1,6 @@
 # SonusAI metrics utilities for model training and validation
+# ruff: noqa: F401
+
 from .calc_audio_stats import calc_audio_stats
 from .calc_class_weights import calc_class_weights_from_mixdb
 from .calc_class_weights import calc_class_weights_from_truth

sonusai/metrics/calc_audio_stats.py

@@ -3,48 +3,53 @@ from sonusai.mixture.datatypes import AudioT
 
 
 def _convert_str_with_factors_to_int(x: str) -> int:
-    if 'k' in x:
-        return int(1000 * float(x.replace('k', '')))
-    if 'M' in x:
-        return int(1000000 * float(x.replace('M', '')))
+    if "k" in x:
+        return int(1000 * float(x.replace("k", "")))
+    if "M" in x:
+        return int(1000000 * float(x.replace("M", "")))
     return int(x)
 
 
-def calc_audio_stats(audio: AudioT, win_len: float = None) -> AudioStatsMetrics:
+def calc_audio_stats(audio: AudioT, win_len: float | None = None) -> AudioStatsMetrics:
     from sonusai.mixture import SAMPLE_RATE
     from sonusai.mixture import Transformer
 
-    args = ['stats']
+    args = ["stats"]
     if win_len is not None:
-        args.extend(['-w', str(win_len)])
+        args.extend(["-w", str(win_len)])
 
     tfm = Transformer()
 
-    _, _, out = tfm.build(input_array=audio,
-                          sample_rate_in=SAMPLE_RATE,
-                          output_filepath='-n',
-                          extra_args=args,
-                          return_output=True)
+    _, _, out = tfm.build(
+        input_array=audio,
+        sample_rate_in=SAMPLE_RATE,
+        output_filepath="-n",
+        extra_args=args,
+        return_output=True,
+    )
+
+    if out is None:
+        raise SystemError("Call to sox failed")
 
     stats = {}
-    lines = out.split('\n')
+    lines = out.split("\n")
     for line in lines:
         split_line = line.split()
         if len(split_line) == 0:
             continue
         value = split_line[-1]
-        key = ' '.join(split_line[:-1])
+        key = " ".join(split_line[:-1])
         stats[key] = value
 
     return AudioStatsMetrics(
-        dco=float(stats['DC offset']),
-        min=float(stats['Min level']),
-        max=float(stats['Max level']),
-        pkdb=float(stats['Pk lev dB']),
-        lrms=float(stats['RMS lev dB']),
-        pkr=float(stats['RMS Pk dB']),
-        tr=float(stats['RMS Tr dB']),
-        cr=float(stats['Crest factor']),
-        fl=float(stats['Flat factor']),
-        pkc=_convert_str_with_factors_to_int(stats['Pk count']),
+        dco=float(stats["DC offset"]),
+        min=float(stats["Min level"]),
+        max=float(stats["Max level"]),
+        pkdb=float(stats["Pk lev dB"]),
+        lrms=float(stats["RMS lev dB"]),
+        pkr=float(stats["RMS Pk dB"]),
+        tr=float(stats["RMS Tr dB"]),
+        cr=float(stats["Crest factor"]),
+        fl=float(stats["Flat factor"]),
+        pkc=_convert_str_with_factors_to_int(stats["Pk count"]),
     )

sonusai/metrics/calc_class_weights.py

@@ -5,9 +5,7 @@ from sonusai.mixture.datatypes import Truth
 from sonusai.mixture.mixdb import MixtureDatabase
 
 
-def calc_class_weights_from_truth(truth: Truth,
-                                  other_weight: float = None,
-                                  other_index: int = -1) -> np.ndarray:
+def calc_class_weights_from_truth(truth: Truth, other_weight: float | None = None, other_index: int = -1) -> np.ndarray:
     """Calculate class weights.
 
     Supports non-existent classes (a problem with sklearn) where non-existent
@@ -54,10 +52,12 @@ def calc_class_weights_from_truth(truth: Truth,
     return weights
 
 
-def calc_class_weights_from_mixdb(mixdb: MixtureDatabase,
-                                  mixids: GeneralizedIDs = None,
-                                  other_weight: float = 1,
-                                  other_index: int = -1) -> tuple[np.ndarray, np.ndarray]:
+def calc_class_weights_from_mixdb(
+    mixdb: MixtureDatabase,
+    mixids: GeneralizedIDs | None = None,
+    other_weight: float = 1,
+    other_index: int = -1,
+) -> tuple[np.ndarray, np.ndarray]:
     """Calculate class weights using estimated feature counts from a mixture database.
 
     Arguments:

sonusai/metrics/calc_optimal_thresholds.py

@@ -4,10 +4,9 @@ from sonusai.mixture.datatypes import Predict
 from sonusai.mixture.datatypes import Truth
 
 
-def calc_optimal_thresholds(truth: Truth,
-                            predict: Predict,
-                            timesteps: int = 0,
-                            truth_thr: float = 0.5) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+def calc_optimal_thresholds(
+    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].
 
@@ -25,14 +24,13 @@ def calc_optimal_thresholds(truth: Truth,
     from sklearn.metrics import roc_auc_score
     from sklearn.metrics import roc_curve
 
-    from sonusai import SonusAIError
     from sonusai.utils import get_num_classes_from_predict
     from sonusai.utils import reshape_outputs
 
     if truth.shape != predict.shape:
-        raise SonusAIError('truth and predict are not the same shape')
+        raise ValueError("truth and predict are not the same shape")
 
-    predict, truth = reshape_outputs(predict=predict, truth=truth, timesteps=timesteps)
+    predict, truth = reshape_outputs(predict=predict, truth=truth, timesteps=timesteps)  # type: ignore[assignment]
     num_classes = get_num_classes_from_predict(predict=predict, timesteps=timesteps)
 
     # Apply decision to truth input

sonusai/metrics/calc_pcm.py

@@ -1,9 +1,9 @@
 import numpy as np
 
 
-def calc_pcm(hypothesis: np.ndarray,
-             reference: np.ndarray,
-             with_log: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+def calc_pcm(
+    hypothesis: np.ndarray, reference: np.ndarray, with_log: bool = False
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Calculate phase constrained magnitude error
 
     These must include a noise to make a complete mixture estimate, i.e.,

sonusai/metrics/calc_pesq.py

@@ -3,10 +3,12 @@ import numpy as np
 from sonusai.mixture.constants import SAMPLE_RATE
 
 
-def calc_pesq(hypothesis: np.ndarray,
-              reference: np.ndarray,
-              error_value: float = 0.0,
-              sample_rate: int = SAMPLE_RATE) -> float:
+def calc_pesq(
+    hypothesis: np.ndarray,
+    reference: np.ndarray,
+    error_value: float = 0.0,
+    sample_rate: int = SAMPLE_RATE,
+) -> float:
     """Computes the PESQ score of hypothesis vs. reference
 
     Upon error, assigns a value of 0, or user specified value in error_value
@@ -22,12 +24,13 @@ def calc_pesq(hypothesis: np.ndarray,
     from pesq import pesq
 
     from sonusai import logger
+
     try:
         with warnings.catch_warnings():
-            warnings.simplefilter('ignore')
-            score = pesq(fs=sample_rate, ref=reference, deg=hypothesis, mode='wb')
+            warnings.simplefilter("ignore")
+            score = pesq(fs=sample_rate, ref=reference, deg=hypothesis, mode="wb")
     except Exception as e:
-        logger.debug(f'PESQ error {e}')
+        logger.debug(f"PESQ error {e}")
         score = error_value
 
     return score

sonusai/metrics/calc_phase_distance.py

@@ -1,9 +1,9 @@
 import numpy as np
 
 
-def calc_phase_distance(reference: np.ndarray,
-                        hypothesis: np.ndarray,
-                        eps: float = 1e-9) -> tuple[float, np.ndarray, np.ndarray]:
+def calc_phase_distance(
+    reference: np.ndarray, hypothesis: np.ndarray, eps: float = 1e-9
+) -> tuple[float, np.ndarray, np.ndarray]:
     """Calculate weighted phase distance error (weight normalization over bins per frame)
 
     :param reference: complex [frames, bins]

sonusai/metrics/calc_sa_sdr.py

@@ -1,10 +1,12 @@
 import numpy as np
 
 
-def calc_sa_sdr(hypothesis: np.ndarray,
-                reference: np.ndarray,
-                with_scale: bool = False,
-                with_negate: bool = False) -> tuple[np.ndarray, np.ndarray]:
+def calc_sa_sdr(
+    hypothesis: np.ndarray,
+    reference: np.ndarray,
+    with_scale: bool = False,
+    with_negate: bool = False,
+) -> tuple[np.ndarray, np.ndarray]:
     """Calculate source-aggregated SDR (signal distortion ratio) using all source inputs which are [samples, nsrc].
 
     These should include a noise to be a complete mixture estimate, i.e.,
@@ -30,9 +32,9 @@ def calc_sa_sdr(hypothesis: np.ndarray,
     """
     if with_scale:
         # calc 1 x nsrc scaling factors
-        ref_energy = np.sum(reference ** 2, axis=0, keepdims=True)
+        ref_energy = np.sum(reference**2, axis=0, keepdims=True)
         # if ref_energy is zero, just set scaling to 1.0
-        with np.errstate(divide='ignore', invalid='ignore'):
+        with np.errstate(divide="ignore", invalid="ignore"):
             opt_scale = np.sum(reference * hypothesis, axis=0, keepdims=True) / ref_energy
             opt_scale[opt_scale == np.inf] = 1.0
             opt_scale = np.nan_to_num(opt_scale, nan=1.0)
@@ -46,8 +48,8 @@ def calc_sa_sdr(hypothesis: np.ndarray,
 
     # -10*log10(sumk(||sk||^2) / sumk(||sk - shk||^2)
     # sum over samples and sources
-    num = np.sum(reference ** 2)
-    den = np.sum(err ** 2)
+    num = np.sum(reference**2)
+    den = np.sum(err**2)
     if num == 0 and den == 0:
         ratio = np.inf
     else:

sonusai/metrics/calc_segsnr_f.py

@@ -33,10 +33,7 @@ def calc_segsnr_f(segsnr_f: Segsnr) -> SnrFMetrics:
         snr_db_mean = np.mean(tmp, axis=0)
         snr_db_std = np.std(tmp, axis=0)
 
-    return SnrFMetrics(snr_mean,
-                       snr_std,
-                       snr_db_mean,
-                       snr_db_std)
+    return SnrFMetrics(snr_mean, snr_std, snr_db_mean, snr_db_std)
 
 
 def calc_segsnr_f_bin(target_f: AudioF, noise_f: AudioF) -> SnrFBinMetrics:
@@ -46,25 +43,24 @@ def calc_segsnr_f_bin(target_f: AudioF, noise_f: AudioF) -> SnrFBinMetrics:
     and mean and standard deviation of the dB values.
     """
     if target_f.ndim != 2 and noise_f.ndim != 2:
-        raise ValueError('target_f and noise_f must have 2 dimensions')
+        raise ValueError("target_f and noise_f must have 2 dimensions")
 
     segsnr_f = (np.abs(target_f) ** 2) / (np.abs(noise_f) ** 2)
 
     frames, bins = segsnr_f.shape
     if np.count_nonzero(segsnr_f) == 0:
         # If all entries are zeros
-        return SnrFBinMetrics(np.zeros(bins),
-                              np.zeros(bins),
-                              -np.inf * np.ones(bins),
-                              np.zeros(bins))
+        return SnrFBinMetrics(np.zeros(bins), np.zeros(bins), -np.inf * np.ones(bins), np.zeros(bins))
 
     tmp = np.ma.array(segsnr_f, mask=np.logical_not(np.isfinite(segsnr_f)))
     if np.ma.count_masked(tmp) == np.ma.size(tmp, axis=0):
         # If all entries are infinite
-        return SnrFBinMetrics(np.inf * np.ones(bins),
-                              np.zeros(bins),
-                              np.inf * np.ones(bins),
-                              np.zeros(bins))
+        return SnrFBinMetrics(
+            np.inf * np.ones(bins),
+            np.zeros(bins),
+            np.inf * np.ones(bins),
+            np.zeros(bins),
+        )
 
     snr_mean = np.mean(tmp, axis=0)
     snr_std = np.std(tmp, axis=0)
@@ -78,7 +74,9 @@ def calc_segsnr_f_bin(target_f: AudioF, noise_f: AudioF) -> SnrFBinMetrics:
         snr_db_mean = np.mean(tmp, axis=0)
         snr_db_std = np.std(tmp, axis=0)
 
-    return SnrFBinMetrics(np.ma.getdata(snr_mean),
-                          np.ma.getdata(snr_std),
-                          np.ma.getdata(snr_db_mean),
-                          np.ma.getdata(snr_db_std))
+    return SnrFBinMetrics(
+        np.ma.getdata(snr_mean),
+        np.ma.getdata(snr_std),
+        np.ma.getdata(snr_db_mean),
+        np.ma.getdata(snr_db_std),
+    )