pigeon-magnet-solver/pigeon_magnet_solver/board.py

from dataclasses import dataclass


@dataclass(kw_only=True, slots=True)
class Board:
    rows: list[str]
    buttons: tuple[int, ...]

    @classmethod
    @property
    def default_puzzle(cls) -> "Board":
        return cls(
            rows=["011", "011", "100", "x1x"],
            buttons=(3, 4, 5, 7),
        )

    @property
    def height(self) -> int:
        return len(self.rows)

    @property
    def width(self) -> int:
        if not self.rows:
            return 0
        else:
            return len(self.rows[0])

    def __post_init__(self) -> None:
        # check char set
        chars = {c for c in "".join(self.rows)}
        assert chars.issubset({"0", "1", "x"}), "Invalid char set!"

        # check defined width
        assert all(
            len(row) == self.width
            for row in self.rows
        ), "Inconsistent width!"

        # check buttons
        length = self.height * self.width
        assert all(
            button >= 0 and button < length
            for button in self.buttons
        ), "Invalid buttons!"

    def __str__(self) -> str:
        result = "\n".join(self.rows)
        result = result\
            .replace("0", "⚪️")\
            .replace("1", "🟢️")\
            .replace("x", "⚫️")
        return result

    @property
    def columns(self) -> tuple[str, ...]:
        return tuple(
            "".join(row[x] for row in self.rows)
            for x in range(self.width)
        )

    @property
    def binary_repr(self) -> tuple[int, ...]:
        return tuple(
            int(column.replace("x", "0")[::-1], base=2)
            for column in self.columns
        )

    @property
    def solution_class(self) -> tuple[int, ...]:
        return tuple(
            column.count("1")
            for column in self.columns
        )

    def click(self, index: int) -> None:
        pass