Updated str for pieces

Added unicode symbols for pieces string versions.

Signed-off-by: Serhii Horodilov <sgorodil@gmail.com>

Author: shorodilov

src/chess/piece.py

@@ -1,6 +1,12 @@
+"""
+Chess pieces implementations
+
+"""
+
 import logging
 from typing import Tuple
 
+from chess import symbols
 from chess.func import within_board
 
 logger = logging.getLogger(__name__)
@@ -9,17 +15,13 @@
 class Piece:
     """Chess piece model
 
-    :ivar name: the name of a piece (e.g. "king", "pawn")
-    :type name: str
     :ivar position: the position on a chess board
     :type position: tuple
     :ivar is_white: a flag indicating if a chess piece is white
     :type is_white: bool
 
     """
 
-    name: str = "piece"
-
     def __init__(self,
                  is_white: bool = True,
                  position: Tuple[int, int] = (0, 0)) -> None:
@@ -40,13 +42,6 @@ def __repr__(self) -> str:
 
         return f"{self.__class__.__name__}({self.is_white}, {self.position})"
 
-    def __str__(self) -> str:
-        """Return a string version of an instance"""
-
-        color = "white" if self.is_white else "black"
-
-        return f"{color} {self.name} at {self.position}"
-
     def swap_color(self) -> None:
         """Change the piece color to the opposite one"""
 
@@ -96,7 +91,8 @@ def get_delta(self, position: Tuple[int, int]) -> Tuple[int, int]:
 
 
 class King(Piece):  # pylint: disable=C0115
-    name = "king"
+    def __str__(self) -> str:
+        return symbols.WHITE_KING if self.is_white else symbols.BLACK_KING
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)
@@ -107,7 +103,8 @@ def can_move(self, position: Tuple[int, int]) -> bool:
 
 
 class Queen(Piece):  # pylint: disable=C0115
-    name = "queen"
+    def __str__(self) -> str:
+        return symbols.WHITE_QUEEN if self.is_white else symbols.BLACK_QUEEN
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)
@@ -118,7 +115,9 @@ def can_move(self, position: Tuple[int, int]) -> bool:
 
 
 class Bishop(Piece):  # pylint: disable=C0115
-    name = "bishop"
+
+    def __str__(self) -> str:
+        return symbols.WHITE_BISHOP if self.is_white else symbols.BLACK_BISHOP
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)
@@ -129,7 +128,9 @@ def can_move(self, position: Tuple[int, int]) -> bool:
 
 
 class Knight(Piece):  # pylint: disable=C0115
-    name = "knight"
+
+    def __str__(self) -> str:
+        return symbols.WHITE_KNIGHT if self.is_white else symbols.BLACK_KNIGHT
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)
@@ -140,7 +141,9 @@ def can_move(self, position: Tuple[int, int]) -> bool:
 
 
 class Rook(Piece):  # pylint: disable=C0115
-    name = "rook"
+
+    def __str__(self) -> str:
+        return symbols.WHITE_ROOK if self.is_white else symbols.BLACK_ROOK
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)
@@ -151,7 +154,9 @@ def can_move(self, position: Tuple[int, int]) -> bool:
 
 
 class Pawn(Piece):  # pylint: disable=C0115
-    name = "pawn"
+
+    def __str__(self) -> str:
+        return symbols.WHITE_PAWN if self.is_white else symbols.BLACK_PAWN
 
     def can_move(self, position: Tuple[int, int]) -> bool:
         delta_x, delta_y = self.get_delta(position)

src/chess/symbols.py

@@ -0,0 +1,16 @@
+"""
+Chess pieces unicode symbols
+"""
+
+WHITE_KING = chr(0x2654)
+BLACK_KING = chr(0x265A)
+WHITE_QUEEN = chr(0x2655)
+BLACK_QUEEN = chr(0x265B)
+WHITE_ROOK = chr(0x2656)
+BLACK_ROOK = chr(0x265C)
+WHITE_BISHOP = chr(0x2657)
+BLACK_BISHOP = chr(0x265D)
+WHITE_KNIGHT = chr(0x2658)
+BLACK_KNIGHT = chr(0x265E)
+WHITE_PAWN = chr(0x2659)
+BLACK_PAWN = chr(0x265F)

tests/chess/test_pieces.py

@@ -1,21 +1,22 @@
 import sys
 import unittest
 
-from chess.piece import Bishop, King, Knight, Pawn, Piece, Queen, Rook
+from chess import piece
+from chess import symbols
 
 
 class TestPieceModel(unittest.TestCase):
     """Abstract chess model test case"""
 
     def setUp(self) -> None:
-        self.instance = Piece()
+        self.instance = piece.Piece()
 
     def test_default_initializer(self):
         self.assertIs(True, self.instance.is_white)
         self.assertTupleEqual((0, 0), self.instance.position)
 
     def test_initializer(self):
-        instance = Piece(False, (7, 6))
+        instance = piece.Piece(False, (7, 6))
         self.assertIs(False, instance.is_white)
         self.assertTupleEqual((7, 6), instance.position)
 
@@ -59,11 +60,15 @@ def test_get_delta(self):
 
 class TestKingPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = King(True)
-        self.instance.set_position((5, 5))
+        self.instance = piece.King(position=(5, 5))
 
-    def test_str(self):
-        self.assertEqual("white king at (5, 5)", str(self.instance))
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_KING, str(self.instance))
+
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_KING, str(self.instance))
 
     def test_can_move(self):
         positions = ((5, 6), (6, 6), (6, 5), (6, 4),
@@ -82,11 +87,15 @@ def test_cannot_move(self):
 
 class TestQueenPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = Queen(False)
-        self.instance.set_position((2, 3))
+        self.instance = piece.Queen(position=(2, 3))
 
-    def test_str(self):
-        self.assertEqual("black queen at (2, 3)", str(self.instance))
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_QUEEN, str(self.instance))
+
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_QUEEN, str(self.instance))
 
     def test_can_move(self):
         positions = ((2, 5), (4, 5), (7, 3), (3, 2),
@@ -104,11 +113,15 @@ def test_cannot_move(self):
 
 class TestBishopPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = Bishop(True)
-        self.instance.set_position((5, 5))
+        self.instance = piece.Bishop(position=(5, 5))
+
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_BISHOP, str(self.instance))
 
-    def test_str(self):
-        self.assertEqual("white bishop at (5, 5)", str(self.instance))
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_BISHOP, str(self.instance))
 
     def test_can_move(self):
         positions = ((6, 6), (7, 3), (2, 2), (3, 7))
@@ -125,11 +138,15 @@ def test_cannot_move(self):
 
 class TestKnightPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = Knight(False)
-        self.instance.set_position((3, 4))
+        self.instance = piece.Knight(position=(3, 4))
 
-    def test_str(self):
-        self.assertEqual("black knight at (3, 4)", str(self.instance))
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_KNIGHT, str(self.instance))
+
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_KNIGHT, str(self.instance))
 
     def test_can_move(self):
         positions = ((4, 6), (5, 5), (5, 3), (4, 2),
@@ -148,11 +165,15 @@ def test_cannot_move(self):
 
 class TestRookPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = Rook(True)
-        self.instance.set_position((5, 2))
+        self.instance = piece.Rook(position=(5, 2))
 
-    def test_str(self):
-        self.assertEqual("white rook at (5, 2)", str(self.instance))
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_ROOK, str(self.instance))
+
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_ROOK, str(self.instance))
 
     def test_can_move(self):
         positions = ((5, 4), (7, 2), (5, 1), (2, 2))
@@ -169,11 +190,15 @@ def test_cannot_move(self):
 
 class TestPawnPiece(unittest.TestCase):
     def setUp(self) -> None:
-        self.instance = Pawn(False)
-        self.instance.set_position((6, 5))
+        self.instance = piece.Pawn(position=(6, 5))
+
+    def test_str_white(self):
+        self.instance.is_white = True
+        self.assertEqual(symbols.WHITE_PAWN, str(self.instance))
 
-    def test_str(self):
-        self.assertEqual("black pawn at (6, 5)", str(self.instance))
+    def test_str_black(self):
+        self.instance.is_white = False
+        self.assertEqual(symbols.BLACK_PAWN, str(self.instance))
 
     def test_can_move(self):
         self.instance.is_white = False