ankigammon 1.0.0__py3-none-any.whl

ankigammon/gui/widgets/smart_input.py

@@ -0,0 +1,268 @@
+"""
+Smart input widget with auto-detection and visual feedback.
+"""
+
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QPlainTextEdit,
+    QLabel, QFrame, QPushButton
+)
+from PySide6.QtCore import Qt, Signal, QTimer
+from PySide6.QtGui import QFont
+import qtawesome as qta
+
+from ankigammon.settings import Settings
+from ankigammon.gui.format_detector import FormatDetector, DetectionResult, InputFormat
+
+
+class SmartInputWidget(QWidget):
+    """
+    Input widget with intelligent format detection.
+
+    Signals:
+        format_detected(DetectionResult): Emitted when format is detected
+    """
+
+    format_detected = Signal(DetectionResult)
+
+    def __init__(self, settings: Settings, parent=None):
+        super().__init__(parent)
+        self.settings = settings
+        self.detector = FormatDetector(settings)
+        self.last_result = None
+
+        # Debounce timer for detection
+        self.detection_timer = QTimer()
+        self.detection_timer.setSingleShot(True)
+        self.detection_timer.timeout.connect(self._run_detection)
+
+        self._setup_ui()
+
+    def _setup_ui(self):
+        """Initialize the user interface."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(12)
+
+        # Label
+        label = QLabel("Input Text:")
+        label.setStyleSheet("font-weight: 600; color: #cdd6f4;")
+        layout.addWidget(label)
+
+        # Text input area
+        self.text_area = QPlainTextEdit()
+        self.text_area.setPlaceholderText(
+            "Paste XG analysis or position IDs here...\n\n"
+            "Examples:\n"
+            "• Full XG analysis (Ctrl+C from eXtreme Gammon)\n"
+            "• XGID, OGID, or GNUID position IDs (one per line)\n"
+            "• Mixed formats supported - auto-detected"
+        )
+
+        # Use fixed-width font for better XGID readability
+        font = QFont("Consolas", 10)
+        if not font.exactMatch():
+            font = QFont("Courier New", 10)
+        self.text_area.setFont(font)
+
+        self.text_area.setLineWrapMode(QPlainTextEdit.NoWrap)
+        self.text_area.setTabChangesFocus(True)
+        self.text_area.setMinimumHeight(300)
+
+        # Dark theme styling
+        self.text_area.setStyleSheet("""
+            QPlainTextEdit {
+                background-color: #1e1e2e;
+                color: #cdd6f4;
+                border: 2px solid #313244;
+                border-radius: 8px;
+                padding: 12px;
+                selection-background-color: #585b70;
+            }
+            QPlainTextEdit:focus {
+                border-color: #89b4fa;
+            }
+        """)
+
+        self.text_area.textChanged.connect(self._on_text_changed)
+        layout.addWidget(self.text_area, stretch=1)
+
+        # Feedback container (outer wrapper with rounded corners)
+        self.feedback_container = QWidget()
+        self.feedback_container.setStyleSheet("""
+            QWidget {
+                background-color: #313244;
+                border-radius: 6px;
+            }
+        """)
+        self.feedback_container.setVisible(False)
+
+        container_layout = QHBoxLayout(self.feedback_container)
+        container_layout.setContentsMargins(0, 0, 0, 0)
+        container_layout.setSpacing(0)
+
+        # Left accent bar (separate widget - avoids Qt border-left + border-radius bug)
+        self.accent_bar = QWidget()
+        self.accent_bar.setFixedWidth(4)
+        self.accent_bar.setStyleSheet("background-color: #6c7086;")
+        container_layout.addWidget(self.accent_bar)
+
+        # Inner content panel
+        self.feedback_panel = QWidget()
+        self.feedback_panel.setStyleSheet("background-color: transparent;")
+        container_layout.addWidget(self.feedback_panel, stretch=1)
+
+        feedback_layout = QHBoxLayout(self.feedback_panel)
+        feedback_layout.setContentsMargins(12, 12, 12, 12)
+        feedback_layout.setSpacing(12)  # Add spacing between icon and text
+
+        # Icon
+        self.feedback_icon = QLabel()
+        self.feedback_icon.setPixmap(qta.icon('fa6s.circle-info', color='#60a5fa').pixmap(20, 20))
+        self.feedback_icon.setMinimumSize(20, 20)  # Minimum size instead of fixed
+        self.feedback_icon.setAlignment(Qt.AlignCenter)
+        self.feedback_icon.setScaledContents(False)  # Prevent pixmap stretching/artifacts
+        feedback_layout.addWidget(self.feedback_icon, alignment=Qt.AlignTop)
+
+        # Text content
+        text_content = QVBoxLayout()
+        text_content.setSpacing(4)
+
+        self.feedback_title = QLabel()
+        self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px;")
+        text_content.addWidget(self.feedback_title)
+
+        self.feedback_detail = QLabel()
+        self.feedback_detail.setStyleSheet("font-size: 12px; color: #a6adc8;")
+        self.feedback_detail.setWordWrap(True)
+        text_content.addWidget(self.feedback_detail)
+
+        feedback_layout.addLayout(text_content, stretch=1)
+
+        # Override button
+        self.override_btn = QPushButton("Override...")
+        self.override_btn.setVisible(False)
+        self.override_btn.setStyleSheet("""
+            QPushButton {
+                background-color: #45475a;
+                color: #cdd6f4;
+                border: none;
+                padding: 6px 12px;
+                border-radius: 4px;
+                font-size: 11px;
+            }
+            QPushButton:hover {
+                background-color: #585b70;
+            }
+        """)
+        self.override_btn.setCursor(Qt.PointingHandCursor)
+        feedback_layout.addWidget(self.override_btn, alignment=Qt.AlignTop)
+
+        layout.addWidget(self.feedback_container)
+
+    def _on_text_changed(self):
+        """Handle text change (debounced)."""
+        # Cancel previous timer, start new one
+        self.detection_timer.stop()
+        self.detection_timer.start(500)  # 500ms debounce
+
+    def _run_detection(self):
+        """Run format detection (after debounce)."""
+        text = self.text_area.toPlainText()
+
+        if not text.strip():
+            self.feedback_container.setVisible(False)
+            self.last_result = None
+            return
+
+        result = self.detector.detect(text)
+        self.last_result = result
+        self._update_feedback_ui(result)
+        self.format_detected.emit(result)
+
+    def _set_feedback_icon(self, icon_name: str, color: str):
+        """Helper to properly set feedback icon."""
+        self.feedback_icon.clear()  # Clear old pixmap first
+        self.feedback_icon.setPixmap(qta.icon(icon_name, color=color).pixmap(20, 20))
+
+    def _set_feedback_style(self, bg_color: str, accent_color: str):
+        """Helper to properly set feedback panel style (avoids Qt border-left + border-radius bug)."""
+        self.feedback_container.setStyleSheet(f"""
+            QWidget {{
+                background-color: {bg_color};
+                border-radius: 6px;
+            }}
+        """)
+        self.accent_bar.setStyleSheet(f"background-color: {accent_color};")
+
+    def _update_feedback_ui(self, result: DetectionResult):
+        """Update feedback panel with detection result."""
+        self.feedback_container.setVisible(True)
+
+        # Update icon and styling based on result
+        if result.format == InputFormat.POSITION_IDS:
+            if result.warnings:
+                # Warning state (GnuBG not configured)
+                self._set_feedback_icon('fa6s.triangle-exclamation', '#fab387')
+                self._set_feedback_style('#2e2416', '#f9e2af')
+                self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #f9e2af;")
+                self.feedback_title.setText(f"{result.details}")
+                self.feedback_detail.setText(
+                    result.warnings[0] + "\nConfigure GnuBG in Settings to analyze positions."
+                )
+            else:
+                # Success state
+                self._set_feedback_icon('fa6s.circle-check', '#a6e3a1')
+                self._set_feedback_style('#1e2d1f', '#a6e3a1')
+                self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #a6e3a1;")
+                self.feedback_title.setText(f"{result.details}")
+
+                # Calculate estimated time
+                est_seconds = result.count * 5  # ~5 seconds per position
+                self.feedback_detail.setText(
+                    f"Will analyze with GnuBG ({self.settings.gnubg_analysis_ply}-ply)\n"
+                    f"Estimated time: ~{est_seconds} seconds"
+                )
+
+        elif result.format == InputFormat.FULL_ANALYSIS:
+            # Success state (blue)
+            self._set_feedback_icon('fa6s.circle-check', '#89b4fa')
+            self._set_feedback_style('#1e2633', '#89b4fa')
+            self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #89b4fa;")
+            self.feedback_title.setText(f"{result.details}")
+
+            # Show preview of first position if available
+            preview_text = "Ready to add to export list"
+            if result.position_previews:
+                preview_text += f"\nFirst position: {result.position_previews[0]}"
+
+            if result.warnings:
+                preview_text += f"\n{result.warnings[0]}"
+
+            self.feedback_detail.setText(preview_text)
+
+        else:
+            # Unknown/error state
+            self._set_feedback_icon('fa6s.triangle-exclamation', '#fab387')
+            self._set_feedback_style('#2e2416', '#fab387')
+            self.feedback_title.setStyleSheet("font-weight: 600; font-size: 13px; color: #fab387;")
+            self.feedback_title.setText(f"{result.details}")
+
+            warning_text = "Paste XGID/OGID/GNUID or full XG analysis text"
+            if result.warnings:
+                warning_text = "\n".join(result.warnings)
+
+            self.feedback_detail.setText(warning_text)
+
+    def get_text(self) -> str:
+        """Get current input text."""
+        return self.text_area.toPlainText()
+
+    def clear_text(self):
+        """Clear input text."""
+        self.text_area.clear()
+        self.feedback_container.setVisible(False)
+        self.last_result = None
+
+    def get_last_result(self) -> DetectionResult:
+        """Get last detection result."""
+        return self.last_result

ankigammon/models.py

@@ -0,0 +1,322 @@
+"""Data models for backgammon positions, moves, and decisions."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Tuple
+
+
+class Player(Enum):
+    """Player identifier."""
+    X = "X"  # Top player
+    O = "O"  # Bottom player
+
+
+class CubeState(Enum):
+    """Doubling cube state."""
+    CENTERED = "centered"
+    X_OWNS = "x_owns"
+    O_OWNS = "o_owns"
+
+
+class DecisionType(Enum):
+    """Type of decision."""
+    CHECKER_PLAY = "checker_play"
+    CUBE_ACTION = "cube_action"
+
+
+@dataclass
+class Position:
+    """
+    Represents a backgammon position.
+
+    Board representation:
+    - points[0] = bar for X (top player)
+    - points[1-24] = board points (point 24 is X's home, point 1 is O's home)
+    - points[25] = bar for O (bottom player)
+
+    Positive numbers = X checkers, negative numbers = O checkers
+    """
+    points: List[int] = field(default_factory=lambda: [0] * 26)
+    x_off: int = 0  # Checkers borne off by X
+    o_off: int = 0  # Checkers borne off by O
+
+    def __post_init__(self):
+        """Validate position."""
+        if len(self.points) != 26:
+            raise ValueError("Position must have exactly 26 points (0=X bar, 1-24=board, 25=O bar)")
+
+    @classmethod
+    def from_xgid(cls, xgid: str) -> 'Position':
+        """
+        Parse a position from XGID format.
+        XGID format: e.g., "XGID=-b----E-C---eE---c-e----B-:1:0:1:63:0:0:0:0:10"
+        """
+        # Import here to avoid circular dependency
+        from ankigammon.utils.xgid import parse_xgid
+        position, _ = parse_xgid(xgid)
+        return position
+
+    @classmethod
+    def from_ogid(cls, ogid: str) -> 'Position':
+        """
+        Parse a position from OGID format.
+        OGID format: e.g., "11jjjjjhhhccccc:ooddddd88866666:N0N::W:IW:0:0:1:0"
+        """
+        # Import here to avoid circular dependency
+        from ankigammon.utils.ogid import parse_ogid
+        position, _ = parse_ogid(ogid)
+        return position
+
+    @classmethod
+    def from_gnuid(cls, gnuid: str) -> 'Position':
+        """
+        Parse a position from GNUID format.
+        GNUID format: e.g., "4HPwATDgc/ABMA:8IhuACAACAAE"
+        """
+        # Import here to avoid circular dependency
+        from ankigammon.utils.gnuid import parse_gnuid
+        position, _ = parse_gnuid(gnuid)
+        return position
+
+    def to_xgid(
+        self,
+        cube_value: int = 1,
+        cube_owner: 'CubeState' = None,
+        dice: Optional[Tuple[int, int]] = None,
+        on_roll: 'Player' = None,
+        score_x: int = 0,
+        score_o: int = 0,
+        match_length: int = 0,
+        crawford_jacoby: int = 0,
+    ) -> str:
+        """Convert position to XGID format."""
+        # Import here to avoid circular dependency
+        from ankigammon.utils.xgid import encode_xgid
+        if cube_owner is None:
+            cube_owner = CubeState.CENTERED
+        if on_roll is None:
+            on_roll = Player.O
+        return encode_xgid(
+            self,
+            cube_value=cube_value,
+            cube_owner=cube_owner,
+            dice=dice,
+            on_roll=on_roll,
+            score_x=score_x,
+            score_o=score_o,
+            match_length=match_length,
+            crawford_jacoby=crawford_jacoby,
+        )
+
+    def to_ogid(
+        self,
+        cube_value: int = 1,
+        cube_owner: 'CubeState' = None,
+        cube_action: str = 'N',
+        dice: Optional[Tuple[int, int]] = None,
+        on_roll: 'Player' = None,
+        game_state: str = '',
+        score_x: int = 0,
+        score_o: int = 0,
+        match_length: Optional[int] = None,
+        match_modifier: str = '',
+        only_position: bool = False,
+    ) -> str:
+        """Convert position to OGID format."""
+        # Import here to avoid circular dependency
+        from ankigammon.utils.ogid import encode_ogid
+        if cube_owner is None:
+            cube_owner = CubeState.CENTERED
+        return encode_ogid(
+            self,
+            cube_value=cube_value,
+            cube_owner=cube_owner,
+            cube_action=cube_action,
+            dice=dice,
+            on_roll=on_roll,
+            game_state=game_state,
+            score_x=score_x,
+            score_o=score_o,
+            match_length=match_length,
+            match_modifier=match_modifier,
+            only_position=only_position,
+        )
+
+    def to_gnuid(
+        self,
+        cube_value: int = 1,
+        cube_owner: 'CubeState' = None,
+        dice: Optional[Tuple[int, int]] = None,
+        on_roll: 'Player' = None,
+        score_x: int = 0,
+        score_o: int = 0,
+        match_length: int = 0,
+        crawford: bool = False,
+        only_position: bool = False,
+    ) -> str:
+        """Convert position to GNUID format."""
+        # Import here to avoid circular dependency
+        from ankigammon.utils.gnuid import encode_gnuid
+        if cube_owner is None:
+            cube_owner = CubeState.CENTERED
+        if on_roll is None:
+            on_roll = Player.X
+        return encode_gnuid(
+            self,
+            cube_value=cube_value,
+            cube_owner=cube_owner,
+            dice=dice,
+            on_roll=on_roll,
+            score_x=score_x,
+            score_o=score_o,
+            match_length=match_length,
+            crawford=crawford,
+            only_position=only_position,
+        )
+
+    def copy(self) -> 'Position':
+        """Create a deep copy of the position."""
+        return Position(
+            points=self.points.copy(),
+            x_off=self.x_off,
+            o_off=self.o_off
+        )
+
+
+@dataclass
+class Move:
+    """
+    Represents a candidate move with its analysis.
+    """
+    notation: str  # e.g., "13/9 6/5" or "double/take" (for MCQ and answer display)
+    equity: float  # Equity of this move
+    error: float = 0.0  # Error compared to best move (0 for best move)
+    rank: int = 1  # Rank among all candidates (including synthetic, 1 = best)
+    xg_rank: Optional[int] = None  # Order in XG's "Cubeful Equities:" section (1-3)
+    xg_error: Optional[float] = None  # Error as shown by XG (relative to first option in Cubeful Equities)
+    xg_notation: Optional[str] = None  # Original notation from XG (e.g., "No double" not "No double/Take")
+    resulting_position: Optional[Position] = None  # Position after this move (if available)
+    from_xg_analysis: bool = True  # True if from XG's analysis, False if synthetically generated
+    was_played: bool = False  # True if this was the move actually played in the game
+    # Winning chances percentages
+    player_win_pct: Optional[float] = None  # Player winning percentage (e.g., 52.68)
+    player_gammon_pct: Optional[float] = None  # Player gammon percentage (e.g., 14.35)
+    player_backgammon_pct: Optional[float] = None  # Player backgammon percentage (e.g., 0.69)
+    opponent_win_pct: Optional[float] = None  # Opponent winning percentage (e.g., 47.32)
+    opponent_gammon_pct: Optional[float] = None  # Opponent gammon percentage (e.g., 12.42)
+    opponent_backgammon_pct: Optional[float] = None  # Opponent backgammon percentage (e.g., 0.55)
+
+    def __str__(self) -> str:
+        """Human-readable representation."""
+        if self.rank == 1:
+            return f"{self.notation} (Equity: {self.equity:.3f})"
+        else:
+            return f"{self.notation} (Equity: {self.equity:.3f}, Error: {self.error:.3f})"
+
+
+@dataclass
+class Decision:
+    """
+    Represents a single decision point from XG analysis.
+    """
+    # Position information
+    position: Position
+    position_image_path: Optional[str] = None  # Path to board image (from HTML export)
+    xgid: Optional[str] = None
+
+    # Game context
+    on_roll: Player = Player.O
+    dice: Optional[Tuple[int, int]] = None  # None for cube decisions
+    score_x: int = 0
+    score_o: int = 0
+    match_length: int = 0  # 0 for money games
+    crawford: bool = False  # True if Crawford game (no doubling allowed)
+    cube_value: int = 1
+    cube_owner: CubeState = CubeState.CENTERED
+
+    # Decision analysis
+    decision_type: DecisionType = DecisionType.CHECKER_PLAY
+    candidate_moves: List[Move] = field(default_factory=list)
+
+    # Winning chances percentages (for cube decisions)
+    player_win_pct: Optional[float] = None
+    player_gammon_pct: Optional[float] = None
+    player_backgammon_pct: Optional[float] = None
+    opponent_win_pct: Optional[float] = None
+    opponent_gammon_pct: Optional[float] = None
+    opponent_backgammon_pct: Optional[float] = None
+
+    # Source metadata
+    source_file: Optional[str] = None
+    game_number: Optional[int] = None
+    move_number: Optional[int] = None
+
+    # User annotations
+    note: Optional[str] = None  # User's note/comment/explanation for this position
+
+    def get_best_move(self) -> Optional[Move]:
+        """Get the best move (rank 1)."""
+        for move in self.candidate_moves:
+            if move.rank == 1:
+                return move
+        return self.candidate_moves[0] if self.candidate_moves else None
+
+    def get_short_display_text(self) -> str:
+        """Get short display text for list views."""
+        # Build score/game type string
+        if self.match_length > 0:
+            # Match play - show score and match info
+            score = f"{self.score_x}-{self.score_o} of {self.match_length}"
+            if self.crawford:
+                score += " Crawford"
+        else:
+            # Money game - just show "Money"
+            score = "Money"
+
+        if self.decision_type == DecisionType.CHECKER_PLAY:
+            dice_str = f"{self.dice[0]}{self.dice[1]}" if self.dice else "—"
+            return f"Checker | {dice_str} | {score}"
+        else:
+            # Cube decision - no dice to show
+            return f"Cube | {score}"
+
+    def get_metadata_text(self) -> str:
+        """Get formatted metadata for card display."""
+        dice_str = f"{self.dice[0]}{self.dice[1]}" if self.dice else "N/A"
+
+        # Show em dash when cube is centered, otherwise just show value
+        if self.cube_owner == CubeState.CENTERED:
+            cube_str = "—"
+        else:
+            cube_str = f"{self.cube_value}"
+
+        # Map Player enum to color names
+        # Player.X = TOP player (plays with white checkers from top)
+        # Player.O = BOTTOM player (plays with black checkers from bottom)
+        player_name = "White" if self.on_roll == Player.X else "Black"
+
+        # Build metadata string based on game type
+        if self.match_length > 0:
+            # Match play - show score and match info
+            match_str = f"{self.match_length}pt"
+            if self.crawford:
+                match_str += " (Crawford)"
+            return (
+                f"{player_name} | "
+                f"Dice: {dice_str} | "
+                f"Score: {self.score_x}-{self.score_o} | "
+                f"Cube: {cube_str} | "
+                f"Match: {match_str}"
+            )
+        else:
+            # Money game - don't show score, just "Money"
+            return (
+                f"{player_name} | "
+                f"Dice: {dice_str} | "
+                f"Cube: {cube_str} | "
+                f"Money"
+            )
+
+    def __str__(self) -> str:
+        """Human-readable representation."""
+        return f"Decision({self.decision_type.value}, {self.get_metadata_text()})"

ankigammon/parsers/__init__.py

@@ -0,0 +1,7 @@
+"""Parsers for XG file formats and GnuBG output."""
+
+from ankigammon.parsers.xg_text_parser import XGTextParser
+from ankigammon.parsers.gnubg_parser import GNUBGParser
+from ankigammon.parsers.xg_binary_parser import XGBinaryParser
+
+__all__ = ["XGTextParser", "GNUBGParser", "XGBinaryParser"]