Trixy7/trixy_core/arbitration/strategies/confidence.py

# -*- coding: utf-8 -*-
"""
Confidence-Strategie für Arbitration.

Wählt den Satellite mit der höchsten Wakeword-Erkennungs-Confidence.
Nützlich wenn die Audio-Qualität variiert (z.B. verschiedene Mikrofone).
"""

from typing import Any

from trixy_core.arbitration.candidate import ArbitrationCandidate
from trixy_core.arbitration.strategies.base import ArbitrationStrategy


class ConfidenceStrategy(ArbitrationStrategy):
    """
    Strategie: Höchste Wakeword-Confidence gewinnt.

    Diese Strategie wählt den Satellite aus, bei dem das Wakeword
    mit der höchsten Konfidenz erkannt wurde. Nützlich wenn
    verschiedene Mikrofone unterschiedliche Qualität haben.

    Beispiel:
        ```python
        strategy = ConfidenceStrategy()

        candidates = [
            ArbitrationCandidate(satellite_id="kitchen", confidence=0.92),
            ArbitrationCandidate(satellite_id="living_room", confidence=0.88),
        ]

        winner = strategy.select(candidates)
        # winner.satellite_id == "kitchen"
        ```
    """

    def __init__(self, min_confidence: float = 0.5) -> None:
        """
        Initialisiert die Strategie.

        Args:
            min_confidence: Minimale Confidence für Gültigkeit
        """
        self.min_confidence = min_confidence

    @property
    def name(self) -> str:
        return "confidence"

    @property
    def description(self) -> str:
        return "Wählt den Satellite mit der höchsten Wakeword-Confidence"

    def calculate_score(
        self,
        candidate: ArbitrationCandidate,
        context: dict[str, Any] | None = None,
    ) -> float:
        """
        Score basiert nur auf Confidence.

        Args:
            candidate: Der Kandidat
            context: Nicht verwendet

        Returns:
            Confidence als Score (0.0-1.0)
        """
        candidate.score_details = {
            "confidence": candidate.confidence,
        }
        return candidate.confidence

    def select(
        self,
        candidates: list[ArbitrationCandidate],
        context: dict[str, Any] | None = None,
    ) -> ArbitrationCandidate | None:
        """
        Wählt Kandidaten mit höchster Confidence.

        Args:
            candidates: Liste der Kandidaten
            context: Nicht verwendet

        Returns:
            Kandidat mit höchster confidence oder None
        """
        valid = self.filter_valid(candidates)
        if not valid:
            return None

        # Scores berechnen
        for candidate in valid:
            candidate.score = self.calculate_score(candidate, context)

        # Höchsten Score auswählen
        winner = max(valid, key=lambda c: c.score)
        return winner

    def validate_candidate(self, candidate: ArbitrationCandidate) -> bool:
        """Prüft ob Confidence über Minimum liegt."""
        base_valid = super().validate_candidate(candidate)
        return base_valid and candidate.confidence >= self.min_confidence