oscura 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

oscura/{quality → validation/quality}/__init__.py

@@ -1,6 +1,6 @@
 """Signal quality analysis module for Oscura."""
 
-from oscura.quality.ensemble import (
+from oscura.validation.quality.ensemble import (
     AMPLITUDE_ENSEMBLE,
     EDGE_DETECTION_ENSEMBLE,
     FREQUENCY_ENSEMBLE,
@@ -10,12 +10,12 @@ from oscura.quality.ensemble import (
     create_edge_ensemble,
     create_frequency_ensemble,
 )
-from oscura.quality.explainer import (
+from oscura.validation.quality.explainer import (
     ResultExplainer,
     ResultExplanation,
     explain_result,
 )
-from oscura.quality.scoring import (
+from oscura.validation.quality.scoring import (
     AnalysisQualityScore,
     DataQualityMetrics,
     ReliabilityCategory,
@@ -24,7 +24,7 @@ from oscura.quality.scoring import (
     combine_quality_scores,
     score_analysis_result,
 )
-from oscura.quality.warnings import (
+from oscura.validation.quality.warnings import (
     QualityWarning,
     SignalQualityAnalyzer,
     check_clipping,

oscura/{quality → validation/quality}/ensemble.py

@@ -6,8 +6,8 @@ bias, handle outliers, and provide confidence bounds for more reliable measureme
 
 
 Example:
-    >>> from oscura.quality.ensemble import EnsembleAggregator, AggregationMethod
-    >>> from oscura.quality.ensemble import create_frequency_ensemble
+    >>> from oscura.validation.quality.ensemble import EnsembleAggregator, AggregationMethod
+    >>> from oscura.validation.quality.ensemble import create_frequency_ensemble
     >>> # Combine multiple frequency measurements
     >>> result = create_frequency_ensemble(signal, sample_rate=1e9)
     >>> print(f"Frequency: {result.value:.2f} Hz ± {result.confidence*100:.1f}%")
@@ -38,7 +38,7 @@ from typing import TYPE_CHECKING, Any
 import numpy as np
 from scipy import stats
 
-from oscura.quality.scoring import AnalysisQualityScore, combine_quality_scores
+from oscura.validation.quality.scoring import AnalysisQualityScore, combine_quality_scores
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray
@@ -233,118 +233,143 @@ class EnsembleAggregator:
         if not values:
             raise ValueError("Cannot aggregate empty values list")
 
-        if original_results is None:
-            original_results = [
-                {"value": v, "confidence": c} for v, c in zip(values, confidences, strict=False)
-            ]
+        original_results = original_results or [
+            {"value": v, "confidence": c} for v, c in zip(values, confidences, strict=False)
+        ]
+
+        # Filter outliers
+        valid_values, valid_confidences, outlier_indices = self._filter_outliers(
+            values, confidences, original_results
+        )
+
+        # Compute aggregation
+        aggregated_value, std_dev = self._compute_aggregated_value(valid_values, valid_confidences)
+
+        # Compute confidence bounds and agreement
+        lower_bound, upper_bound = self._compute_confidence_bounds(
+            aggregated_value, std_dev, len(valid_values)
+        )
+        method_agreement = self._compute_method_agreement(valid_values, aggregated_value, std_dev)
+
+        # Overall confidence
+        overall_confidence = self._compute_overall_confidence(valid_confidences, method_agreement)
+
+        # Quality scores
+        ensemble_quality = self._combine_quality_scores(original_results, confidences)
+
+        return EnsembleResult(
+            value=aggregated_value,
+            confidence=overall_confidence,
+            lower_bound=lower_bound,
+            upper_bound=upper_bound,
+            method_agreement=method_agreement,
+            individual_results=original_results,
+            aggregation_method=self.method,
+            quality_score=ensemble_quality,
+            outlier_methods=outlier_indices,
+        )
 
+    def _filter_outliers(
+        self,
+        values: list[float],
+        confidences: list[float],
+        original_results: list[dict[str, Any]],
+    ) -> tuple[NDArray[np.float64], NDArray[np.float64], list[int]]:
+        """Filter outliers from values and return valid subsets."""
         values_arr = np.array(values, dtype=np.float64)
         confidences_arr = np.array(confidences, dtype=np.float64)
 
-        # Detect outliers
         outlier_indices = self.detect_outlier_methods(original_results)
 
-        # Create mask for non-outlier values
         valid_mask = np.ones(len(values), dtype=bool)
         valid_mask[outlier_indices] = False
 
-        # Use only non-outliers for aggregation
         valid_values = values_arr[valid_mask]
         valid_confidences = confidences_arr[valid_mask]
 
         if len(valid_values) == 0:
-            # All values are outliers, use all with warning
             logger.warning("All methods detected as outliers, using all values")
-            valid_values = values_arr
-            valid_confidences = confidences_arr
-            outlier_indices = []
+            return values_arr, confidences_arr, []
+
+        return valid_values, valid_confidences, outlier_indices
 
-        # Compute aggregated value based on method
+    def _compute_aggregated_value(
+        self, valid_values: NDArray[np.float64], valid_confidences: NDArray[np.float64]
+    ) -> tuple[float, float]:
+        """Compute aggregated value and standard deviation."""
         if self.method == AggregationMethod.WEIGHTED_AVERAGE:
-            # Normalize weights
             weights = valid_confidences / np.sum(valid_confidences)
-            aggregated_value = float(np.sum(valid_values * weights))
-            # Weighted variance
-            variance = float(np.sum(weights * (valid_values - aggregated_value) ** 2))
-            std_dev = np.sqrt(variance)
+            value = float(np.sum(valid_values * weights))
+            variance = float(np.sum(weights * (valid_values - value) ** 2))
+            return value, float(np.sqrt(variance))
 
         elif self.method == AggregationMethod.MEDIAN:
-            aggregated_value = float(np.median(valid_values))
-            # Use MAD (Median Absolute Deviation) for robust std estimate
-            mad = float(np.median(np.abs(valid_values - aggregated_value)))
-            std_dev = mad * 1.4826  # Scale factor for normal distribution
+            value = float(np.median(valid_values))
+            mad = float(np.median(np.abs(valid_values - value)))
+            return value, mad * 1.4826
 
         elif self.method == AggregationMethod.BAYESIAN:
-            # Bayesian combination with Gaussian likelihood
-            # Prior: uniform over range
-            # Likelihood: Gaussian with confidence-based variance
-            precisions = valid_confidences**2  # Higher confidence = lower variance
+            precisions = valid_confidences**2
             total_precision = np.sum(precisions)
-            aggregated_value = float(np.sum(valid_values * precisions) / total_precision)
-            # Posterior variance
-            variance = 1.0 / total_precision
-            std_dev = float(np.sqrt(variance))
-
-        else:
-            # Fallback to simple average
-            aggregated_value = float(np.mean(valid_values))
-            std_dev = float(np.std(valid_values))
-
-        # Compute confidence bounds (95% confidence interval)
-        if len(valid_values) > 1:
-            # Use t-distribution for small samples
-            dof = len(valid_values) - 1
-            t_value = stats.t.ppf(0.975, dof)  # 95% CI
-            margin = t_value * std_dev / np.sqrt(len(valid_values))
-            lower_bound = aggregated_value - margin
-            upper_bound = aggregated_value + margin
-        else:
-            lower_bound = aggregated_value
-            upper_bound = aggregated_value
+            value = float(np.sum(valid_values * precisions) / total_precision)
+            std_dev = float(np.sqrt(1.0 / total_precision))
+            return value, std_dev
 
-        # Compute method agreement (inverse of coefficient of variation)
-        if len(valid_values) > 1 and aggregated_value != 0:
-            cv = std_dev / abs(aggregated_value)
-            method_agreement = float(np.clip(1.0 - cv, 0.0, 1.0))
         else:
-            method_agreement = 1.0
-
-        # Overall confidence (weighted average of individual confidences)
-        overall_confidence = float(np.mean(valid_confidences))
+            return float(np.mean(valid_values)), float(np.std(valid_values))
+
+    def _compute_confidence_bounds(
+        self, value: float, std_dev: float, n_values: int
+    ) -> tuple[float, float]:
+        """Compute 95% confidence interval bounds."""
+        if n_values <= 1:
+            return value, value
+
+        dof = n_values - 1
+        t_value = stats.t.ppf(0.975, dof)
+        margin = t_value * std_dev / np.sqrt(n_values)
+        return value - margin, value + margin
+
+    def _compute_method_agreement(
+        self, valid_values: NDArray[np.float64], value: float, std_dev: float
+    ) -> float:
+        """Compute method agreement from coefficient of variation."""
+        if len(valid_values) <= 1 or value == 0:
+            return 1.0
+
+        cv = std_dev / abs(value)
+        return float(np.clip(1.0 - cv, 0.0, 1.0))
+
+    def _compute_overall_confidence(
+        self, valid_confidences: NDArray[np.float64], method_agreement: float
+    ) -> float:
+        """Compute overall confidence with agreement penalty."""
+        confidence = float(np.mean(valid_confidences))
 
-        # Penalize confidence if agreement is low
         if method_agreement < self.min_agreement:
-            overall_confidence *= method_agreement
+            confidence *= method_agreement
             logger.warning(
                 f"Low method agreement ({method_agreement:.2f}), "
-                f"reduced confidence to {overall_confidence:.2f}"
+                f"reduced confidence to {confidence:.2f}"
             )
 
-        # Combine quality scores if available
+        return confidence
+
+    def _combine_quality_scores(
+        self, original_results: list[dict[str, Any]], confidences: list[float]
+    ) -> AnalysisQualityScore | None:
+        """Combine quality scores if available."""
         quality_scores_raw = [
             r.get("quality_score") for r in original_results if "quality_score" in r
         ]
-        ensemble_quality = None
-        if quality_scores_raw and all(
+
+        if not quality_scores_raw or not all(
             isinstance(q, AnalysisQualityScore) for q in quality_scores_raw
         ):
-            # Type narrowing - we know all are AnalysisQualityScore at this point
-            quality_scores: list[AnalysisQualityScore] = quality_scores_raw  # type: ignore[assignment]
-            ensemble_quality = combine_quality_scores(
-                quality_scores, weights=confidences[: len(quality_scores)]
-            )
+            return None
 
-        return EnsembleResult(
-            value=aggregated_value,
-            confidence=overall_confidence,
-            lower_bound=lower_bound,
-            upper_bound=upper_bound,
-            method_agreement=method_agreement,
-            individual_results=original_results,
-            aggregation_method=self.method,
-            quality_score=ensemble_quality,
-            outlier_methods=outlier_indices,
-        )
+        quality_scores: list[AnalysisQualityScore] = quality_scores_raw  # type: ignore[assignment]
+        return combine_quality_scores(quality_scores, weights=confidences[: len(quality_scores)])
 
     def aggregate_categorical(
         self,
@@ -517,7 +542,7 @@ def create_frequency_ensemble(
         EnsembleResult with combined frequency estimate.
 
     Raises:
-        ValueError: If all frequency detection methods fail.
+        ValueError: If all frequency detection methods failed.
 
     Example:
         >>> import numpy as np
@@ -531,80 +556,96 @@ def create_frequency_ensemble(
         method_weights = FREQUENCY_ENSEMBLE
 
     results = []
+    results.extend(_try_fft_frequency(signal, sample_rate, method_weights[0][1]))
+    results.extend(_try_zero_crossing_frequency(signal, sample_rate, method_weights[1][1]))
+    results.extend(_try_autocorr_frequency(signal, sample_rate, method_weights[2][1]))
+
+    if not results:
+        raise ValueError("All frequency detection methods failed")
+
+    aggregator = EnsembleAggregator(method=AggregationMethod.WEIGHTED_AVERAGE)
+    return aggregator.aggregate(results)
 
-    # Method 1: FFT peak detection
+
+def _try_fft_frequency(
+    signal: NDArray[np.float64], sample_rate: float, weight: float
+) -> list[dict[str, Any]]:
+    """Try FFT peak detection for frequency estimation."""
     try:
         fft_result = np.fft.rfft(signal)
         freqs = np.fft.rfftfreq(len(signal), d=1.0 / sample_rate)
         peak_idx = np.argmax(np.abs(fft_result[1:])) + 1  # Skip DC
         freq_fft = float(freqs[peak_idx])
+
         # Confidence based on peak prominence
         peak_magnitude = np.abs(fft_result[peak_idx])
         mean_magnitude = np.mean(np.abs(fft_result[1:]))
-        confidence_fft = min(1.0, peak_magnitude / (mean_magnitude * 10))
-        results.append(
-            {
-                "value": freq_fft,
-                "confidence": confidence_fft * method_weights[0][1],
-                "method": "fft_peak",
-            }
-        )
+        confidence = min(1.0, peak_magnitude / (mean_magnitude * 10))
+
+        return [{"value": freq_fft, "confidence": confidence * weight, "method": "fft_peak"}]
     except Exception as e:
         logger.debug(f"FFT peak detection failed: {e}")
+        return []
 
-    # Method 2: Zero crossing rate
+
+def _try_zero_crossing_frequency(
+    signal: NDArray[np.float64], sample_rate: float, weight: float
+) -> list[dict[str, Any]]:
+    """Try zero crossing rate for frequency estimation."""
     try:
         zero_crossings = np.where(np.diff(np.sign(signal)))[0]
-        if len(zero_crossings) > 1:
-            # Average time between zero crossings (half period)
-            avg_half_period = np.mean(np.diff(zero_crossings)) / sample_rate
-            freq_zc = 1.0 / (2.0 * avg_half_period)
-            # Confidence based on regularity of crossings
-            std_half_period = np.std(np.diff(zero_crossings)) / sample_rate
-            confidence_zc = max(0.0, 1.0 - std_half_period / avg_half_period)
-            results.append(
-                {
-                    "value": float(freq_zc),
-                    "confidence": confidence_zc * method_weights[1][1],
-                    "method": "zero_crossing",
-                }
-            )
+        if len(zero_crossings) <= 1:
+            return []
+
+        # Average time between zero crossings (half period)
+        avg_half_period = np.mean(np.diff(zero_crossings)) / sample_rate
+        freq_zc = 1.0 / (2.0 * avg_half_period)
+
+        # Confidence based on regularity of crossings
+        std_half_period = np.std(np.diff(zero_crossings)) / sample_rate
+        confidence = max(0.0, 1.0 - std_half_period / avg_half_period)
+
+        return [
+            {"value": float(freq_zc), "confidence": confidence * weight, "method": "zero_crossing"}
+        ]
     except Exception as e:
         logger.debug(f"Zero crossing detection failed: {e}")
+        return []
 
-    # Method 3: Autocorrelation
+
+def _try_autocorr_frequency(
+    signal: NDArray[np.float64], sample_rate: float, weight: float
+) -> list[dict[str, Any]]:
+    """Try autocorrelation for frequency estimation."""
     try:
-        # Compute autocorrelation
         autocorr = np.correlate(signal, signal, mode="full")
         autocorr = autocorr[len(autocorr) // 2 :]
-        # Find first peak after zero lag (skip DC)
-        peaks = []
-        for i in range(1, min(len(autocorr) - 1, len(signal) // 2)):
-            if autocorr[i] > autocorr[i - 1] and autocorr[i] > autocorr[i + 1]:
-                peaks.append(i)
-        if peaks:
-            first_peak = peaks[0]
-            period_samples = first_peak
-            freq_ac = sample_rate / period_samples
-            # Confidence based on peak strength
-            peak_strength = autocorr[first_peak] / autocorr[0]
-            confidence_ac = float(np.clip(peak_strength, 0.0, 1.0))
-            results.append(
-                {
-                    "value": float(freq_ac),
-                    "confidence": confidence_ac * method_weights[2][1],
-                    "method": "autocorrelation",
-                }
-            )
-    except Exception as e:
-        logger.debug(f"Autocorrelation detection failed: {e}")
 
-    if not results:
-        raise ValueError("All frequency detection methods failed")
+        # Find first peak after zero lag
+        peaks = [
+            i
+            for i in range(1, min(len(autocorr) - 1, len(signal) // 2))
+            if autocorr[i] > autocorr[i - 1] and autocorr[i] > autocorr[i + 1]
+        ]
 
-    # Aggregate results
-    aggregator = EnsembleAggregator(method=AggregationMethod.WEIGHTED_AVERAGE)
-    return aggregator.aggregate(results)
+        if not peaks:
+            return []
+
+        first_peak = peaks[0]
+        freq_ac = sample_rate / first_peak
+        peak_strength = autocorr[first_peak] / autocorr[0]
+        confidence = float(np.clip(peak_strength, 0.0, 1.0))
+
+        return [
+            {
+                "value": float(freq_ac),
+                "confidence": confidence * weight,
+                "method": "autocorrelation",
+            }
+        ]
+    except Exception as e:
+        logger.debug(f"Autocorrelation detection failed: {e}")
+        return []
 
 
 def create_edge_ensemble(
@@ -643,89 +684,128 @@ def create_edge_ensemble(
         threshold = float((np.max(signal) + np.min(signal)) / 2.0)
 
     results = []
+    results.extend(_detect_threshold_crossing(signal, threshold, method_weights[0][1]))
+    results.extend(_detect_derivative_edges(signal, method_weights[1][1]))
+    results.extend(_detect_schmitt_trigger(signal, threshold, method_weights[2][1]))
 
-    # Method 1: Threshold crossing
+    if not results:
+        raise ValueError("All edge detection methods failed")
+
+    aggregator = EnsembleAggregator(method=AggregationMethod.MEDIAN)
+    return aggregator.aggregate(results)
+
+
+def _detect_threshold_crossing(
+    signal: NDArray[np.float64], threshold: float, weight: float
+) -> list[dict[str, Any]]:
+    """Detect edges via threshold crossing.
+
+    Args:
+        signal: Input signal.
+        threshold: Detection threshold.
+        weight: Method weight for confidence.
+
+    Returns:
+        List with single result dict or empty list if failed.
+    """
     try:
         crossings = np.where(np.diff(np.sign(signal - threshold)))[0]
-        edge_count_tc = len(crossings)
-        # Confidence based on signal quality (SNR proxy)
+        edge_count = len(crossings)
+
         signal_range = np.ptp(signal)
         noise_estimate = np.std(np.diff(signal))
-        confidence_tc = (
-            min(1.0, signal_range / (noise_estimate * 10)) if noise_estimate > 0 else 0.5
-        )
-        results.append(
+        confidence = min(1.0, signal_range / (noise_estimate * 10)) if noise_estimate > 0 else 0.5
+
+        return [
             {
-                "value": edge_count_tc,
-                "confidence": confidence_tc * method_weights[0][1],
+                "value": edge_count,
+                "confidence": confidence * weight,
                 "method": "threshold_crossing",
             }
-        )
+        ]
     except Exception as e:
         logger.debug(f"Threshold crossing detection failed: {e}")
+        return []
+
+
+def _detect_derivative_edges(signal: NDArray[np.float64], weight: float) -> list[dict[str, Any]]:
+    """Detect edges via derivative peak detection.
+
+    Args:
+        signal: Input signal.
+        weight: Method weight for confidence.
 
-    # Method 2: Derivative-based
+    Returns:
+        List with single result dict or empty list if failed.
+    """
     try:
         derivative = np.diff(signal)
-        # Find peaks in absolute derivative
         deriv_std = np.std(derivative)
         deriv_threshold = deriv_std * 2
         edge_indices = np.where(np.abs(derivative) > deriv_threshold)[0]
+
         # Remove consecutive detections (within 2 samples)
         filtered_edges = []
         for i, idx in enumerate(edge_indices):
             if i == 0 or idx - edge_indices[i - 1] > 2:
                 filtered_edges.append(idx)
-        edge_count_deriv = len(filtered_edges)
-        # Confidence based on peak derivative prominence above threshold
-        # Higher max derivative relative to threshold means clearer edges
+
         max_deriv = np.max(np.abs(derivative)) if len(derivative) > 0 else 0.0
         prominence_ratio = (max_deriv / deriv_threshold) if deriv_threshold > 0 else 0.0
-        confidence_deriv = float(
-            np.clip(prominence_ratio / 3.0, 0.0, 1.0)
-        )  # Normalize: 3x threshold = 100%
-        results.append(
+        confidence = float(np.clip(prominence_ratio / 3.0, 0.0, 1.0))
+
+        return [
             {
-                "value": edge_count_deriv,
-                "confidence": confidence_deriv * method_weights[1][1],
+                "value": len(filtered_edges),
+                "confidence": confidence * weight,
                 "method": "derivative",
             }
-        )
+        ]
     except Exception as e:
         logger.debug(f"Derivative edge detection failed: {e}")
+        return []
+
 
-    # Method 3: Schmitt trigger (hysteresis)
+def _detect_schmitt_trigger(
+    signal: NDArray[np.float64], threshold: float, weight: float
+) -> list[dict[str, Any]]:
+    """Detect edges via Schmitt trigger with hysteresis.
+
+    Args:
+        signal: Input signal.
+        threshold: Base threshold.
+        weight: Method weight for confidence.
+
+    Returns:
+        List with single result dict or empty list if failed.
+    """
     try:
         hysteresis = float(np.std(signal) * 0.1)
         thresh_high = threshold + hysteresis
         thresh_low = threshold - hysteresis
         state = signal[0] > threshold
-        edge_count_schmitt = 0
+        edge_count = 0
+
         for val in signal:
             if not state and val > thresh_high:
-                edge_count_schmitt += 1
+                edge_count += 1
                 state = True
             elif state and val < thresh_low:
-                edge_count_schmitt += 1
+                edge_count += 1
                 state = False
-        # Confidence based on hysteresis effectiveness
-        confidence_schmitt = 0.7  # Lower base confidence due to hysteresis delay
-        results.append(
+
+        confidence = 0.7  # Lower base confidence due to hysteresis delay
+
+        return [
             {
-                "value": edge_count_schmitt,
-                "confidence": confidence_schmitt * method_weights[2][1],
+                "value": edge_count,
+                "confidence": confidence * weight,
                 "method": "schmitt_trigger",
             }
-        )
+        ]
     except Exception as e:
         logger.debug(f"Schmitt trigger detection failed: {e}")
-
-    if not results:
-        raise ValueError("All edge detection methods failed")
-
-    # Aggregate results (use median for integer counts)
-    aggregator = EnsembleAggregator(method=AggregationMethod.MEDIAN)
-    return aggregator.aggregate(results)
+        return []
 
 
 __all__ = [

oscura/{quality → validation/quality}/explainer.py

@@ -4,8 +4,8 @@ Generates human-readable explanations for why analysis results
 are reliable or unreliable.
 
 Example:
-    >>> from oscura.quality.explainer import explain_result
-    >>> from oscura.quality.scoring import calculate_quality_score
+    >>> from oscura.validation.quality.explainer import explain_result
+    >>> from oscura.validation.quality.scoring import calculate_quality_score
     >>> score = calculate_quality_score(0.9, 0.8, 0.85)
     >>> explanation = explain_result("frequency", 10.5e6, score, "fft")
     >>> print(explanation)
@@ -20,7 +20,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, ClassVar
 
 if TYPE_CHECKING:
-    from oscura.quality.scoring import AnalysisQualityScore
+    from oscura.validation.quality.scoring import AnalysisQualityScore
 
 
 @dataclass

oscura/{quality → validation/quality}/scoring.py

@@ -5,7 +5,7 @@ analysis results, enabling users to assess confidence in automated findings.
 
 
 Example:
-    >>> from oscura.quality.scoring import AnalysisQualityScore, ReliabilityCategory
+    >>> from oscura.validation.quality.scoring import AnalysisQualityScore, ReliabilityCategory
     >>> score = AnalysisQualityScore(
     ...     confidence=0.85,
     ...     category=ReliabilityCategory.HIGH,

oscura/{quality → validation/quality}/warnings.py

@@ -5,7 +5,7 @@ including clipping, noise, saturation, and undersampling.
 
 
 Example:
-    >>> from oscura.quality.warnings import SignalQualityAnalyzer
+    >>> from oscura.validation.quality.warnings import SignalQualityAnalyzer
     >>> analyzer = SignalQualityAnalyzer()
     >>> warnings = analyzer.analyze(trace)
     >>> for warning in warnings:
@@ -91,7 +91,7 @@ class SignalQualityAnalyzer:
         nyquist_factor: Factor for Nyquist frequency check (default: 2.0)
 
     Example:
-        >>> from oscura.quality.warnings import SignalQualityAnalyzer
+        >>> from oscura.validation.quality.warnings import SignalQualityAnalyzer
         >>> analyzer = SignalQualityAnalyzer(clip_threshold=0.95)
         >>> warnings = analyzer.analyze(trace)
         >>> if warnings:
@@ -152,9 +152,9 @@ class SignalQualityAnalyzer:
         """
         # Extract data and sample rate
         if hasattr(trace, "data"):
-            data = trace.data  # type: ignore[ignore-without-code]
+            data = trace.data
             if sample_rate is None and hasattr(trace, "metadata"):
-                sample_rate = trace.metadata.sample_rate  # type: ignore[ignore-without-code]
+                sample_rate = trace.metadata.sample_rate
         else:
             data = trace  # type: ignore[assignment]