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

sonusai/calc_metric_spenh.py

@@ -59,9 +59,10 @@ Metric and extraction data are written into prediction location PLOC as separate
 Inputs:
 
 """
+
 import signal
+from contextlib import redirect_stdout
 from dataclasses import dataclass
-from typing import Optional
 
 import matplotlib
 import matplotlib.pyplot as plt
@@ -83,51 +84,33 @@ 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)
 
-matplotlib.use('SVG')
+matplotlib.use("SVG")
 
 
 @dataclass
 class MPGlobal:
-    mixdb: MixtureDatabase = None
-    predict_location: str = None
-    predict_wav_mode: bool = None
-    truth_est_mode: bool = None
-    enable_plot: bool = None
-    enable_wav: bool = None
-    asr_method: str = None
-    asr_model_name: str = None
-
-
-MP_GLOBAL = MPGlobal()
-
-
-def power_compress(spec):
-    mag = np.abs(spec)
-    phase = np.angle(spec)
-    mag = mag ** 0.3
-    real_compress = mag * np.cos(phase)
-    imag_compress = mag * np.sin(phase)
-    return real_compress + 1j * imag_compress
+    mixdb: MixtureDatabase
+    predict_location: str
+    predict_wav_mode: bool
+    truth_est_mode: bool
+    enable_plot: bool
+    enable_wav: bool
+    asr_method: str
+    asr_model_name: str
 
 
-def power_uncompress(spec):
-    mag = np.abs(spec)
-    phase = np.angle(spec)
-    mag = mag ** (1. / 0.3)
-    real_uncompress = mag * np.cos(phase)
-    imag_uncompress = mag * np.sin(phase)
-    return real_uncompress + 1j * imag_uncompress
+MP_GLOBAL: MPGlobal
 
 
-def mean_square_error(hypothesis: np.ndarray,
-                      reference: np.ndarray,
-                      squared: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+def mean_square_error(
+    hypothesis: np.ndarray, reference: np.ndarray, squared: bool = False
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Calculate root-mean-square error or mean square error
 
     :param hypothesis: [frames, bins]
@@ -152,8 +135,9 @@ def mean_square_error(hypothesis: np.ndarray,
     return err, err_b, err_f
 
 
-def mean_abs_percentage_error(hypothesis: np.ndarray,
-                              reference: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+def mean_abs_percentage_error(
+    hypothesis: np.ndarray, reference: np.ndarray
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Calculate mean abs percentage error
 
     If inputs are complex, calculates average: mape(real)/2 + mape(imag)/2
@@ -205,13 +189,16 @@ def log_error(reference: np.ndarray, hypothesis: np.ndarray) -> tuple[np.ndarray
     return err, err_b, err_f
 
 
-def plot_mixpred(mixture: AudioT,
-                 mixture_f: AudioF,
-                 target: Optional[AudioT] = None,
-                 feature: Optional[Feature] = None,
-                 predict: Optional[Predict] = None,
-                 tp_title: str = '') -> plt.Figure:
+def plot_mixpred(
+    mixture: AudioT,
+    mixture_f: AudioF,
+    target: AudioT | None = None,
+    feature: Feature | None = None,
+    predict: Predict | None = None,
+    tp_title: str = "",
+) -> plt.Figure:
     from sonusai.mixture import SAMPLE_RATE
+
     num_plots = 2
     if feature is not None:
         num_plots += 1
@@ -223,36 +210,48 @@ def plot_mixpred(mixture: AudioT,
     # Plot the waveform
     p = 0
     x_axis = np.arange(len(mixture), dtype=np.float32) / SAMPLE_RATE
-    ax[p].plot(x_axis, mixture, label='Mixture', color='mistyrose')
-    ax[0].set_ylabel('magnitude', color='tab:blue')
+    ax[p].plot(x_axis, mixture, label="Mixture", color="mistyrose")
+    ax[0].set_ylabel("magnitude", color="tab:blue")
     ax[p].set_xlim(x_axis[0], x_axis[-1])
     if target is not None:  # Plot target time-domain waveform on top of mixture
-        ax[0].plot(x_axis, target, label='Target', color='tab:blue')
-    ax[p].set_title('Waveform')
+        ax[0].plot(x_axis, target, label="Target", color="tab:blue")
+    ax[p].set_title("Waveform")
 
     # Plot the mixture spectrogram
     p += 1
-    ax[p].imshow(np.transpose(mixture_f), aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Mixture')
+    ax[p].imshow(np.transpose(mixture_f), aspect="auto", interpolation="nearest", origin="lower")
+    ax[p].set_title("Mixture")
 
     if feature is not None:
         p += 1
-        ax[p].imshow(np.transpose(feature), aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Feature')
+        ax[p].imshow(
+            np.transpose(feature),
+            aspect="auto",
+            interpolation="nearest",
+            origin="lower",
+        )
+        ax[p].set_title("Feature")
 
     if predict is not None:
         p += 1
-        im = ax[p].imshow(np.transpose(predict), aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Predict ' + tp_title)
-        plt.colorbar(im, location='bottom')
+        im = ax[p].imshow(
+            np.transpose(predict),
+            aspect="auto",
+            interpolation="nearest",
+            origin="lower",
+        )
+        ax[p].set_title("Predict " + tp_title)
+        plt.colorbar(im, location="bottom")
 
     return fig
 
 
-def plot_pdb_predict_truth(predict: np.ndarray,
-                           truth_f: Optional[np.ndarray] = None,
-                           metric: Optional[np.ndarray] = None,
-                           tp_title: str = '') -> plt.Figure:
+def plot_pdb_predict_truth(
+    predict: np.ndarray,
+    truth_f: np.ndarray | None = None,
+    metric: np.ndarray | None = None,
+    tp_title: str = "",
+) -> plt.Figure:
     """Plot predict and optionally truth and a metric in power db, e.g. applies 10*log10(predict)"""
     num_plots = 2
     if truth_f is not None:
@@ -263,48 +262,62 @@ def plot_pdb_predict_truth(predict: np.ndarray,
     # Plot the predict spectrogram
     p = 0
     tmp = 10 * np.log10(predict.transpose() + np.finfo(np.float32).eps)
-    im = ax[p].imshow(tmp, aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Predict')
-    plt.colorbar(im, location='bottom')
+    im = ax[p].imshow(tmp, aspect="auto", interpolation="nearest", origin="lower")
+    ax[p].set_title("Predict")
+    plt.colorbar(im, location="bottom")
 
     if truth_f is not None:
         p += 1
         tmp = 10 * np.log10(truth_f.transpose() + np.finfo(np.float32).eps)
-        im = ax[p].imshow(tmp, aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Truth')
-        plt.colorbar(im, location='bottom')
+        im = ax[p].imshow(tmp, aspect="auto", interpolation="nearest", origin="lower")
+        ax[p].set_title("Truth")
+        plt.colorbar(im, location="bottom")
 
     # Plot the predict avg, and optionally truth avg and metric lines
     pred_avg = 10 * np.log10(np.mean(predict, axis=-1) + np.finfo(np.float32).eps)
     p += 1
     x_axis = np.arange(len(pred_avg), dtype=np.float32)  # / SAMPLE_RATE
-    ax[p].plot(x_axis, pred_avg, color='black', linestyle='dashed', label='Predict mean over freq.')
-    ax[p].set_ylabel('mean db', color='black')
+    ax[p].plot(
+        x_axis,
+        pred_avg,
+        color="black",
+        linestyle="dashed",
+        label="Predict mean over freq.",
+    )
+    ax[p].set_ylabel("mean db", color="black")
     ax[p].set_xlim(x_axis[0], x_axis[-1])
     if truth_f is not None:
         truth_avg = 10 * np.log10(np.mean(truth_f, axis=-1) + np.finfo(np.float32).eps)
-        ax[p].plot(x_axis, truth_avg, color='green', linestyle='dashed', label='Truth mean over freq.')
+        ax[p].plot(
+            x_axis,
+            truth_avg,
+            color="green",
+            linestyle="dashed",
+            label="Truth mean over freq.",
+        )
 
     if metric is not None:  # instantiate 2nd y-axis that shares the same x-axis
         ax2 = ax[p].twinx()
-        color2 = 'red'
-        ax2.plot(x_axis, metric, color=color2, label='sig distortion (mse db)')
+        color2 = "red"
+        ax2.plot(x_axis, metric, color=color2, label="sig distortion (mse db)")
         ax2.set_xlim(x_axis[0], x_axis[-1])
         ax2.set_ylim([0, np.max(metric)])
-        ax2.set_ylabel('spectral distortion (mse db)', color=color2)
-        ax2.tick_params(axis='y', labelcolor=color2)
-        ax[p].set_title('SNR and SNR mse (mean over freq. db)')
+        ax2.set_ylabel("spectral distortion (mse db)", color=color2)
+        ax2.tick_params(axis="y", labelcolor=color2)
+        ax[p].set_title("SNR and SNR mse (mean over freq. db)")
     else:
-        ax[p].set_title('SNR (mean over freq. db)')
+        ax[p].set_title("SNR (mean over freq. db)")
     return fig
 
 
-def plot_e_predict_truth(predict: np.ndarray,
-                         predict_wav: np.ndarray,
-                         truth_f: Optional[np.ndarray] = None,
-                         truth_wav: Optional[np.ndarray] = None,
-                         metric: Optional[np.ndarray] = None,
-                         tp_title: str = '') -> plt.Figure:
+def plot_e_predict_truth(
+    predict: np.ndarray,
+    predict_wav: np.ndarray,
+    truth_f: np.ndarray | None = None,
+    truth_wav: np.ndarray | None = None,
+    metric: np.ndarray | None = None,
+    tp_title: str = "",
+) -> plt.Figure:
     """Plot predict spectrogram and waveform and optionally truth and a metric)"""
     num_plots = 2
     if truth_f is not None:
@@ -316,26 +329,32 @@ def plot_e_predict_truth(predict: np.ndarray,
 
     # Plot the predict spectrogram
     p = 0
-    im = ax[p].imshow(predict.transpose(), aspect='auto', interpolation='nearest', origin='lower')
-    ax[p].set_title('Predict')
-    plt.colorbar(im, location='bottom')
+    im = ax[p].imshow(predict.transpose(), aspect="auto", interpolation="nearest", origin="lower")
+    ax[p].set_title("Predict")
+    plt.colorbar(im, location="bottom")
 
     if truth_f is not None:  # plot truth if provided and use same colormap as predict
         p += 1
-        ax[p].imshow(truth_f.transpose(), im.cmap, aspect='auto', interpolation='nearest', origin='lower')
-        ax[p].set_title('Truth')
+        ax[p].imshow(
+            truth_f.transpose(),
+            im.cmap,
+            aspect="auto",
+            interpolation="nearest",
+            origin="lower",
+        )
+        ax[p].set_title("Truth")
 
     # Plot predict wav, and optionally truth avg and metric lines
     p += 1
     x_axis = np.arange(len(predict_wav), dtype=np.float32)  # / SAMPLE_RATE
-    ax[p].plot(x_axis, predict_wav, color='black', linestyle='dashed', label='Speech Estimate')
-    ax[p].set_ylabel('Amplitude', color='black')
+    ax[p].plot(x_axis, predict_wav, color="black", linestyle="dashed", label="Speech Estimate")
+    ax[p].set_ylabel("Amplitude", color="black")
     ax[p].set_xlim(x_axis[0], x_axis[-1])
     if truth_wav is not None:
         ntrim = len(truth_wav) - len(predict_wav)
         if ntrim > 0:
             truth_wav = truth_wav[0:-ntrim]
-        ax[p].plot(x_axis, truth_wav, color='green', linestyle='dashed', label='True Target')
+        ax[p].plot(x_axis, truth_wav, color="green", linestyle="dashed", label="True Target")
 
     # Plot the metric lines
     if metric is not None:
@@ -345,22 +364,21 @@ def plot_e_predict_truth(predict: np.ndarray,
         else:
             metric1 = metric  # if single dim, plot it as 1st
         x_axis = np.arange(len(metric1), dtype=np.float32)  # / SAMPLE_RATE
-        ax[p].plot(x_axis, metric1, color='red', label='Target LogErr')
-        ax[p].set_ylabel('log error db', color='red')
+        ax[p].plot(x_axis, metric1, color="red", label="Target LogErr")
+        ax[p].set_ylabel("log error db", color="red")
         ax[p].set_xlim(x_axis[0], x_axis[-1])
-        ax[p].set_ylim([-0.01, np.max(metric1) + .01])
-        if metric.ndim > 1:
-            if metric.shape[1] > 1:
-                metr2 = metric[:, 1]
-                ax2 = ax[p].twinx()
-                color2 = 'blue'
-                ax2.plot(x_axis, metr2, color=color2, label='phase dist (deg)')
-                # ax2.set_ylim([-180.0, +180.0])
-                if np.max(metr2) - np.min(metr2) > .1:
-                    ax2.set_ylim([np.min(metr2), np.max(metr2)])
-                ax2.set_ylabel('phase dist (deg)', color=color2)
-                ax2.tick_params(axis='y', labelcolor=color2)
-                # ax[p].set_title('SNR and SNR mse (mean over freq. db)')
+        ax[p].set_ylim([-0.01, np.max(metric1) + 0.01])
+        if metric.ndim > 1 and metric.shape[1] > 1:
+            metr2 = metric[:, 1]
+            ax2 = ax[p].twinx()
+            color2 = "blue"
+            ax2.plot(x_axis, metr2, color=color2, label="phase dist (deg)")
+            # ax2.set_ylim([-180.0, +180.0])
+            if np.max(metr2) - np.min(metr2) > 0.1:
+                ax2.set_ylim([np.min(metr2), np.max(metr2)])
+            ax2.set_ylabel("phase dist (deg)", color=color2)
+            ax2.tick_params(axis="y", labelcolor=color2)
+            # ax[p].set_title('SNR and SNR mse (mean over freq. db)')
 
     return fig
 
@@ -376,7 +394,6 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     from matplotlib.backends.backend_pdf import PdfPages
     from pystoi import stoi
 
-    from sonusai import SonusAIError
     from sonusai import logger
     from sonusai.metrics import calc_pcm
     from sonusai.metrics import calc_phase_distance
@@ -388,11 +405,15 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     from sonusai.mixture import read_audio
     from sonusai.utils import calc_asr
     from sonusai.utils import float_to_int16
+    from sonusai.utils import power_compress
+    from sonusai.utils import power_uncompress
     from sonusai.utils import reshape_outputs
     from sonusai.utils import stack_complex
     from sonusai.utils import unstack_complex
     from sonusai.utils import write_audio
 
+    global MP_GLOBAL
+
     mixdb = MP_GLOBAL.mixdb
     predict_location = MP_GLOBAL.predict_location
     predict_wav_mode = MP_GLOBAL.predict_wav_mode
@@ -409,25 +430,25 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
         # in truth estimation mode we use the truth in place of prediction to see metrics with perfect input
         # don't bother to read prediction, and predict var will get assigned to truth later
         # mark outputs with tru suffix, i.e. 0000_truest_*
-        base_name = splitext(output_name)[0] + '_truest'
+        base_name = splitext(output_name)[0] + "_truest"
     else:
         base_name, ext = splitext(output_name)  # base_name used later
         if not predict_wav_mode:
             try:
-                with h5py.File(output_name, 'r') as f:
-                    predict = np.array(f['predict'])
+                with h5py.File(output_name, "r") as f:
+                    predict = np.array(f["predict"])
             except Exception as e:
-                raise SonusAIError(f'Error reading {output_name}: {e}')
+                raise OSError(f"Error reading {output_name}: {e}") from e
             # reshape to always be [frames,classes] where ndim==3 case frames = batch * tsteps
             if predict.ndim > 2:  # TBD generalize to somehow detect if timestep dim exists, some cases > 2 don't have
                 # logger.debug(f'Prediction reshape from {predict.shape} to remove timestep dimension.')
                 predict, _ = reshape_outputs(predict=predict, truth=None, timesteps=predict.shape[1])
         else:
             base_name, ext = splitext(output_name)
-            predict_name = join(base_name + '.wav')
+            predict_name = join(base_name + ".wav")
             audio = read_audio(predict_name)
             predict = forward_transform(audio, mixdb.ft_config)
-            if mixdb.feature[0:1] == 'h':
+            if mixdb.feature[0:1] == "h":
                 predict = power_compress(predict)
             predict = stack_complex(predict)
 
@@ -441,7 +462,7 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     noise = mixture - target  # has time-domain distortion (ir,etc.) but does not have specaugment
     # noise_f = mixdb.mixture_noise_f(mixid, noise=noise)
     # note: uses pre-IR, pre-specaug audio
-    segsnr_f: np.ndarray = mixdb.mixture_metrics(mixid, ['ssnr'])[0]  # type: ignore
+    segsnr_f: np.ndarray = mixdb.mixture_metrics(mixid, ["ssnr"])[0]  # type: ignore[assignment]
     mixture_f = mixdb.mixture_mixture_f(mixid, mixture=mixture)
     noise_f = mixture_f - target_f  # true noise in freq domain includes specaugment and time-domain ir,distortions
     # segsnr_f = mixdb.mixture_segsnr(mixid, target=target, noise=noise)
@@ -457,8 +478,8 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     # TODO: parse truth_f for different formats
     feature, truth_f = mixdb.mixture_ft(mixid, mixture_f=mixture_f)
     # ignore mixup
-    for truth_setting in mixdb.target_file(mixdb.mixture(mixid).targets[0].file_id).truth_settings:
-        if truth_setting.function == 'target_mixture_f':
+    for truth_setting in mixdb.target_file(mixdb.mixture(mixid).targets[0].file_id).truth_configs:
+        if truth_setting.function == "target_mixture_f":
             half = truth_f.shape[-1] // 2
             # extract target_f only
             truth_f = truth_f[..., :half]
@@ -466,7 +487,7 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     if not truth_est_mode:
         if predict.shape[0] < target_f.shape[0]:  # target_f, truth_f, mixture_f, etc. same size
             trim_f = target_f.shape[0] - predict.shape[0]
-            logger.debug(f'Warning: prediction frames less than mixture, trimming {trim_f} frames from all truth.')
+            logger.debug(f"Warning: prediction frames less than mixture, trimming {trim_f} frames from all truth.")
             target_f = target_f[0:-trim_f, :]
             target_fi, _ = inverse_transform(target_f, mixdb.it_config)
             trim_t = target.shape[0] - target_fi.shape[0]
@@ -478,10 +499,11 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
             truth_f = truth_f[0:-trim_f, :]
         elif predict.shape[0] > target_f.shape[0]:
             logger.debug(
-                f'Warning: prediction has more frames than true mixture {predict.shape[0]} vs {truth_f.shape[0]}')
+                f"Warning: prediction has more frames than true mixture {predict.shape[0]} vs {truth_f.shape[0]}"
+            )
             trim_f = predict.shape[0] - target_f.shape[0]
             predict = predict[0:-trim_f, :]
-            # raise SonusAIError(
+            # raise ValueError(
             #     f'Error: prediction has more frames than true mixture {predict.shape[0]} vs {truth_f.shape[0]}')
 
     # 3) Extraction - format proper complex and wav estimates and truth (unstack, uncompress, inv tf, etc.)
@@ -489,13 +511,13 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
         predict = truth_f  # substitute truth for the prediction (for test/debug)
         predict_complex = unstack_complex(predict)  # unstack
         # if feat has compressed mag and truth does not, compress it
-        if mixdb.feature[0:1] == 'h' and mixdb.target_file(1).truth_settings[0].function[0:10] != 'targetcmpr':
+        if mixdb.feature[0:1] == "h" and mixdb.target_file(1).truth_configs[0].function[0:10] != "targetcmpr":
             predict_complex = power_compress(predict_complex)  # from uncompressed truth
     else:
         predict_complex = unstack_complex(predict)
 
     truth_f_complex = unstack_complex(truth_f)
-    if mixdb.feature[0:1] == 'h':  # 'hn' or 'ha' or 'hd', etc.:  # if feat has compressed mag
+    if mixdb.feature[0:1] == "h":  # 'hn' or 'ha' or 'hd', etc.:  # if feat has compressed mag
         # estimate noise in uncompressed-mag domain
         noise_est_complex = mixture_f - power_uncompress(predict_complex)
         predict_complex = power_uncompress(predict_complex)  # uncompress if truth is compressed
@@ -537,7 +559,7 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     if int(mixdb.mixture(mixid).snr) > -99:
         # len = target_est_wav.shape[0]
         pesq_speech, csig_tg, cbak_tg, covl_tg = calc_speech(target_est_wav, target_fi)
-        pesq_mixture, csig_mx, cbak_mx, covl_mx = mixdb.mixture_metrics(mixid, ['mxpesq', 'mxcsig', 'mxcbak', 'mxcovl'])
+        pesq_mixture, csig_mx, cbak_mx, covl_mx = mixdb.mixture_metrics(mixid, ["mxpesq", "mxcsig", "mxcbak", "mxcovl"])
         # pesq_speech_tst = calc_pesq(hypothesis=target_est_wav, reference=target)
         # pesq_mixture_tst = calc_pesq(hypothesis=mixture, reference=target)
         # pesq improvement
@@ -561,8 +583,8 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
     asr_tge = None
     asr_engines = list(mixdb.asr_configs.keys())
     if len(asr_engines) > 0 and mixdb.mixture(mixid).snr >= -96:  # noise only, ignore/reset target asr
-        wer_mx = float(mixdb.mixture_metrics(mixid, [f'mxwer.{asr_engines[0]}'])[0]) * 100
-        asr_tt = MP_GLOBAL.mixdb.mixture_speech_metadata(mixid, 'text')[0]  # ignore mixup
+        wer_mx = float(mixdb.mixture_metrics(mixid, [f"mxwer.{asr_engines[0]}"])[0]) * 100
+        asr_tt = MP_GLOBAL.mixdb.mixture_speech_metadata(mixid, "text")[0]  # ignore mixup
         if asr_tt is None:
             asr_tt = calc_asr(target, engine=asr_method, whisper_model_name=asr_model_name).text  # target truth
 
@@ -577,76 +599,118 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
             else:
                 wer_pi = 100 * (wer_mx - wer_tge) / wer_mx
         else:
-            print(f'Warning: mixid {mixid} asr truth is empty, setting to 0% wer')
+            print(f"Warning: mixid {mixid} asr truth is empty, setting to 0% wer")
             wer_mx = float(0)
             wer_tge = float(0)
             wer_pi = float(0)
     else:
-        wer_mx = float('nan')
-        wer_tge = float('nan')
-        wer_pi = float('nan')
+        wer_mx = float("nan")
+        wer_tge = float("nan")
+        wer_pi = float("nan")
 
     # 5) Save per mixture metric results
     # Single row in table of scalar metrics per mixture
-    mtable1_col = ['MXSNR', 'MXPESQ', 'PESQ', 'PESQi%', 'MXWER', 'WER', 'WERi%', 'WSDR', 'STOI',
-                   'PCM', 'SPLERR', 'NLERR', 'PD', 'MXCSIG', 'CSIG', 'MXCBAK', 'CBAK', 'MXCOVL', 'COVL',
-                   'SPFILE', 'NFILE']
+    mtable1_col = [
+        "MXSNR",
+        "MXPESQ",
+        "PESQ",
+        "PESQi%",
+        "MXWER",
+        "WER",
+        "WERi%",
+        "WSDR",
+        "STOI",
+        "PCM",
+        "SPLERR",
+        "NLERR",
+        "PD",
+        "MXCSIG",
+        "CSIG",
+        "MXCBAK",
+        "CBAK",
+        "MXCOVL",
+        "COVL",
+        "SPFILE",
+        "NFILE",
+    ]
     ti = mixdb.mixture(mixid).targets[0].file_id
     ni = mixdb.mixture(mixid).noise.file_id
-    metr1 = [mixdb.mixture(mixid).snr, pesq_mixture, pesq_speech, pesq_impr_pc, wer_mx, wer_tge, wer_pi, wsdr,
-             target_stoi, pcm, lerr_tg, lerr_n, phd, csig_mx, csig_tg, cbak_mx, cbak_tg, covl_mx, covl_tg,
-             basename(mixdb.target_file(ti).name), basename(mixdb.noise_file(ni).name)]
+    metr1 = [
+        mixdb.mixture(mixid).snr,
+        pesq_mixture,
+        pesq_speech,
+        pesq_impr_pc,
+        wer_mx,
+        wer_tge,
+        wer_pi,
+        wsdr,
+        target_stoi,
+        pcm,
+        lerr_tg,
+        lerr_n,
+        phd,
+        csig_mx,
+        csig_tg,
+        cbak_mx,
+        cbak_tg,
+        covl_mx,
+        covl_tg,
+        basename(mixdb.target_file(ti).name),
+        basename(mixdb.noise_file(ni).name),
+    ]
     mtab1 = pd.DataFrame([metr1], columns=mtable1_col, index=[mixid])
 
     # Stats of per frame estimation metrics
-    metr2 = pd.DataFrame({'SSNR':  segsnr_f,
-                          'PCM':   pcm_frame,
-                          'SLERR': lerr_tg_frame,
-                          'NLERR': lerr_n_frame,
-                          'SPD':   phd_frame})
+    metr2 = pd.DataFrame(
+        {
+            "SSNR": segsnr_f,
+            "PCM": pcm_frame,
+            "SLERR": lerr_tg_frame,
+            "NLERR": lerr_n_frame,
+            "SPD": phd_frame,
+        }
+    )
     metr2 = metr2.describe()  # Use pandas stat function
     # Change SSNR stats to dB, except count.  SSNR is index 0, pandas requires using iloc
     # metr2['SSNR'][1:] = metr2['SSNR'][1:].apply(lambda x: 10 * np.log10(x + 1.01e-10))
-    metr2.iloc[1:, 0] = metr2['SSNR'][1:].apply(lambda x: 10 * np.log10(x + 1.01e-10))
+    metr2.iloc[1:, 0] = metr2["SSNR"][1:].apply(lambda x: 10 * np.log10(x + 1.01e-10))
     # create a single row in multi-column header
-    new_labels = pd.MultiIndex.from_product([metr2.columns,
-                                             ['Avg', 'Min', 'Med', 'Max', 'Std']],
-                                            names=['Metric', 'Stat'])
-    dat1row = metr2.loc[['mean', 'min', '50%', 'max', 'std'], :].T.stack().to_numpy().reshape((1, -1))
-    mtab2 = pd.DataFrame(dat1row,
-                         index=[mixid],
-                         columns=new_labels)
-    mtab2.insert(0, 'MXSNR', mixdb.mixture(mixid).snr, False)  # add MXSNR as the first metric column
+    new_labels = pd.MultiIndex.from_product(
+        [metr2.columns, ["Avg", "Min", "Med", "Max", "Std"]], names=["Metric", "Stat"]
+    )
+    dat1row = metr2.loc[["mean", "min", "50%", "max", "std"], :].T.stack().to_numpy().reshape((1, -1))
+    mtab2 = pd.DataFrame(dat1row, index=[mixid], columns=new_labels)
+    mtab2.insert(0, "MXSNR", mixdb.mixture(mixid).snr, False)  # add MXSNR as the first metric column
 
     all_metrics_table_1 = mtab1  # return to be collected by process
     all_metrics_table_2 = mtab2  # return to be collected by process
 
-    metric_name = base_name + '_metric_spenh.txt'
-    with open(metric_name, 'w') as f:
-        print('Speech enhancement metrics:', file=f)
-        print(mtab1.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-        print('', file=f)
-        print(f'Extraction statistics over {mixture_f.shape[0]} frames:', file=f)
-        print(metr2.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-        print('', file=f)
-        print(f'Target path: {mixdb.target_file(ti).name}', file=f)
-        print(f'Noise path: {mixdb.noise_file(ni).name}', file=f)
-        if asr_method != 'none':
-            print(f'ASR method: {asr_method} and whisper model (if used):  {asr_model_name}', file=f)
-            print(f'ASR truth:  {asr_tt}', file=f)
-            print(f'ASR result for mixture:  {asr_mx}', file=f)
-            print(f'ASR result for prediction:  {asr_tge}', file=f)
-
-        print(f'Augmentations: {mixdb.mixture(mixid)}', file=f)
+    metric_name = base_name + "_metric_spenh.txt"
+    with open(metric_name, "w") as f, redirect_stdout(f):
+        print("Speech enhancement metrics:")
+        print(mtab1.round(2).to_string(float_format=lambda x: f"{x:.2f}"))
+        print("")
+        print(f"Extraction statistics over {mixture_f.shape[0]} frames:")
+        print(metr2.round(2).to_string(float_format=lambda x: f"{x:.2f}"))
+        print("")
+        print(f"Target path: {mixdb.target_file(ti).name}")
+        print(f"Noise path: {mixdb.noise_file(ni).name}")
+        if asr_method != "none":
+            print(f"ASR method: {asr_method} and whisper model (if used):  {asr_model_name}")
+            print(f"ASR truth:  {asr_tt}")
+            print(f"ASR result for mixture:  {asr_mx}")
+            print(f"ASR result for prediction:  {asr_tge}")
+
+        print(f"Augmentations: {mixdb.mixture(mixid)}")
 
     # 7) write wav files
     if enable_wav:
-        write_audio(name=base_name + '_mixture.wav', audio=float_to_int16(mixture))
-        write_audio(name=base_name + '_target.wav', audio=float_to_int16(target))
+        write_audio(name=base_name + "_mixture.wav", audio=float_to_int16(mixture))
+        write_audio(name=base_name + "_target.wav", audio=float_to_int16(target))
         # write_audio(name=base_name + '_target_fi.wav', audio=float_to_int16(target_fi))
-        write_audio(name=base_name + '_noise.wav', audio=float_to_int16(noise))
-        write_audio(name=base_name + '_target_est.wav', audio=float_to_int16(target_est_wav))
-        write_audio(name=base_name + '_noise_est.wav', audio=float_to_int16(noise_est_wav))
+        write_audio(name=base_name + "_noise.wav", audio=float_to_int16(noise))
+        write_audio(name=base_name + "_target_est.wav", audio=float_to_int16(target_est_wav))
+        write_audio(name=base_name + "_noise_est.wav", audio=float_to_int16(noise_est_wav))
 
         # debug code to test for perfect reconstruction of the extraction method
         # note both 75% olsa-hanns and 50% olsa-hann modes checked to have perfect reconstruction
@@ -657,14 +721,14 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
 
     # 8) Write out plot file
     if enable_plot:
-        plot_name = base_name + '_metric_spenh.pdf'
+        plot_name = base_name + "_metric_spenh.pdf"
 
         # Reshape feature to eliminate overlap redundancy for easier to understand spectrogram view
         # Original size (frames, stride, num_bands), decimates in stride dimension only if step is > 1
         # Reshape to get frames*decimated_stride, num_bands
         step = int(mixdb.feature_samples / mixdb.feature_step_samples)
         if feature.ndim != 3:
-            raise SonusAIError(f'feature does not have 3 dimensions: frames, stride, num_bands')
+            raise ValueError("feature does not have 3 dimensions: frames, stride, num_bands")
 
         # for feature cn*00n**
         feat_sgram = unstack_complex(feature)
@@ -674,27 +738,29 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
 
         with PdfPages(plot_name) as pdf:
             # page1 we always have a mixture and prediction, target optional if truth provided
-            tfunc_name = mixdb.target_file(1).truth_settings[0].function  # first target, assumes all have same
-            if tfunc_name == 'mapped_snr_f':
+            tfunc_name = mixdb.target_file(1).truth_configs[0].function  # first target, assumes all have same
+            if tfunc_name == "mapped_snr_f":
                 # leave as unmapped snr
                 predplot = predict
-                tfunc_name = mixdb.target_file(1).truth_settings[0].function
-            elif tfunc_name == 'target_f' or 'target_mixture_f':
+                tfunc_name = mixdb.target_file(1).truth_configs[0].function
+            elif tfunc_name in ("target_f", "target_mixture_f"):
                 predplot = 20 * np.log10(abs(predict_complex) + np.finfo(np.float32).eps)
             else:
                 # use dB scale
                 predplot = 10 * np.log10(predict + np.finfo(np.float32).eps)
-                tfunc_name = tfunc_name + ' (db)'
+                tfunc_name = tfunc_name + " (db)"
 
             mixspec = 20 * np.log10(abs(mixture_f) + np.finfo(np.float32).eps)
-            fig_obj = plot_mixpred(mixture=mixture,
-                                   mixture_f=mixspec,
-                                   target=target,
-                                   feature=feat_sgram,
-                                   predict=predplot,
-                                   tp_title=tfunc_name)
+            fig_obj = plot_mixpred(
+                mixture=mixture,
+                mixture_f=mixspec,
+                target=target,
+                feature=feat_sgram,
+                predict=predplot,
+                tp_title=tfunc_name,
+            )
             pdf.savefig(fig_obj)
-            with mgzip.open(base_name + '_metric_spenh_fig1.mfigz', 'wb') as f:
+            with mgzip.open(base_name + "_metric_spenh_fig1.mfigz", "wb") as f:
                 pickle.dump(fig_obj, f)
 
             # ----- page 2, plot unmapped predict, opt truth reconstructed and line plots of mean-over-f
@@ -704,34 +770,38 @@ def _process_mixture(mixid: int) -> tuple[pd.DataFrame, pd.DataFrame]:
             tg_spec = 20 * np.log10(abs(target_f) + np.finfo(np.float32).eps)
             tg_est_spec = 20 * np.log10(abs(predict_complex) + np.finfo(np.float32).eps)
             # n_spec = np.reshape(n_spec,(n_spec.shape[0] * n_spec.shape[1], n_spec.shape[2]))
-            fig_obj = plot_e_predict_truth(predict=tg_est_spec,
-                                           predict_wav=target_est_wav,
-                                           truth_f=tg_spec,
-                                           truth_wav=target_fi,
-                                           metric=np.vstack((lerr_tg_frame, phd_frame)).T,
-                                           tp_title='speech estimate')
+            fig_obj = plot_e_predict_truth(
+                predict=tg_est_spec,
+                predict_wav=target_est_wav,
+                truth_f=tg_spec,
+                truth_wav=target_fi,
+                metric=np.vstack((lerr_tg_frame, phd_frame)).T,
+                tp_title="speech estimate",
+            )
             pdf.savefig(fig_obj)
-            with mgzip.open(base_name + '_metric_spenh_fig2.mfigz', 'wb') as f:
+            with mgzip.open(base_name + "_metric_spenh_fig2.mfigz", "wb") as f:
                 pickle.dump(fig_obj, f)
 
             # page 4 noise extraction
             n_spec = 20 * np.log10(abs(noise_f) + np.finfo(np.float32).eps)
             n_est_spec = 20 * np.log10(abs(noise_est_complex) + np.finfo(np.float32).eps)
-            fig_obj = plot_e_predict_truth(predict=n_est_spec,
-                                           predict_wav=noise_est_wav,
-                                           truth_f=n_spec,
-                                           truth_wav=noise_fi,
-                                           metric=lerr_n_frame,
-                                           tp_title='noise estimate')
+            fig_obj = plot_e_predict_truth(
+                predict=n_est_spec,
+                predict_wav=noise_est_wav,
+                truth_f=n_spec,
+                truth_wav=noise_fi,
+                metric=lerr_n_frame,
+                tp_title="noise estimate",
+            )
             pdf.savefig(fig_obj)
-            with mgzip.open(base_name + '_metric_spenh_fig4.mfigz', 'wb') as f:
+            with mgzip.open(base_name + "_metric_spenh_fig4.mfigz", "wb") as f:
                 pickle.dump(fig_obj, f)
 
             # Plot error waveforms
             # tg_err_wav = target_fi - target_est_wav
             # tg_err_spec = 20*np.log10(np.abs(target_f - predict_complex))
 
-        plt.close('all')
+        plt.close("all")
 
     return all_metrics_table_1, all_metrics_table_2
 
@@ -744,17 +814,17 @@ def main():
 
     args = docopt(trim_docstring(__doc__), version=sonusai.__version__, options_first=True)
 
-    verbose = args['--verbose']
-    mixids = args['--mixid']
-    asr_method = args['--asr-method'].lower()
-    asr_model_name = args['--model'].lower()
-    truth_est_mode = args['--truth-est-mode']
-    enable_plot = args['--plot']
-    enable_wav = args['--wav']
-    enable_summary = args['--summary']
-    predict_location = args['PLOC']
-    num_proc = args['--num_process']
-    truth_location = args['TLOC']
+    verbose = args["--verbose"]
+    mixids = args["--mixid"]
+    asr_method = args["--asr-method"].lower()
+    asr_model_name = args["--model"].lower()
+    truth_est_mode = args["--truth-est-mode"]
+    enable_plot = args["--plot"]
+    enable_wav = args["--wav"]
+    enable_summary = args["--summary"]
+    predict_location = args["PLOC"]
+    num_proc = args["--num_process"]
+    truth_location = args["TLOC"]
 
     import glob
     from os.path import basename
@@ -762,7 +832,6 @@ def main():
     from os.path import join
 
     import psutil
-    from tqdm import tqdm
 
     from sonusai import create_file_handler
     from sonusai import initial_log_messages
@@ -772,11 +841,12 @@ def main():
     from sonusai.mixture import MixtureDatabase
     from sonusai.mixture import read_audio
     from sonusai.utils import calc_asr
-    from sonusai.utils import pp_tqdm_imap
+    from sonusai.utils import par_track
+    from sonusai.utils import track
 
     # Check prediction subdirectory
     if not isdir(predict_location):
-        print(f'The specified predict location {predict_location} is not a valid subdirectory path, exiting ...')
+        print(f"The specified predict location {predict_location} is not a valid subdirectory path, exiting ...")
 
     # all_predict_files = listdir(predict_location)
     all_predict_files = glob.glob(predict_location + "/*.h5")
@@ -785,69 +855,72 @@ def main():
     if len(all_predict_files) <= 0 and not truth_est_mode:
         all_predict_files = glob.glob(predict_location + "/*.wav")  # check for wav files
         if len(all_predict_files) <= 0:
-            print(f'Subdirectory {predict_location} has no .h5 or .wav files, exiting ...')
+            print(f"Subdirectory {predict_location} has no .h5 or .wav files, exiting ...")
         else:
-            logger.info(f'Found {len(all_predict_files)} prediction .wav files.')
+            logger.info(f"Found {len(all_predict_files)} prediction .wav files.")
             predict_wav_mode = True
     else:
-        logger.info(f'Found {len(all_predict_files)} prediction .h5 files.')
+        logger.info(f"Found {len(all_predict_files)} prediction .h5 files.")
 
     if len(predict_logfile) == 0:
-        logger.info(f'Warning, predict location {predict_location} has no prediction log files.')
+        logger.info(f"Warning, predict location {predict_location} has no prediction log files.")
     else:
-        logger.info(f'Found predict log {basename(predict_logfile[0])} in predict location.')
+        logger.info(f"Found predict log {basename(predict_logfile[0])} in predict location.")
 
     # Setup logging file
-    create_file_handler(join(predict_location, 'calc_metric_spenh.log'))
+    create_file_handler(join(predict_location, "calc_metric_spenh.log"))
     update_console_handler(verbose)
-    initial_log_messages('calc_metric_spenh')
+    initial_log_messages("calc_metric_spenh")
 
     mixdb = MixtureDatabase(truth_location)
     mixids = mixdb.mixids_to_list(mixids)
     logger.info(
-        f'Found mixdb of {mixdb.num_mixtures} total mixtures, with {mixdb.num_classes} classes in {truth_location}')
-    logger.info(f'Only running specified subset of {len(mixids)} mixtures')
+        f"Found mixdb of {mixdb.num_mixtures} total mixtures, with {mixdb.num_classes} classes in {truth_location}"
+    )
+    logger.info(f"Only running specified subset of {len(mixids)} mixtures")
 
     enable_asr_warmup = False
-    if asr_method == 'none':
-        fnb = 'metric_spenh_'
-    elif asr_method == 'google':
-        fnb = 'metric_spenh_ggl_'
-        logger.info(f'ASR enabled with method {asr_method}')
+    if asr_method == "none":
+        fnb = "metric_spenh_"
+    elif asr_method == "google":
+        fnb = "metric_spenh_ggl_"
+        logger.info(f"ASR enabled with method {asr_method}")
         enable_asr_warmup = True
-    elif asr_method == 'deepgram':
-        fnb = 'metric_spenh_dgram_'
-        logger.info(f'ASR enabled with method {asr_method}')
+    elif asr_method == "deepgram":
+        fnb = "metric_spenh_dgram_"
+        logger.info(f"ASR enabled with method {asr_method}")
         enable_asr_warmup = True
-    elif asr_method == 'aixplain_whisper':
-        fnb = 'metric_spenh_whspx_' + asr_model_name + '_'
-        logger.info(f'ASR enabled with method {asr_method} and whisper model {asr_model_name}')
+    elif asr_method == "aixplain_whisper":
+        fnb = "metric_spenh_whspx_" + asr_model_name + "_"
+        logger.info(f"ASR enabled with method {asr_method} and whisper model {asr_model_name}")
         enable_asr_warmup = True
-    elif asr_method == 'whisper':
-        fnb = 'metric_spenh_whspl_' + asr_model_name + '_'
-        logger.info(f'ASR enabled with method {asr_method} and whisper model {asr_model_name}')
+    elif asr_method == "whisper":
+        fnb = "metric_spenh_whspl_" + asr_model_name + "_"
+        logger.info(f"ASR enabled with method {asr_method} and whisper model {asr_model_name}")
         enable_asr_warmup = True
-    elif asr_method == 'aaware_whisper':
-        fnb = 'metric_spenh_whspaaw_' + asr_model_name + '_'
-        logger.info(f'ASR enabled with method {asr_method} and whisper model {asr_model_name}')
+    elif asr_method == "aaware_whisper":
+        fnb = "metric_spenh_whspaaw_" + asr_model_name + "_"
+        logger.info(f"ASR enabled with method {asr_method} and whisper model {asr_model_name}")
         enable_asr_warmup = True
-    elif asr_method == 'faster_whisper':
-        fnb = 'metric_spenh_fwhsp_' + asr_model_name + '_'
-        logger.info(f'ASR enabled with method {asr_method} and whisper model {asr_model_name}')
+    elif asr_method == "faster_whisper":
+        fnb = "metric_spenh_fwhsp_" + asr_model_name + "_"
+        logger.info(f"ASR enabled with method {asr_method} and whisper model {asr_model_name}")
         enable_asr_warmup = True
-    elif asr_method == 'sensory':
-        fnb = 'metric_spenh_snsr_' + asr_model_name + '_'
-        logger.info(f'ASR enabled with method {asr_method} and model {asr_model_name}')
+    elif asr_method == "sensory":
+        fnb = "metric_spenh_snsr_" + asr_model_name + "_"
+        logger.info(f"ASR enabled with method {asr_method} and model {asr_model_name}")
         enable_asr_warmup = True
     else:
-        logger.error(f'Unrecognized ASR method: {asr_method}')
+        logger.error(f"Unrecognized ASR method: {asr_method}")
         return
 
     if enable_asr_warmup:
         audio = read_audio(DEFAULT_SPEECH)
-        logger.info(f'Warming up asr method, note for cloud service this could take up to a few min ...')
+        logger.info("Warming up asr method, note for cloud service this could take up to a few min ...")
         asr_chk = calc_asr(audio, engine=asr_method, whisper_model_name=asr_model_name)
-        logger.info(f'Warmup completed, results {asr_chk}')
+        logger.info(f"Warmup completed, results {asr_chk}")
+
+    global MP_GLOBAL
 
     MP_GLOBAL.mixdb = mixdb
     MP_GLOBAL.predict_location = predict_location
@@ -862,9 +935,9 @@ def main():
     cpu_percent = psutil.cpu_percent(interval=1)
     logger.info(f"#CPUs: {num_cpu}, current CPU utilization: {cpu_percent}%")
     logger.info(f"Memory utilization: {psutil.virtual_memory().percent}%")
-    if num_proc == 'auto':
+    if num_proc == "auto":
         use_cpu = int(num_cpu * (0.9 - cpu_percent / 100))  # default use 80% of available cpus
-    elif num_proc == 'None':
+    elif num_proc == "None":
         use_cpu = None
     else:
         use_cpu = min(max(int(num_proc), 1), num_cpu)
@@ -872,11 +945,11 @@ def main():
     # Individual mixtures use pandas print, set precision to 2 decimal places
     # pd.set_option('float_format', '{:.2f}'.format)
     logger.info(f"Calculating metrics for {len(mixids)} mixtures using {use_cpu} parallel processes ...")
-    progress = tqdm(total=len(mixids), desc='calc_metric_spenh')
+    progress = track(total=len(mixids), desc="calc_metric_spenh")
     if use_cpu is None:
-        all_metrics_tables = pp_tqdm_imap(_process_mixture, mixids, progress=progress, no_par=True)
+        all_metrics_tables = par_track(_process_mixture, mixids, progress=progress, no_par=True)
     else:
-        all_metrics_tables = pp_tqdm_imap(_process_mixture, mixids, progress=progress, num_cpus=use_cpu)
+        all_metrics_tables = par_track(_process_mixture, mixids, progress=progress, num_cpus=use_cpu)
     progress.close()
 
     all_metrics_table_1 = pd.concat([item[0] for item in all_metrics_tables])
@@ -887,37 +960,40 @@ def main():
 
     # 9) Done with mixtures, write out summary metrics
     # Calculate SNR summary avg of each non-random snr
-    all_mtab1_sorted = all_metrics_table_1.sort_values(by=['MXSNR', 'SPFILE'])
-    all_mtab2_sorted = all_metrics_table_2.sort_values(by=['MXSNR'])
+    all_mtab1_sorted = all_metrics_table_1.sort_values(by=["MXSNR", "SPFILE"])
+    all_mtab2_sorted = all_metrics_table_2.sort_values(by=["MXSNR"])
     mtab_snr_summary = None
     mtab_snr_summary_em = None
     for snri in range(0, len(mixdb.snrs)):
-        tmp = all_mtab1_sorted.query('MXSNR==' + str(mixdb.snrs[snri])).mean(numeric_only=True).to_frame().T
+        tmp = all_mtab1_sorted.query("MXSNR==" + str(mixdb.snrs[snri])).mean(numeric_only=True).to_frame().T
         # avoid nan when subset of mixids specified
         if ~np.isnan(tmp.iloc[0].to_numpy()[0]).any():
             mtab_snr_summary = pd.concat([mtab_snr_summary, tmp])
 
-        tmp = all_mtab2_sorted[all_mtab2_sorted['MXSNR'] == mixdb.snrs[snri]].mean(numeric_only=True).to_frame().T
+        tmp = all_mtab2_sorted[all_mtab2_sorted["MXSNR"] == mixdb.snrs[snri]].mean(numeric_only=True).to_frame().T
         # avoid nan when subset of mixids specified (mxsnr will be nan if no data):
         if ~np.isnan(tmp.iloc[0].to_numpy()[0]).any():
             mtab_snr_summary_em = pd.concat([mtab_snr_summary_em, tmp])
 
-    mtab_snr_summary = mtab_snr_summary.sort_values(by=['MXSNR'], ascending=False)
+    mtab_snr_summary = mtab_snr_summary.sort_values(by=["MXSNR"], ascending=False)
     # Correct percentages in snr summary table
-    mtab_snr_summary['PESQi%'] = 100 * (mtab_snr_summary['PESQ'] - mtab_snr_summary['MXPESQ']) / np.maximum(
-        mtab_snr_summary['MXPESQ'], 0.01)
+    mtab_snr_summary["PESQi%"] = (
+        100 * (mtab_snr_summary["PESQ"] - mtab_snr_summary["MXPESQ"]) / np.maximum(mtab_snr_summary["MXPESQ"], 0.01)
+    )
     for i in range(len(mtab_snr_summary)):
-        if mtab_snr_summary['MXWER'].iloc[i] == 0.0:
-            if mtab_snr_summary['WER'].iloc[i] == 0.0:
+        if mtab_snr_summary["MXWER"].iloc[i] == 0.0:
+            if mtab_snr_summary["WER"].iloc[i] == 0.0:
                 mtab_snr_summary.iloc[i, 6] = 0.0  # mtab_snr_summary['WERi%'].iloc[i] = 0.0
             else:
                 mtab_snr_summary.iloc[i, 6] = -999.0  # mtab_snr_summary['WERi%'].iloc[i] = -999.0
         else:
-            if ~np.isnan(mtab_snr_summary['WER'].iloc[i]) and ~np.isnan(mtab_snr_summary['MXWER'].iloc[i]):
+            if ~np.isnan(mtab_snr_summary["WER"].iloc[i]) and ~np.isnan(mtab_snr_summary["MXWER"].iloc[i]):
                 # update WERi% in 6th col
-                mtab_snr_summary.iloc[i, 6] = 100 * (mtab_snr_summary['MXWER'].iloc[i] -
-                                                     mtab_snr_summary['WER'].iloc[i]) / \
-                                              mtab_snr_summary['MXWER'].iloc[i]
+                mtab_snr_summary.iloc[i, 6] = (
+                    100
+                    * (mtab_snr_summary["MXWER"].iloc[i] - mtab_snr_summary["WER"].iloc[i])
+                    / mtab_snr_summary["MXWER"].iloc[i]
+                )
 
     # Calculate avg metrics over all mixtures except -99
     all_mtab1_sorted_nom99 = all_mtab1_sorted[all_mtab1_sorted.MXSNR != -99]
@@ -925,16 +1001,17 @@ def main():
 
     # correct the percentage averages with a direct calculation (PESQ% and WER%):
     # ser.iloc[pos]
-    all_nom99_mean['PESQi%'] = (100 * (all_nom99_mean['PESQ'] - all_nom99_mean['MXPESQ'])
-                                / np.maximum(all_nom99_mean['MXPESQ'], 0.01))  # pesq%
+    all_nom99_mean["PESQi%"] = (
+        100 * (all_nom99_mean["PESQ"] - all_nom99_mean["MXPESQ"]) / np.maximum(all_nom99_mean["MXPESQ"], 0.01)
+    )  # pesq%
     # all_nom99_mean[3] = 100 * (all_nom99_mean[2] - all_nom99_mean[1]) / np.maximum(all_nom99_mean[1], 0.01)  # pesq%
-    if all_nom99_mean['MXWER'] == 0.0:
-        if all_nom99_mean['WER'] == 0.0:
-            all_nom99_mean['WERi%'] = 0.0
+    if all_nom99_mean["MXWER"] == 0.0:
+        if all_nom99_mean["WER"] == 0.0:
+            all_nom99_mean["WERi%"] = 0.0
         else:
-            all_nom99_mean['WERi%'] = -999.0
+            all_nom99_mean["WERi%"] = -999.0
     else:  # wer%
-        all_nom99_mean['WERi%'] = 100 * (all_nom99_mean['MXWER'] - all_nom99_mean['WER']) / all_nom99_mean['MXWER']
+        all_nom99_mean["WERi%"] = 100 * (all_nom99_mean["MXWER"] - all_nom99_mean["WER"]) / all_nom99_mean["MXWER"]
 
     num_mix = len(mixids)
     if num_mix > 1:
@@ -942,91 +1019,88 @@ def main():
         # pd.set_option('float_format', '{:.2f}'.format)
 
         if not truth_est_mode:
-            ofname = join(predict_location, fnb + 'summary.txt')
+            ofname = join(predict_location, fnb + "summary.txt")
         else:
-            ofname = join(predict_location, fnb + 'summary_truest.txt')
-
-        with open(ofname, 'w') as f:
-            print(f'ASR enabled with method {asr_method}, whisper model, if used: {asr_model_name}', file=f)
-            print(f'Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:',
-                  file=f)
-            print(all_nom99_mean.to_frame().T.round(2).to_string(float_format=lambda x: "{:.2f}".format(x),
-                                                                 index=False), file=f)
-            print(f'\nSpeech enhancement metrics avg over each SNR:', file=f)
-            print(mtab_snr_summary.round(2).to_string(float_format=lambda x: "{:.2f}".format(x), index=False), file=f)
-            print('', file=f)
-            print(f'Extraction statistics stats avg over each SNR:', file=f)
+            ofname = join(predict_location, fnb + "summary_truest.txt")
+
+        with open(ofname, "w") as f, redirect_stdout(f):
+            print(f"ASR enabled with method {asr_method}, whisper model, if used: {asr_model_name}")
+            print(f"Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:")
+            print(all_nom99_mean.to_frame().T.round(2).to_string(float_format=lambda x: f"{x:.2f}", index=False))
+            print("\nSpeech enhancement metrics avg over each SNR:")
+            print(mtab_snr_summary.round(2).to_string(float_format=lambda x: f"{x:.2f}", index=False))
+            print("")
+            print("Extraction statistics stats avg over each SNR:")
             # with pd.option_context('display.max_colwidth', 9):
             # with pd.set_option('float_format', '{:.1f}'.format):
-            print(mtab_snr_summary_em.round(1).to_string(float_format=lambda x: "{:.1f}".format(x), index=False),
-                  file=f)
-            print('', file=f)
+            print(mtab_snr_summary_em.round(1).to_string(float_format=lambda x: f"{x:.1f}", index=False))
+            print("")
             # pd.set_option('float_format', '{:.2f}'.format)
 
-            print(f'Speech enhancement metrics stats over all {num_mix} mixtures:', file=f)
-            print(all_metrics_table_1.describe().round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-            print('', file=f)
-            print(f'Extraction statistics stats over all {num_mix} mixtures:', file=f)
-            print(all_metrics_table_2.describe().round(2).to_string(float_format=lambda x: "{:.1f}".format(x)), file=f)
-            print('', file=f)
+            print(f"Speech enhancement metrics stats over all {num_mix} mixtures:")
+            print(all_metrics_table_1.describe().round(2).to_string(float_format=lambda x: f"{x:.2f}"))
+            print("")
+            print(f"Extraction statistics stats over all {num_mix} mixtures:")
+            print(all_metrics_table_2.describe().round(2).to_string(float_format=lambda x: f"{x:.1f}"))
+            print("")
 
-            print('Speech enhancement metrics all-mixtures list:', file=f)
-            # print(all_metrics_table_1.head().style.format(precision=2), file=f)
-            print(all_metrics_table_1.round(2).to_string(float_format=lambda x: "{:.2f}".format(x)), file=f)
-            print('', file=f)
-            print('Extraction statistics all-mixtures list:', file=f)
-            print(all_metrics_table_2.round(2).to_string(float_format=lambda x: "{:.1f}".format(x)), file=f)
+            print("Speech enhancement metrics all-mixtures list:")
+            # print(all_metrics_table_1.head().style.format(precision=2))
+            print(all_metrics_table_1.round(2).to_string(float_format=lambda x: f"{x:.2f}"))
+            print("")
+            print("Extraction statistics all-mixtures list:")
+            print(all_metrics_table_2.round(2).to_string(float_format=lambda x: f"{x:.1f}"))
 
         # Write summary to .csv file
         if not truth_est_mode:
-            csv_name = str(join(predict_location, fnb + 'summary.csv'))
+            csv_name = str(join(predict_location, fnb + "summary.csv"))
         else:
-            csv_name = str(join(predict_location, fnb + 'truest_summary.csv'))
+            csv_name = str(join(predict_location, fnb + "truest_summary.csv"))
         header_args = {
-            'mode':     'a',
-            'encoding': 'utf-8',
-            'index':    False,
-            'header':   False,
+            "mode": "a",
+            "encoding": "utf-8",
+            "index": False,
+            "header": False,
         }
         table_args = {
-            'mode':     'a',
-            'encoding': 'utf-8',
+            "mode": "a",
+            "encoding": "utf-8",
         }
-        label = f'Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:'
+        label = f"Speech enhancement metrics avg over all {len(all_mtab1_sorted_nom99)} non -99 SNR mixtures:"
         pd.DataFrame([label]).to_csv(csv_name, header=False, index=False)  # open as write
         all_nom99_mean.to_frame().T.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame([f'Speech enhancement metrics avg over each SNR:']).to_csv(csv_name, **header_args)
+        pd.DataFrame([""]).to_csv(csv_name, **header_args)
+        pd.DataFrame(["Speech enhancement metrics avg over each SNR:"]).to_csv(csv_name, **header_args)
         mtab_snr_summary.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame([f'Extraction statistics stats avg over each SNR:']).to_csv(csv_name, **header_args)
+        pd.DataFrame([""]).to_csv(csv_name, **header_args)
+        pd.DataFrame(["Extraction statistics stats avg over each SNR:"]).to_csv(csv_name, **header_args)
         mtab_snr_summary_em.round(2).to_csv(csv_name, index=False, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        label = f'Speech enhancement metrics stats over {num_mix} mixtures:'
+        pd.DataFrame([""]).to_csv(csv_name, **header_args)
+        pd.DataFrame([""]).to_csv(csv_name, **header_args)
+        label = f"Speech enhancement metrics stats over {num_mix} mixtures:"
         pd.DataFrame([label]).to_csv(csv_name, **header_args)
         all_metrics_table_1.describe().round(2).to_csv(csv_name, **table_args)
-        pd.DataFrame(['']).to_csv(csv_name, **header_args)
-        label = f'Extraction statistics stats over {num_mix} mixtures:'
+        pd.DataFrame([""]).to_csv(csv_name, **header_args)
+        label = f"Extraction statistics stats over {num_mix} mixtures:"
         pd.DataFrame([label]).to_csv(csv_name, **header_args)
         all_metrics_table_2.describe().round(2).to_csv(csv_name, **table_args)
-        label = f'ASR enabled with method {asr_method}, whisper model, if used: {asr_model_name}'
+        label = f"ASR enabled with method {asr_method}, whisper model, if used: {asr_model_name}"
         pd.DataFrame([label]).to_csv(csv_name, **header_args)
 
         if not truth_est_mode:
-            csv_name = str(join(predict_location, fnb + 'list.csv'))
+            csv_name = str(join(predict_location, fnb + "list.csv"))
         else:
-            csv_name = str(join(predict_location, fnb + 'truest_list.csv'))
-        pd.DataFrame(['Speech enhancement metrics list:']).to_csv(csv_name, header=False, index=False)  # open as write
+            csv_name = str(join(predict_location, fnb + "truest_list.csv"))
+        pd.DataFrame(["Speech enhancement metrics list:"]).to_csv(csv_name, header=False, index=False)  # open as write
         all_metrics_table_1.round(2).to_csv(csv_name, **table_args)
 
         if not truth_est_mode:
-            csv_name = str(join(predict_location, fnb + 'estats_list.csv'))
+            csv_name = str(join(predict_location, fnb + "estats_list.csv"))
         else:
-            csv_name = str(join(predict_location, fnb + 'truest_estats_list.csv'))
-        pd.DataFrame(['Extraction statistics list:']).to_csv(csv_name, header=False, index=False)  # open as write
+            csv_name = str(join(predict_location, fnb + "truest_estats_list.csv"))
+        pd.DataFrame(["Extraction statistics list:"]).to_csv(csv_name, header=False, index=False)  # open as write
         all_metrics_table_2.round(2).to_csv(csv_name, **table_args)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()