feat!: rename sideboard to sideboards

hearthstone/deckstrings.py

@@ -55,25 +55,25 @@ def from_deckstring(cls, deckstring: str) -> "Deck":
 			instance.cards,
 			instance.heroes,
 			instance.format,
-			instance.sideboard,
+			instance.sideboards,
 		) = parse_deckstring(deckstring)
 		return instance
 
 	def __init__(self):
 		self.cards: CardIncludeList = []
-		self.sideboard: SideboardList = []
+		self.sideboards: SideboardList = []
 		self.heroes: CardList = []
 		self.format: FormatType = FormatType.FT_UNKNOWN
 
 	@property
 	def as_deckstring(self) -> str:
-		return write_deckstring(self.cards, self.heroes, self.format, self.sideboard)
+		return write_deckstring(self.cards, self.heroes, self.format, self.sideboards)
 
 	def get_dbf_id_list(self) -> CardIncludeList:
 		return sorted(self.cards, key=lambda x: x[0])
 
 	def get_sideboard_dbf_id_list(self) -> SideboardList:
-		return sorted(self.sideboard, key=lambda x: x[0])
+		return sorted(self.sideboards, key=lambda x: x[0])
 
 
 def trisort_cards(cards: Sequence[tuple]) -> Tuple[
@@ -192,10 +192,10 @@ def write_deckstring(
 	cards: CardIncludeList,
 	heroes: CardList,
 	format: FormatType,
-	sideboard: Optional[SideboardList] = None,
+	sideboards: Optional[SideboardList] = None,
 ) -> str:
-	if sideboard is None:
-		sideboard = []
+	if sideboards is None:
+		sideboards = []
 
 	data = BytesIO()
 	data.write(b"\0")
@@ -222,24 +222,24 @@ def write_deckstring(
 		_write_varint(data, cardid)
 		_write_varint(data, count)
 
-	if len(sideboard) > 0:
+	if len(sideboards) > 0:
 		data.write(b"\1")
 
-		sideboard_x1, sideboard_x2, sideboard_xn = trisort_cards(sideboard)
+		sideboards_x1, sideboards_x2, sideboards_xn = trisort_cards(sideboards)
 
 		sb_sort_key = lambda x: (x[2], x[0])
 
 		for cardlist in (
-			sorted(sideboard_x1, key=sb_sort_key),
-			sorted(sideboard_x2, key=sb_sort_key)
+			sorted(sideboards_x1, key=sb_sort_key),
+			sorted(sideboards_x2, key=sb_sort_key)
 		):
 			_write_varint(data, len(cardlist))
 			for cardid, _, sideboard_owner in cardlist:
 				_write_varint(data, cardid)
 				_write_varint(data, sideboard_owner)
 
-		_write_varint(data, len(sideboard_xn))
-		for cardid, count, sideboard_owner in sorted(sideboard_xn, key=sb_sort_key):
+		_write_varint(data, len(sideboards_xn))
+		for cardid, count, sideboard_owner in sorted(sideboards_xn, key=sb_sort_key):
 			_write_varint(data, cardid)
 			_write_varint(data, count)
 			_write_varint(data, sideboard_owner)

tests/test_deckstrings.py

@@ -215,7 +215,7 @@ def test_decode_deckstring():
 def test_encode_deckstring():
 	deck = deckstrings.Deck()
 	deck.cards = _decksorted(TEST_DECKSTRING_CARDLIST)
-	deck.sideboard = []
+	deck.sideboards = []
 	deck.format = FormatType.FT_WILD
 	deck.heroes = [31]
 	assert deck.as_deckstring == TEST_DECKSTRING
@@ -229,15 +229,15 @@ def test_reencode_deckstring():
 def test_decode_sideboard_deckstring():
 	deck = deckstrings.Deck.from_deckstring(TEST_SIDEBOARD_DECKSTRING)
 	assert deck.get_dbf_id_list() == _decksorted(TEST_SIDEBOARD_DECKSTRING_CARDLIST)
-	assert deck.sideboard == _decksorted(TEST_SIDEBOARD_DECKSTRING_SIDEBOARD)
+	assert deck.sideboards == _decksorted(TEST_SIDEBOARD_DECKSTRING_SIDEBOARD)
 	assert deck.format == FormatType.FT_WILD
 	assert deck.heroes == [101648]  # Hedanis
 
 
 def test_encode_sideboard_deckstring():
 	deck = deckstrings.Deck()
 	deck.cards = _decksorted(TEST_SIDEBOARD_DECKSTRING_CARDLIST)
-	deck.sideboard = _decksorted(TEST_SIDEBOARD_DECKSTRING_SIDEBOARD)
+	deck.sideboards = _decksorted(TEST_SIDEBOARD_DECKSTRING_SIDEBOARD)
 	deck.format = FormatType.FT_WILD
 	deck.heroes = [101648]
 	assert deck.as_deckstring == TEST_SIDEBOARD_DECKSTRING
@@ -260,7 +260,7 @@ def test_encode_canonical_deckstring():
 		(9, 3),
 		(3, 3),
 	]
-	deck.sideboard = [
+	deck.sideboards = [
 		(8, 1, 3),
 		(10, 1, 2),
 		(1, 1, 3),
@@ -282,7 +282,7 @@ def test_decode_canonical_deckstring():
 		(7, 2),
 		(9, 3),
 	]
-	assert deck.sideboard == [
+	assert deck.sideboards == [
 		(10, 1, 2),
 		(1, 1, 3),
 		(8, 1, 3),
@@ -297,7 +297,7 @@ def test_deckstrings_regression():
 		# Encode tests
 		deck = deckstrings.Deck()
 		deck.cards = deckdata["cards"]
-		deck.sideboard = sideboards
+		deck.sideboards = sideboards
 		deck.heroes = deckdata["heroes"]
 		deck.format = deckdata["format"]
 
@@ -306,6 +306,6 @@ def test_deckstrings_regression():
 		# Decode tests
 		deck = deckstrings.Deck.from_deckstring(deckdata["deckstring"])
 		assert deck.cards == _decksorted(deckdata["cards"])
-		assert deck.sideboard == _sbsorted(sideboards)
+		assert deck.sideboards == _sbsorted(sideboards)
 		assert deck.heroes == sorted(deckdata["heroes"])
 		assert deck.format == deckdata["format"]