audio-validation 0.3.0__tar.gz → 0.3.2__tar.gz

{audio_validation-0.3.0 → audio_validation-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audio_validation
-Version: 0.3.0
+Version: 0.3.2
 Summary: Tools for validating audio data, including feature extraction and visualization.
 Maintainer-email: Hubert Stepniewski <hubert.stepniewski@int2code.com>, Marcin Tomiczek <marcin.tomiczek@int2code.com>, Piotr Sznapka <piotr.sznapka@int2code.com>
 License: MIT License

audio_validation-0.3.2/RELEASE_NOTES.md

@@ -0,0 +1,19 @@
+### 0.3.2
+
+[PATCH] Add warmup chunks, improve failure reporting.
+
+### 0.3.1
+
+[PATCH] Fix printing Continous Audio Validator Failure Info.
+
+### 0.3.0
+
+[MINOR] Add Continous Audio Validator.
+
+### 0.2.0
+
+[MINOR] Add THD, THD+N calculation.
+
+### 0.1.2
+
+[MINOR] Initial release.

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)
 
-__commit_id__ = commit_id = 'gc754f7812'
+__commit_id__ = commit_id = 'ge32c5a61b'

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation/continous_validation/criteria.py

@@ -6,10 +6,14 @@ swapped atomically by reference while the analysis thread reads it, without
 copying.  :func:`evaluate_chunk` runs every configured check (skipping any left
 at ``None``) and reports *all* failures, each check living in its own function
 that logs a per-channel table.
+
+Each check returns a :class:`CheckResult` that keeps its one-line *summary*
+separate from its per-channel *failures* table, so callers can render a compact
+overview (one row per chunk) without embedding a whole table in a single cell.
 """
 
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Callable, List, Optional, Tuple
 
 import numpy as np
@@ -60,6 +64,74 @@ class AudioCriteria:
     custom_check: Optional[Callable[[AudioFeatures], Tuple[bool, str]]] = None
 
 
+@dataclass(frozen=True)
+class CheckResult:
+    """Outcome of a single check.
+
+    Keeping *summary* (one line) apart from *failures* (a table) lets the caller
+    choose the rendering: a compact column in a metrics table, or a full
+    multiline block in a failure report.
+
+    :ivar name: Short check identifier, e.g. ``"thd_n"``.
+    :ivar ok: Whether the check passed.
+    :ivar summary: Single-line reason; empty when the check passed.
+    :ivar failures: Failing per-channel rows, or ``None`` when not applicable.
+    """
+
+    name: str
+    ok: bool
+    summary: str = ""
+    failures: Optional[pd.DataFrame] = None
+
+    @classmethod
+    def from_tuple(cls, name: str, result: Tuple[bool, str]) -> "CheckResult":
+        """Adapt a legacy ``(ok, reason)`` pair (e.g. from ``custom_check``).
+
+        A multiline *reason* keeps its first line as the summary; the rest is
+        preserved as a single-column details table.
+        """
+        ok, reason = result
+        head, _, rest = reason.partition("\n")
+        failures = pd.DataFrame({"detail": rest.splitlines()}) if rest.strip() else None
+        return cls(name=name, ok=ok, summary=head, failures=failures)
+
+    @property
+    def detail(self) -> str:
+        """Return the multiline ``summary`` + failing-rows table."""
+        if self.ok:
+            return ""
+        if self.failures is None or self.failures.empty:
+            return self.summary
+        return f"{self.summary}\n{self.failures.to_string()}"
+
+
+@dataclass(frozen=True)
+class ChunkVerdict:
+    """Aggregated outcome of every check run against one chunk."""
+
+    results: List[CheckResult] = field(default_factory=list)
+
+    @property
+    def failures(self) -> List[CheckResult]:
+        """Return the failing checks, in evaluation order."""
+        return [result for result in self.results if not result.ok]
+
+    @property
+    def ok(self) -> bool:
+        """Whether every check passed."""
+        return not self.failures
+
+    @property
+    def summary(self) -> str:
+        """Single-line reason joining every failing check's summary."""
+        return "; ".join(result.summary for result in self.failures)
+
+    @property
+    def detail(self) -> str:
+        """Multiline reason with each failing check's per-channel table."""
+        return "\n".join(result.detail for result in self.failures)
+
+
 def _channel_label(ch: int) -> str:
     """Return a stable, human-readable label for channel index *ch*."""
     return f"ch{ch}"
@@ -87,13 +159,13 @@ def _format_list(freqs: Any, max_display: int = 5) -> str:
     )
 
 
-def check_silence(features: AudioFeatures, threshold: float) -> Tuple[bool, str]:
+def check_silence(features: AudioFeatures, threshold: float) -> CheckResult:
     """Check that every channel is silent (RMS at/below *threshold*).
 
     :param features: Per-channel features to check.
     :param threshold: RMS at/below which a channel counts as silent.
-    :return: ``(True, "")`` if all channels are silent, else ``(False, reason)``
-        naming the non-silent channels.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        non-silent channels.
     """
     rows = [
         {
@@ -104,18 +176,20 @@ def check_silence(features: AudioFeatures, threshold: float) -> Tuple[bool, str]
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("Silence check:\n%s", df.to_string())
 
     non_silent_df = df[~df["silent"]]
     if non_silent_df.empty:
-        return True, ""
-    return False, (
+        return CheckResult("silence", True)
+    return CheckResult(
+        "silence",
+        False,
         f"Expected silence (RMS <= {threshold}) but audio detected on "
-        f"{len(non_silent_df)} channel(s).\n{non_silent_df.to_string()}"
+        f"{len(non_silent_df)} channel(s)",
+        non_silent_df,
     )
 
 
-def check_audio_present(features: AudioFeatures, threshold: float) -> Tuple[bool, str]:
+def check_audio_present(features: AudioFeatures, threshold: float) -> CheckResult:
     """Check that every channel carries audio (RMS strictly above *threshold*).
 
     Complement of :func:`check_silence`; mirrors the legacy
@@ -123,8 +197,8 @@ def check_audio_present(features: AudioFeatures, threshold: float) -> Tuple[bool
 
     :param features: Per-channel features to check.
     :param threshold: RMS strictly above which a channel counts as present.
-    :return: ``(True, "")`` if all channels are present, else ``(False, reason)``
-        naming the silent channels.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        silent channels.
     """
     rows = [
         {
@@ -135,27 +209,28 @@ def check_audio_present(features: AudioFeatures, threshold: float) -> Tuple[bool
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("Audio presence check:\n%s", df.to_string())
 
     silent_df = df[~df["audio_present"]]
     if silent_df.empty:
-        return True, ""
-    return False, (
-        f"No audio detected (RMS <= {threshold}) on {len(silent_df)} channel(s).\n"
-        f"{silent_df.to_string()}"
+        return CheckResult("audio_present", True)
+    return CheckResult(
+        "audio_present",
+        False,
+        f"No audio detected (RMS <= {threshold}) on {len(silent_df)} channel(s)",
+        silent_df,
     )
 
 
 def check_rms(
     features: AudioFeatures, expected_rms: List[float], tolerance: float
-) -> Tuple[bool, str]:
+) -> CheckResult:
     """Check that each channel's RMS is within *tolerance* of its expected value.
 
     :param features: Per-channel features to check.
     :param expected_rms: Per-channel expected RMS values.
     :param tolerance: Allowed absolute deviation from *expected_rms*.
-    :return: ``(True, "")`` if all channels are in tolerance, else
-        ``(False, reason)`` naming the out-of-tolerance channels.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        out-of-tolerance channels.
     """
     rows = [
         {
@@ -168,23 +243,25 @@ def check_rms(
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("RMS check:\n%s", df.to_string())
 
     failed_df = df[~df["rms_ok"]]
     if failed_df.empty:
-        return True, ""
-    return False, (
-        f"RMS out of tolerance on {len(failed_df)} channel(s).\n{failed_df.to_string()}"
+        return CheckResult("rms", True)
+    return CheckResult(
+        "rms",
+        False,
+        f"RMS out of tolerance on {len(failed_df)} channel(s)",
+        failed_df,
     )
 
 
-def check_frequency(features: AudioFeatures) -> Tuple[bool, str]:
+def check_frequency(features: AudioFeatures) -> CheckResult:
     """Check that the expected frequency was detected on every channel.
 
     :param features: Per-channel features to check (``detected`` set by the
         FFT stage of :meth:`AudioFeatures.compute`).
-    :return: ``(True, "")`` if detected on all channels, else ``(False, reason)``
-        naming the channels that missed the expected frequency.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        channels that missed the expected frequency.
     """
     rows = [
         {
@@ -202,26 +279,27 @@ def check_frequency(features: AudioFeatures) -> Tuple[bool, str]:
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("Frequency presence check:\n%s", df.to_string())
 
     failed_df = df[~df["detected"]]
     if failed_df.empty:
-        return True, ""
-    return False, (
-        f"Expected frequency not detected on {len(failed_df)} channel(s).\n"
-        f"{failed_df.to_string()}"
+        return CheckResult("frequency", True)
+    return CheckResult(
+        "frequency",
+        False,
+        f"Expected frequency not detected on {len(failed_df)} channel(s)",
+        failed_df,
     )
 
 
-def check_thd(features: AudioFeatures, max_thd: float) -> Tuple[bool, str]:
+def check_thd(features: AudioFeatures, max_thd: float) -> CheckResult:
     """Check that each channel's THD is at/below *max_thd* percent.
 
     Channels with THD not computed (``None``) are treated as passing.
 
     :param features: Per-channel features to check.
     :param max_thd: Maximum allowed THD as a percentage.
-    :return: ``(True, "")`` if all channels are within tolerance, else
-        ``(False, reason)`` naming the channels above tolerance.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        channels above tolerance.
     """
     rows = [
         {
@@ -233,18 +311,19 @@ def check_thd(features: AudioFeatures, max_thd: float) -> Tuple[bool, str]:
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("THD check:\n%s", df.to_string())
 
     failed_df = df[~df["thd_ok"]]
     if failed_df.empty:
-        return True, ""
-    return False, (
-        f"THD above tolerance ({max_thd} %) on {len(failed_df)} channel(s).\n"
-        f"{failed_df.to_string()}"
+        return CheckResult("thd", True)
+    return CheckResult(
+        "thd",
+        False,
+        f"THD above tolerance ({max_thd} %) on {len(failed_df)} channel(s)",
+        failed_df,
     )
 
 
-def check_thd_n(features: AudioFeatures, max_thd_n: float) -> Tuple[bool, str]:
+def check_thd_n(features: AudioFeatures, max_thd_n: float) -> CheckResult:
     """Check that each channel's THD+N is at/below *max_thd_n* percent.
 
     THD+N accounts for broadband noise as well as harmonics, so it catches a
@@ -253,8 +332,8 @@ def check_thd_n(features: AudioFeatures, max_thd_n: float) -> Tuple[bool, str]:
 
     :param features: Per-channel features to check.
     :param max_thd_n: Maximum allowed THD+N as a percentage.
-    :return: ``(True, "")`` if all channels are within tolerance, else
-        ``(False, reason)`` naming the channels above tolerance.
+    :return: A passing :class:`CheckResult`, or a failing one carrying the
+        channels above tolerance.
     """
     rows = [
         {
@@ -266,33 +345,31 @@ def check_thd_n(features: AudioFeatures, max_thd_n: float) -> Tuple[bool, str]:
         for ch, feat in enumerate(features.channel_features)
     ]
     df = pd.DataFrame(rows).set_index("ch")
-    logger.debug("THD+N check:\n%s", df.to_string())
 
     failed_df = df[~df["thd_n_ok"]]
     if failed_df.empty:
-        return True, ""
-    return False, (
-        f"THD+N above tolerance ({max_thd_n} %) on {len(failed_df)} channel(s).\n"
-        f"{failed_df.to_string()}"
+        return CheckResult("thd_n", True)
+    return CheckResult(
+        "thd_n",
+        False,
+        f"THD+N above tolerance ({max_thd_n} %) on {len(failed_df)} channel(s)",
+        failed_df,
     )
 
 
-def evaluate_chunk(
-    features: AudioFeatures, criteria: AudioCriteria
-) -> Tuple[bool, str]:
+def evaluate_chunk(features: AudioFeatures, criteria: AudioCriteria) -> ChunkVerdict:
     """Evaluate one chunk's features against every configured check.
 
     Unlike a short-circuiting check, this runs *all* checks enabled by
-    *criteria* and aggregates the reasons of every failing one, so a single
-    chunk reports all its problems at once.
+    *criteria* and collects every result, so a single chunk reports all its
+    problems at once.
 
     :param features: Per-channel features from :meth:`AudioFeatures.compute`.
     :param criteria: Active criteria snapshot.
-    :return: ``(True, "")`` if every configured check passes, otherwise
-        ``(False, reason)`` where *reason* joins the reason of each failing
-        check (one per line).
+    :return: A :class:`ChunkVerdict` holding each executed check's result;
+        ``verdict.ok`` is ``True`` when every configured check passed.
     """
-    results: List[Tuple[bool, str]] = []
+    results: List[CheckResult] = []
 
     if criteria.require_audio_present:
         results.append(check_audio_present(features, criteria.silence_rms_threshold))
@@ -309,9 +386,8 @@ def evaluate_chunk(
     if criteria.max_thd_n is not None:
         results.append(check_thd_n(features, criteria.max_thd_n))
     if criteria.custom_check is not None:
-        results.append(criteria.custom_check(features))
+        results.append(
+            CheckResult.from_tuple("custom", criteria.custom_check(features))
+        )
 
-    failures = [reason for ok, reason in results if not ok]
-    if failures:
-        return False, "\n".join(failures)
-    return True, ""
+    return ChunkVerdict(results)

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation/continous_validation/models.py

@@ -5,12 +5,29 @@ short-lived (only referenced by the bounded retention buffer).
 """
 
 from dataclasses import dataclass, field
+from textwrap import indent
 from typing import List, Optional
 
 import numpy as np
 import pandas as pd
 
 
+def format_timestamp(seconds: float) -> str:
+    """Render *seconds* since capture start as ``HH:MM:SS.mmm``.
+
+    Chunk boundaries are far easier to line up with a long run's wall clock as
+    ``00:15:04.023`` than as ``904.023``. Hours are not wrapped at 24.
+
+    :param seconds: Offset from capture start in seconds.
+    :return: Zero-padded ``HH:MM:SS.mmm`` string.
+    """
+    millis = round(seconds * 1000)
+    hours, millis = divmod(millis, 3_600_000)
+    minutes, millis = divmod(millis, 60_000)
+    secs, millis = divmod(millis, 1000)
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millis:03d}"
+
+
 @dataclass
 class RawChunk:
     """One contiguous captured block, tagged with its position in the run.
@@ -41,13 +58,19 @@ class ChannelMetric:
 
 @dataclass
 class ChunkMetrics:
-    """Per-chunk analysis result: timing, verdict and per-channel metrics."""
+    """Per-chunk analysis result: timing, verdict and per-channel metrics.
+
+    :ivar reason: Single-line failure summary, suited to a table column.
+    :ivar detail: Multiline failure report with the per-check channel tables;
+        never put this in a DataFrame cell, log it separately.
+    """
 
     index: int
     start_s: float
     end_s: float
     ok: bool
     reason: str
+    detail: str = ""
     channels: List[ChannelMetric] = field(default_factory=list)
 
 
@@ -60,6 +83,17 @@ class FailureInfo:
     reason: str
     wav_offset_s: float
 
+    def __str__(self) -> str:
+        """Return a human-readable, multiline failure summary."""
+        return (
+            "FailureInfo:\n"
+            f"  chunk_index: {self.chunk_index}\n"
+            f"  time_s: {self.time_s}\n"
+            f"  wav_offset_s: {self.wav_offset_s}\n"
+            "  reason:\n"
+            f"{indent(self.reason, '    ')}"
+        )
+
 
 @dataclass
 class ValidationResult:  # pylint: disable=too-many-instance-attributes
@@ -83,22 +117,44 @@ class ValidationResult:  # pylint: disable=too-many-instance-attributes
     plot_path: Optional[str] = None
 
     def metrics_dataframe(self) -> pd.DataFrame:
-        """Flatten the metrics timeline to one row per (chunk, channel)."""
+        """Flatten the metrics timeline to one row per (chunk, channel).
+
+        The ``reason`` column holds only the single-line failure summary; the
+        per-check channel tables live in :meth:`failure_details`, because a
+        multiline table crammed into one cell wrecks the table layout.
+
+        ``start``/``end`` are rendered as ``HH:MM:SS.mmm`` offsets from capture
+        start rather than raw seconds.
+        """
         rows = []
         for metric in self.metrics:
             for ch_idx, ch_mertric in enumerate(metric.channels):
                 rows.append(
                     {
                         "index": metric.index,
-                        "start_s": metric.start_s,
-                        "end_s": metric.end_s,
-                        "ok": metric.ok,
-                        "reason": metric.reason,
+                        "start": format_timestamp(metric.start_s),
+                        "end": format_timestamp(metric.end_s),
                         "ch": ch_idx,
                         "rms": ch_mertric.rms,
                         "thd": ch_mertric.thd,
                         "thd_n": ch_mertric.thd_n,
                         "detected": ch_mertric.detected,
+                        "ok": metric.ok,
+                        "reason": metric.reason,
                     }
                 )
         return pd.DataFrame(rows)
+
+    def failure_details(self) -> str:
+        """Render the multiline failure report of every failing chunk.
+
+        One block per failing chunk, each with the per-check channel tables
+        produced by the criteria checks. Empty when no chunk failed.
+        """
+        blocks = [
+            f"chunk {metric.index} (t={metric.start_s:.1f}-{metric.end_s:.1f}s):\n"
+            f"{indent(metric.detail or metric.reason, '  ')}"
+            for metric in self.metrics
+            if not metric.ok
+        ]
+        return "\n".join(blocks)

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation/continous_validation/validator.py

@@ -27,6 +27,7 @@ from scipy.io import wavfile
 from audio_validation.audio_features import AudioFeatures
 from audio_validation.continous_validation.criteria import (
     AudioCriteria,
+    ChunkVerdict,
     evaluate_chunk,
 )
 from audio_validation.continous_validation.models import (
@@ -56,8 +57,14 @@ class ValidatorConfig:
     :param max_capture_s: Capture-time limit; ``None`` means unlimited.
     :param pre_failure_s: Seconds retained before failure; ``None`` keeps all.
     :param post_failure_s: Seconds retained/captured after a failure.
-    :param stop_on_failure: Stop the run on the first armed failure.
+    :param stop_on_failure: Stop the run on the first armed failure. When
+        ``False`` the run continues to completion but the failure is still
+        reported in :attr:`ValidationResult.failure`.
     :param failure_consecutive: Consecutive failing chunks required to report run failure.
+    :param warmup_chunks: Leading chunks whose features are computed and recorded
+        but not evaluated. Covers playback start-up, where the signal is still
+        ramping and THD / RMS are meaningless — especially with a small
+        ``chunk_s``, where the ramp fills a whole chunk.
     :param artifacts_dir: Directory for persisted artifacts (for example WAV).
     :param wav_filename: Saved WAV filename.
     :param wav_dtype: Retained/saved sample dtype.
@@ -74,6 +81,7 @@ class ValidatorConfig:
     post_failure_s: int = 60
     stop_on_failure: bool = True
     failure_consecutive: int = 1
+    warmup_chunks: int = 0
     artifacts_dir: str = "test_artifacts"
     wav_filename: str = "continuous_capture.wav"
     wav_dtype: str = "float32"
@@ -323,7 +331,12 @@ class ContinuousAudioValidator:  # pylint: disable=too-many-instance-attributes
             self._abort.set()
 
     def _validate_chunk_features(self, chunk: RawChunk) -> None:
-        """Compute features for *chunk*, evaluate criteria, and arm on failure."""
+        """Compute features for *chunk*, evaluate criteria, and arm on failure.
+
+        Warm-up chunks still get their features computed and recorded — they
+        belong in the metrics table and the WAV — but no check is run against
+        them, so they can neither fail the run nor break a failing streak.
+        """
         with self._state_lock:
             criteria = self._criteria
 
@@ -337,20 +350,16 @@ class ContinuousAudioValidator:  # pylint: disable=too-many-instance-attributes
             skip_latency=chunk.index == 0,
             activity_threshold=criteria.silence_rms_threshold,
         )
-        logger.debug(
-            "Evaluating chunk %d: start=%.1fs end=%.1fs",
-            chunk.index,
-            chunk.start_s,
-            chunk.end_s,
-        )
-        ok, reason = evaluate_chunk(features, criteria)
+        warmup = chunk.index < self._cfg.warmup_chunks
+        verdict = ChunkVerdict() if warmup else evaluate_chunk(features, criteria)
 
         metric = ChunkMetrics(
             index=chunk.index,
             start_s=chunk.start_s,
             end_s=chunk.end_s,
-            ok=ok,
-            reason=reason,
+            ok=verdict.ok,
+            reason="warm-up (not evaluated)" if warmup else verdict.summary,
+            detail=verdict.detail,
             channels=[
                 ChannelMetric(
                     rms=feat.rms,
@@ -372,26 +381,27 @@ class ContinuousAudioValidator:  # pylint: disable=too-many-instance-attributes
 
         self._retention.add(chunk)
 
-        if ok:
+        if verdict.ok:
             self._consec_fail = 0
             return
-        if not self._cfg.stop_on_failure:
-            return
         self._consec_fail += 1
         if self._consec_fail < self._cfg.failure_consecutive:
             return
-        first = False
+        arm_stop = False
         with self._state_lock:
-            if self._failure_time_s is None:
-                self._failure_time_s = chunk.end_s
+            if self._failure_info is None:
                 self._failure_info = FailureInfo(
                     chunk_index=chunk.index,
                     time_s=chunk.start_s,
-                    reason=reason,
+                    reason=verdict.detail,
                     wav_offset_s=0.0,  # will be updated when wav is written
                 )
-                first = True
-        if first:
+            # ``_failure_time_s`` arms the run teardown (reader break + retention
+            # freeze), so it is only set when the run is meant to stop.
+            if self._cfg.stop_on_failure and self._failure_time_s is None:
+                self._failure_time_s = chunk.end_s
+                arm_stop = True
+        if arm_stop:
             self._retention.freeze(chunk.end_s)
 
     # Finalising the run and assembling the result ------------------------------------------------
@@ -463,12 +473,20 @@ class ContinuousAudioValidator:  # pylint: disable=too-many-instance-attributes
             error = self._error
             metrics = list(self._metrics)
 
-        if failure is not None and wav_start is not None:
+        # Without ``stop_on_failure`` the retention window keeps rolling, so the
+        # failing chunk may have been evicted before the WAV was written.
+        failure_in_wav = (
+            failure is not None
+            and wav_start is not None
+            and wav_end is not None
+            and wav_start <= failure.time_s <= wav_end
+        )
+        if failure_in_wav:
             failure = replace(failure, wav_offset_s=failure.time_s - wav_start)
 
         if error is not None:
             stopped_reason = "capture_error"
-        elif failure is not None:
+        elif failure is not None and self._cfg.stop_on_failure:
             stopped_reason = "failure"
         elif self._stop_requested:
             stopped_reason = "stopped"
@@ -484,8 +502,12 @@ class ContinuousAudioValidator:  # pylint: disable=too-many-instance-attributes
                 (
                     f"; failure at t={failure.time_s:.1f}s = "
                     f"{failure.wav_offset_s:.1f}s into WAV."
-                    if failure is not None
-                    else "."
+                    if failure_in_wav
+                    else (
+                        f"; failure at t={failure.time_s:.1f}s is outside the WAV."
+                        if failure is not None
+                        else "."
+                    )
                 ),
             )
 

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audio_validation
-Version: 0.3.0
+Version: 0.3.2
 Summary: Tools for validating audio data, including feature extraction and visualization.
 Maintainer-email: Hubert Stepniewski <hubert.stepniewski@int2code.com>, Marcin Tomiczek <marcin.tomiczek@int2code.com>, Piotr Sznapka <piotr.sznapka@int2code.com>
 License: MIT License

{audio_validation-0.3.0 → audio_validation-0.3.2}/src/audio_validation.egg-info/scm_file_list.json

@@ -1,38 +1,38 @@
 {
   "files": [
-    "README.md",
-    "requirements-test.txt",
     "tox.ini",
-    "LICENSE",
-    ".pylint_ignore",
-    "pyproject.toml",
     "requirements.txt",
-    ".gitignore",
+    "requirements-test.txt",
     "requirements-dev.txt",
+    "pyproject.toml",
+    ".pylint_ignore",
+    "LICENSE",
     "RELEASE_NOTES.md",
-    "docs/Makefile",
-    "docs/index.rst",
-    "docs/requirements.txt",
-    "docs/installation.rst",
-    "docs/contribute.rst",
-    "docs/release_notes.rst",
-    "docs/conf.py",
-    "docs/tutorials/index.rst",
+    "README.md",
+    ".gitignore",
+    ".github/workflows/code_checker.yml",
+    ".github/workflows/unit_tests.yml",
+    ".github/workflows/publish_to_pypi.yml",
+    "tests/__init__.py",
+    "tests/test_template.py",
     "src/audio_validation/__init__.py",
     "src/audio_validation/audio_features.py",
     "src/audio_validation/audio_verification.py",
     "src/audio_validation/utils/audio_generation.py",
-    "src/audio_validation/continous_validation/retention.py",
-    "src/audio_validation/continous_validation/validator.py",
     "src/audio_validation/continous_validation/criteria.py",
+    "src/audio_validation/continous_validation/plots.py",
+    "src/audio_validation/continous_validation/validator.py",
     "src/audio_validation/continous_validation/recorder.py",
+    "src/audio_validation/continous_validation/retention.py",
     "src/audio_validation/continous_validation/models.py",
-    "src/audio_validation/continous_validation/plots.py",
-    "_ci/is_dev_version.sh",
-    "tests/__init__.py",
-    "tests/test_template.py",
-    ".github/workflows/unit_tests.yml",
-    ".github/workflows/publish_to_pypi.yml",
-    ".github/workflows/code_checker.yml"
+    "docs/requirements.txt",
+    "docs/index.rst",
+    "docs/conf.py",
+    "docs/release_notes.rst",
+    "docs/Makefile",
+    "docs/contribute.rst",
+    "docs/installation.rst",
+    "docs/tutorials/index.rst",
+    "_ci/is_dev_version.sh"
   ]
 }

audio_validation-0.3.2/src/audio_validation.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.3.2",
+  "distance": 0,
+  "node": "ge32c5a61ba2f0d187518620dd508fd43f8e2e24f",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-06"
+}

audio_validation-0.3.0/RELEASE_NOTES.md

@@ -1,11 +0,0 @@
-### 0.3.0
-
-[MINOR] Add Continous Audio Validator.
-
-### 0.2.0
-
-[MINOR] Add THD, THD+N calculation.
-
-### 0.1.2
-
-[MINOR] Initial release.

audio_validation-0.3.0/src/audio_validation.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.3.0",
-  "distance": 0,
-  "node": "gc754f78124724d9a3fd179145568e6219acf5b25",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-07-16"
-}