pls make this program emit on of the standard windows sounds when it cant find a 100% safe spot and all available are 50/50. dont change anything else. i want standard windows sound bcuz im too lazy to download a sound myself and putting it in same dir and so on. also it should not make a move in that case obviously. code:
class MinesweeperAI:
    def __init__(self, grid: List[List[str]]):
        """
        Initialize the Minesweeper AI with the current grid.
        """
        self.grid = grid
        self.height = len(grid)
        self.width = len(grid[0]) if self.height > 0 else 0
        self.safe_cells: Set[Tuple[int, int]] = set()
        self.mine_cells: Set[Tuple[int, int]] = set()
        self.cells_to_consider: Set[Tuple[int, int]] = set()
        self._init_knowledge()

    def _init_knowledge(self):
        """
        Initialize knowledge based on the current grid.
        """
        for r in range(self.height):
            for c in range(self.width):
                cell = self.grid[r][c]
                if cell.isdigit():
                    count = int(cell)
                    neighbors = self._get_neighbors(r, c)
                    covered = [n for n in neighbors if self.grid[n[0]][n[1]] == '□']
                    if count == 0:
                        # All neighboring covered cells are safe
                        for n in neighbors:
                            if self.grid[n[0]][n[1]] == '□' and n not in self.mine_cells:
                                self.safe_cells.add(n)
                    elif count == len(covered):
                        # All neighboring covered cells are mines
                        for n in covered:
                            if n not in self.mine_cells:
                                self.mine_cells.add(n)
        self.cells_to_consider = self.safe_cells.copy()

    def _get_neighbors(self, row: int, col: int) -> Set[Tuple[int, int]]:
        """
        Get all valid neighboring cells for a given cell.
        """
        neighbors = set()
        for dr in [-1, 0, 1]:
            for dc in [-1, 0, 1]:
                if dr == 0 and dc == 0:
                    continue
                nr, nc = row + dr, col + dc
                if 0 <= nr < self.height and 0 <= nc < self.width:
                    neighbors.add((nr, nc))
        return neighbors

    def _update_knowledge(self):
        """
        Update the knowledge base by inferring new safe cells or mines.
        """
        changed = True
        while changed:
            changed = False
            for r in range(self.height):
                for c in range(self.width):
                    cell = self.grid[r][c]
                    if not cell.isdigit():
                        continue
                    count = int(cell)
                    neighbors = self._get_neighbors(r, c)
                    flagged = len([n for n in neighbors if n in self.mine_cells])
                    covered = [
                        n for n in neighbors
                        if self.grid[n[0]][n[1]] == '□' and n not in self.mine_cells
                    ]
                    remaining = count - flagged
                    if remaining == 0:
                        # All covered cells are safe
                        for n in covered:
                            if n not in self.safe_cells:
                                self.safe_cells.add(n)
                                self.cells_to_consider.add(n)
                                changed = True
                    elif remaining == len(covered):
                        # All covered cells are mines
                        for n in covered:
                            if n not in self.mine_cells:
                                self.mine_cells.add(n)
                                changed = True

    def make_move(self) -> Tuple[int, int]:
        """
        Decide the next move to uncover.
        Returns the coordinates (row, col) of the cell to uncover.
        """
        self._update_knowledge()
        if self.cells_to_consider:
            # Choose a known safe cell
            return self.cells_to_consider.pop()

        # If no safe cells are known, use probability to guess
        probabilities = self._calculate_probabilities()
        #if not probabilities:
        #    raise Exception("No moves left to make.")
        # Select the cell with the lowest probability of being a mine
        best_move = probabilities[0][0]  # probabilities are sorted ascendingly
        return best_move

    def _calculate_probabilities(self) -> List[Tuple[Tuple[int, int], float]]:
        """
        Calculate the probability of each covered cell containing a mine.
        Returns a list of tuples containing cell coordinates and their mine probability.
        """
        probabilities = {}
        # Assuming 'stage' is defined externally and accessible here
        if stage == 1:
            total_mines = 10
        elif stage == 2:
            total_mines = 19
        elif stage == 3:
            total_mines = 32
        elif stage == 4:
            total_mines = 47
        else:
            raise ValueError("Invalid stage value.")

        remaining_mines = total_mines - len(self.mine_cells)

        # Define covered_cells as cells that are still covered and not flagged as mines
        covered_cells = {
            (r, c)
            for r in range(self.height)
            for c in range(self.width)
            if self.grid[r][c] == '□' and (r, c) not in self.mine_cells
        }

        if not covered_cells:
            return []

        # Simple probability: remaining mines / remaining covered cells
        base_prob = remaining_mines / len(covered_cells) if len(covered_cells) > 0 else 1
        for cell in covered_cells:
            probabilities[cell] = base_prob

        # Refine probabilities based on the numbers
        for r in range(self.height):
            for c in range(self.width):
                cell = self.grid[r][c]
                if not cell.isdigit():
                    continue
                count = int(cell)
                neighbors = self._get_neighbors(r, c)
                flagged = len([n for n in neighbors if n in self.mine_cells])
                covered = [
                    n for n in neighbors
                    if self.grid[n[0]][n[1]] == '□' and n not in self.mine_cells
                ]
                remaining = count - flagged
                if remaining <= 0:
                    continue
                prob = remaining / len(covered) if len(covered) > 0 else 1
                for n in covered:
                    if n in probabilities:
                        # Take the maximum probability derived from all constraints
                        probabilities[n] = max(probabilities[n], prob)

        # Convert to list and sort by probability ascendingly
        prob_list = list(probabilities.items())
        prob_list.sort(key=lambda x: x[1])
        return prob_list

    def _estimate_total_mines(self) -> int:
        """
        Estimate the total number of mines in the grid.
        Adjust this method based on how total mines are defined.
        For this implementation, we'll assume a standard Minesweeper setting based on grid size.
        """
        # This method is no longer needed since total_mines are hardcoded based on 'stage'
        # You can remove this method if it's not being used elsewhere
        raise NotImplementedError("Total mines are determined by the 'stage' variable.")