Use typing_extensions.Self

Author: niklasf

chess/__init__.py

@@ -25,7 +25,7 @@
 from typing import ClassVar, Callable, Counter, Dict, Generic, Hashable, Iterable, Iterator, List, Literal, Mapping, Optional, SupportsInt, Tuple, Type, TypeVar, Union
 
 if typing.TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing_extensions import Self, TypeAlias
 
 
 EnPassantSpec = Literal["legal", "fen", "xfen"]
@@ -1455,7 +1455,7 @@ def apply_transform(self, f: Callable[[Bitboard], Bitboard]) -> None:
         self.occupied = f(self.occupied)
         self.promoted = f(self.promoted)
 
-    def transform(self: BaseBoardT, f: Callable[[Bitboard], Bitboard]) -> BaseBoardT:
+    def transform(self, f: Callable[[Bitboard], Bitboard]) -> Self:
         """
         Returns a transformed copy of the board (without move stack)
         by applying a bitboard transformation function.
@@ -1473,11 +1473,11 @@ def transform(self: BaseBoardT, f: Callable[[Bitboard], Bitboard]) -> BaseBoardT
         board.apply_transform(f)
         return board
 
-    def apply_mirror(self: BaseBoardT) -> None:
+    def apply_mirror(self) -> None:
         self.apply_transform(flip_vertical)
         self.occupied_co[WHITE], self.occupied_co[BLACK] = self.occupied_co[BLACK], self.occupied_co[WHITE]
 
-    def mirror(self: BaseBoardT) -> BaseBoardT:
+    def mirror(self) -> Self:
         """
         Returns a mirrored copy of the board (without move stack).
 
@@ -1491,7 +1491,7 @@ def mirror(self: BaseBoardT) -> BaseBoardT:
         board.apply_mirror()
         return board
 
-    def copy(self: BaseBoardT) -> BaseBoardT:
+    def copy(self) -> Self:
         """Creates a copy of the board."""
         board = type(self)(None)
 
@@ -1509,10 +1509,10 @@ def copy(self: BaseBoardT) -> BaseBoardT:
 
         return board
 
-    def __copy__(self: BaseBoardT) -> BaseBoardT:
+    def __copy__(self) -> Self:
         return self.copy()
 
-    def __deepcopy__(self: BaseBoardT, memo: Dict[int, object]) -> BaseBoardT:
+    def __deepcopy__(self, memo: Dict[int, object]) -> Self:
         board = self.copy()
         memo[id(self)] = board
         return board
@@ -1694,7 +1694,7 @@ class Board(BaseBoard):
     manipulation.
     """
 
-    def __init__(self: BoardT, fen: Optional[str] = STARTING_FEN, *, chess960: bool = False) -> None:
+    def __init__(self, fen: Optional[str] = STARTING_FEN, *, chess960: bool = False) -> None:
         BaseBoard.__init__(self, None)
 
         self.chess960 = chess960
@@ -1786,7 +1786,7 @@ def clear_stack(self) -> None:
         self.move_stack.clear()
         self._stack.clear()
 
-    def root(self: BoardT) -> BoardT:
+    def root(self) -> Self:
         """Returns a copy of the root position."""
         if self._stack:
             board = type(self)(None, chess960=self.chess960)
@@ -2307,7 +2307,7 @@ def is_repetition(self, count: int = 3) -> bool:
     def _push_capture(self, move: Move, capture_square: Square, piece_type: PieceType, was_promoted: bool) -> None:
         pass
 
-    def push(self: BoardT, move: Move) -> None:
+    def push(self, move: Move) -> None:
         """
         Updates the position with the given *move* and puts it onto the
         move stack.
@@ -2428,7 +2428,7 @@ def push(self: BoardT, move: Move) -> None:
         # Swap turn.
         self.turn = not self.turn
 
-    def pop(self: BoardT) -> Move:
+    def pop(self) -> Move:
         """
         Restores the previous position and returns the last move from the stack.
 
@@ -2838,7 +2838,7 @@ def _validate_epd_opcode(self, opcode: str) -> None:
             if blacklisted in opcode:
                 raise ValueError(f"invalid character {blacklisted!r} in epd opcode: {opcode!r}")
 
-    def _parse_epd_ops(self: BoardT, operation_part: str, make_board: Callable[[], BoardT]) -> Dict[str, Union[None, str, int, float, Move, List[Move]]]:
+    def _parse_epd_ops(self, operation_part: str, make_board: Callable[[], Self]) -> Dict[str, Union[None, str, int, float, Move, List[Move]]]:
         operations: Dict[str, Union[None, str, int, float, Move, List[Move]]] = {}
         state = "opcode"
         opcode = ""
@@ -3831,16 +3831,16 @@ def apply_transform(self, f: Callable[[Bitboard], Bitboard]) -> None:
         self.ep_square = None if self.ep_square is None else msb(f(BB_SQUARES[self.ep_square]))
         self.castling_rights = f(self.castling_rights)
 
-    def transform(self: BoardT, f: Callable[[Bitboard], Bitboard]) -> BoardT:
+    def transform(self, f: Callable[[Bitboard], Bitboard]) -> Self:
         board = self.copy(stack=False)
         board.apply_transform(f)
         return board
 
-    def apply_mirror(self: BoardT) -> None:
+    def apply_mirror(self) -> None:
         super().apply_mirror()
         self.turn = not self.turn
 
-    def mirror(self: BoardT) -> BoardT:
+    def mirror(self) -> Self:
         """
         Returns a mirrored copy of the board.
 
@@ -3855,7 +3855,7 @@ def mirror(self: BoardT) -> BoardT:
         board.apply_mirror()
         return board
 
-    def copy(self: BoardT, *, stack: Union[bool, int] = True) -> BoardT:
+    def copy(self, *, stack: Union[bool, int] = True) -> Self:
         """
         Creates a copy of the board.
 

chess/engine.py

@@ -970,7 +970,7 @@ def pipe_data_received(self, fd: int, data: Union[bytes, str]) -> None:
     def error_line_received(self, line: str) -> None:
         LOGGER.warning("%s: stderr >> %s", self, line)
 
-    def _line_received(self: Protocol, line: str) -> None:
+    def _line_received(self, line: str) -> None:
         LOGGER.debug("%s: >> %s", self, line)
 
         self.line_received(line)

chess/pgn.py

@@ -15,6 +15,9 @@
 from typing import Any, Callable, Dict, Generic, Iterable, Iterator, List, Literal, Mapping, MutableMapping, Set, TextIO, Tuple, Type, TypeVar, Optional, Union
 from chess import Color, Square
 
+if typing.TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 LOGGER = logging.getLogger(__name__)
 
@@ -1014,10 +1017,10 @@ def __iter__(self) -> Iterator[str]:
     def __len__(self) -> int:
         return len(self._tag_roster) + len(self._others)
 
-    def copy(self: HeadersT) -> HeadersT:
+    def copy(self) -> Self:
         return type(self)(self)
 
-    def __copy__(self: HeadersT) -> HeadersT:
+    def __copy__(self) -> Self:
         return self.copy()
 
     def __repr__(self) -> str:

chess/syzygy.py

@@ -14,6 +14,9 @@
 from types import TracebackType
 from typing import Deque, Dict, Iterable, Iterator, List, Optional, Set, Tuple, Type, TypeVar, Union
 
+if typing.TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 UINT64_BE = struct.Struct(">Q")
 UINT32 = struct.Struct("<I")
@@ -532,8 +535,6 @@ class PawnFileDataDtz:
     norm: List[int]
 
 
-TableT = TypeVar("TableT", bound="Table")
-
 class Table:
     size: List[int]
 
@@ -1025,7 +1026,7 @@ def close(self) -> None:
                     self.data.close()
                     self.data = None
 
-    def __enter__(self: TableT) -> TableT:
+    def __enter__(self) -> Self:
         return self
 
     def __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType]) -> None:

chess/variant.py

@@ -2,9 +2,13 @@
 
 import chess
 import itertools
+import typing
 
 from typing import Dict, Generic, Hashable, Iterable, Iterator, List, Optional, Type, TypeVar, Union
 
+if typing.TYPE_CHECKING:
+    from typing_extensions import Self
+
 
 class SuicideBoard(chess.Board):
 
@@ -795,23 +799,23 @@ def _transposition_key(self) -> Hashable:
         return (super()._transposition_key(),
                 self.remaining_checks[chess.WHITE], self.remaining_checks[chess.BLACK])
 
-    def copy(self: ThreeCheckBoardT, stack: Union[bool, int] = True) -> ThreeCheckBoardT:
+    def copy(self, stack: Union[bool, int] = True) -> Self:
         board = super().copy(stack=stack)
         board.remaining_checks = self.remaining_checks.copy()
         if stack:
             stack = len(self.move_stack) if stack is True else stack
             board._three_check_stack = self._three_check_stack[-stack:]
         return board
 
-    def root(self: ThreeCheckBoardT) -> ThreeCheckBoardT:
+    def root(self) -> Self:
         if self._three_check_stack:
             board = super().root()
             self._three_check_stack[0].restore(board)
             return board
         else:
             return self.copy(stack=False)
 
-    def mirror(self: ThreeCheckBoardT) -> ThreeCheckBoardT:
+    def mirror(self) -> Self:
         board = super().mirror()
         board.remaining_checks[chess.WHITE] = self.remaining_checks[chess.BLACK]
         board.remaining_checks[chess.BLACK] = self.remaining_checks[chess.WHITE]
@@ -865,7 +869,7 @@ def __len__(self) -> int:
     def __repr__(self) -> str:
         return f"CrazyhousePocket('{self}')"
 
-    def copy(self: CrazyhousePocketT) -> CrazyhousePocketT:
+    def copy(self) -> Self:
         """Returns a copy of this pocket."""
         pocket = type(self)()
         pocket._pieces = self._pieces[:]
@@ -1047,7 +1051,7 @@ def epd(self, shredder: bool = False, en_passant: chess.EnPassantSpec = "legal",
         board_part, info_part = epd.split(" ", 1)
         return f"{board_part}[{str(self.pockets[chess.WHITE]).upper()}{self.pockets[chess.BLACK]}] {info_part}"
 
-    def copy(self: CrazyhouseBoardT, stack: Union[bool, int] = True) -> CrazyhouseBoardT:
+    def copy(self, stack: Union[bool, int] = True) -> Self:
         board = super().copy(stack=stack)
         board.pockets[chess.WHITE] = self.pockets[chess.WHITE].copy()
         board.pockets[chess.BLACK] = self.pockets[chess.BLACK].copy()
@@ -1056,15 +1060,15 @@ def copy(self: CrazyhouseBoardT, stack: Union[bool, int] = True) -> CrazyhouseBo
             board._crazyhouse_stack = self._crazyhouse_stack[-stack:]
         return board
 
-    def root(self: CrazyhouseBoardT) -> CrazyhouseBoardT:
+    def root(self) -> Self:
         if self._crazyhouse_stack:
             board = super().root()
             self._crazyhouse_stack[0].restore(board)
             return board
         else:
             return self.copy(stack=False)
 
-    def mirror(self: CrazyhouseBoardT) -> CrazyhouseBoardT:
+    def mirror(self) -> Self:
         board = super().mirror()
         board.pockets[chess.WHITE] = self.pockets[chess.BLACK].copy()
         board.pockets[chess.BLACK] = self.pockets[chess.WHITE].copy()