feat: added piece_count function instead of chess.popcount(board.occupied)

Author: Litschi21

CHANGELOG.rst

@@ -1,6 +1,15 @@
 Changelog for python-chess
 ==========================
 
+New in unreleased (27th Mar 2026)
+---------------------------------
+
+Bugfixes:
+* Fixed typo in README.rst.
+
+Changes:
+* Added ``board.piece_count`` function.
+
 New in v1.11.2 (25th Feb 2025)
 ------------------------------
 

chess/__init__.py

@@ -841,6 +841,9 @@ def clear_board(self) -> None:
         :class:`~chess.Board` also clears the move stack.
         """
         self._clear_board()
+    
+    def piece_count(self) -> int:
+        return popcount(self.occupied)
 
     def pieces_mask(self, piece_type: PieceType, color: Color) -> Bitboard:
         if piece_type == PAWN:

chess/gaviota.py

@@ -1519,8 +1519,8 @@ def probe_dtm(self, board: chess.Board) -> int:
             raise KeyError(f"gaviota tables do not contain positions with castling rights: {board.fen()}")
 
         # Supports only up to 5 pieces.
-        if chess.popcount(board.occupied) > 5:
-            raise KeyError(f"gaviota tables support up to 5 pieces, not {chess.popcount(board.occupied)}: {board.fen()}")
+        if board.piece_count() > 5:
+            raise KeyError(f"gaviota tables support up to 5 pieces, not {board.piece_count()}: {board.fen()}")
 
         # KvK is a draw.
         if board.occupied == board.kings:
@@ -1885,8 +1885,8 @@ def _probe_hard(self, board: chess.Board, wdl_only: bool = False) -> int:
         if board.castling_rights:
             raise KeyError(f"gaviota tables do not contain positions with castling rights: {board.fen()}")
 
-        if chess.popcount(board.occupied) > 5:
-            raise KeyError(f"gaviota tables support up to 5 pieces, not {chess.popcount(board.occupied)}: {board.fen()}")
+        if board.piece_count() > 5:
+            raise KeyError(f"gaviota tables support up to 5 pieces, not {board.piece_count()}: {board.fen()}")
 
         stm = ctypes.c_uint(0 if board.turn == chess.WHITE else 1)
         ep_square = ctypes.c_uint(board.ep_square if board.ep_square else 64)

chess/syzygy.py

@@ -1548,8 +1548,8 @@ def probe_wdl_table(self, board: chess.Board) -> int:
         try:
             table = typing.cast(WdlTable, self.wdl[key])
         except KeyError:
-            if chess.popcount(board.occupied) > TBPIECES:
-                raise KeyError(f"syzygy tables support up to {TBPIECES} pieces, not {chess.popcount(board.occupied)}: {board.fen()}")
+            if board.piece_count() > TBPIECES:
+                raise KeyError(f"syzygy tables support up to {TBPIECES} pieces, not {board.piece_count()}: {board.fen()}")
             raise MissingTableError(f"did not find wdl table {key}")
 
         self._bump_lru(table)
@@ -1567,8 +1567,8 @@ def probe_ab(self, board: chess.Board, alpha: int, beta: int, threats: bool = Fa
         # positions that have more pieces than the maximum number of supported
         # pieces. We artificially limit this to one additional level, to
         # make sure search remains somewhat bounded.
-        if chess.popcount(board.occupied) > TBPIECES + 1:
-            raise KeyError(f"syzygy tables support up to {TBPIECES} pieces, not {chess.popcount(board.occupied)}: {board.fen()}")
+        if board.piece_count() > TBPIECES + 1:
+            raise KeyError(f"syzygy tables support up to {TBPIECES} pieces, not {board.piece_count()}: {board.fen()}")
 
         # Special case: Variant with compulsory captures.
         if self.variant.captures_compulsory:
@@ -1613,7 +1613,7 @@ def sprobe_ab(self, board: chess.Board, alpha: int, beta: int, threats: bool = F
 
         threats_found = False
 
-        if threats or chess.popcount(board.occupied) >= 6:
+        if threats or board.piece_count() >= 6:
             for threat in board.generate_legal_moves(~board.pawns):
                 board.push(threat)
                 try:

test.py

@@ -1220,7 +1220,7 @@ def test_clear(self):
         self.assertFalse(board.ep_square)
 
         self.assertFalse(board.piece_at(chess.E1))
-        self.assertEqual(chess.popcount(board.occupied), 0)
+        self.assertEqual(board.piece_count(), 0)
 
     def test_threefold_repetition(self):
         board = chess.Board()