cardspy 0.0.1__tar.gz

cardspy-0.0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: cardspy
+Version: 0.0.1
+Summary: Functionalities for playing cards
+Author: bd.noads@gmail.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: mypy (>=1.15.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+# cardspy

cardspy-0.0.1/README.md

@@ -0,0 +1 @@
+# cardspy

cardspy-0.0.1/cardspy/card.py

@@ -0,0 +1,177 @@
+"""Card"""
+from typing import List
+from functools import reduce
+from dataclasses import dataclass
+from .rank import (
+    Rank,
+    R2,
+    R3,
+    R4,
+    R5,
+    R6,
+    R7,
+    R8,
+    R9,
+    RT,
+    RJ,
+    RQ,
+    RK,
+    RA,
+)
+from .suit import Suit, CLUB, DIAMOND, HEART, SPADE
+
+
+@dataclass
+class Card:
+    """Card"""
+    key: int
+    rank: Rank
+    suit: Suit
+    code: str
+    name: str
+    symbol: str
+
+    def __str__(self) -> str:
+        return self.symbol
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __lt__(self, other: "Card") -> bool:
+        return self.key < other.key
+
+    def __le__(self, other: "Card") -> bool:
+        return self.key <= other.key
+
+    def __gt__(self, other: "Card") -> bool:
+        return self.key > other.key
+
+    def __ge__(self, other: "Card") -> bool:
+        return self.key >= other.key
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Card):
+            return NotImplemented
+        return self.key == other.key
+
+    def __ne__(self, other: object) -> bool:
+        if not isinstance(other, Card):
+            return NotImplemented
+        return self.key != other.key
+
+
+C2C = Card(0x1, R2, CLUB, "2C", "Two of Clubs", "2♣")
+C2D = Card(0x2, R2, DIAMOND, "2D", "Two of Diamonds", "2♦")
+C2H = Card(0x4, R2, HEART, "2H", "Two of Hearts", "2♥")
+C2S = Card(0x8, R2, SPADE, "2S", "Two of Spades", "2♠")
+
+C3C = Card(0x10, R3, CLUB, "3C", "Three of Clubs", "3♣")
+C3D = Card(0x20, R3, DIAMOND, "3D", "Three of Diamonds", "3♦")
+C3H = Card(0x40, R3, HEART, "3H", "Three of Hearts", "3♥")
+C3S = Card(0x80, R3, SPADE, "3S", "Three of Spades", "3♠")
+
+C4C = Card(0x100, R4, CLUB, "4C", "Four of Clubs", "4♣")
+C4D = Card(0x200, R4, DIAMOND, "4D", "Four of Diamonds", "4♦")
+C4H = Card(0x400, R4, HEART, "4H", "Four of Hearts", "4♥")
+C4S = Card(0x800, R4, SPADE, "4S", "Four of Spades", "4♠")
+
+C5C = Card(0x1000, R5, CLUB, "5C", "Five of Clubs", "5♣")
+C5D = Card(0x2000, R5, DIAMOND, "5D", "Five of Diamonds", "5♦")
+C5H = Card(0x4000, R5, HEART, "5H", "Five of Hearts", "5♥")
+C5S = Card(0x8000, R5, SPADE, "5S", "Five of Spades", "5♠")
+
+C6C = Card(0x10000, R6, CLUB, "6C", "Six of Clubs", "6♣")
+C6D = Card(0x20000, R6, DIAMOND, "6D", "Six of Diamonds", "6♦")
+C6H = Card(0x40000, R6, HEART, "6H", "Six of Hearts", "6♥")
+C6S = Card(0x80000, R6, SPADE, "6S", "Six of Spades", "6♠")
+
+C7C = Card(0x100000, R7, CLUB, "7C", "Seven of Clubs", "7♣")
+C7D = Card(0x200000, R7, DIAMOND, "7D", "Seven of Diamonds", "7♦")
+C7H = Card(0x400000, R7, HEART, "7H", "Seven of Hearts", "7♥")
+C7S = Card(0x800000, R7, SPADE, "7S", "Seven of Spades", "7♠")
+
+C8C = Card(0x1000000, R8, CLUB, "8C", "Eight of Clubs", "8♣")
+C8D = Card(0x2000000, R8, DIAMOND, "8D", "Eight of Diamonds", "8♦")
+C8H = Card(0x4000000, R8, HEART, "8H", "Eight of Hearts", "8♥")
+C8S = Card(0x8000000, R8, SPADE, "8S", "Eight of Spades", "8♠")
+
+C9C = Card(0x10000000, R9, CLUB, "9C", "Nine of Clubs", "9♣")
+C9D = Card(0x20000000, R9, DIAMOND, "9D", "Nine of Diamonds", "9♦")
+C9H = Card(0x40000000, R9, HEART, "9H", "Nine of Hearts", "9♥")
+C9S = Card(0x80000000, R9, SPADE, "9S", "Nine of Spades", "9♠")
+
+CTC = Card(0x100000000, RT, CLUB, "TC", "Ten of Clubs", "10♣")
+CTD = Card(0x200000000, RT, DIAMOND, "TD", "Ten of Diamonds", "10♦")
+CTH = Card(0x400000000, RT, HEART, "TH", "Ten of Hearts", "10♥")
+CTS = Card(0x800000000, RT, SPADE, "TS", "Ten of Spades", "10♠")
+
+CJC = Card(0x1000000000, RJ, CLUB, "JC", "Jack of Clubs", "J♣")
+CJD = Card(0x2000000000, RJ, DIAMOND, "JD", "Jack of Diamonds", "J♦")
+CJH = Card(0x4000000000, RJ, HEART, "JH", "Jack of Hearts", "J♥")
+CJS = Card(0x8000000000, RJ, SPADE, "JS", "Jack of Spades", "J♠")
+
+CQC = Card(0x10000000000, RQ, CLUB, "QC", "Queen of Clubs", "Q♣")
+CQD = Card(0x20000000000, RQ, DIAMOND, "QD", "Queen of Diamonds", "Q♦")
+CQH = Card(0x40000000000, RQ, HEART, "QH", "Queen of Hearts", "Q♥")
+CQS = Card(0x80000000000, RQ, SPADE, "QS", "Queen of Spades", "Q♠")
+
+CKC = Card(0x100000000000, RK, CLUB, "KC", "King of Clubs", "K♣")
+CKD = Card(0x200000000000, RK, DIAMOND, "KD", "King of Diamonds", "K♦")
+CKH = Card(0x400000000000, RK, HEART, "KH", "King of Hearts", "K♥")
+CKS = Card(0x800000000000, RK, SPADE, "KS", "King of Spades", "K♠")
+
+CAC = Card(0x1000000000000, RA, CLUB, "AC", "Ace of Clubs", "A♣")
+CAD = Card(0x2000000000000, RA, DIAMOND, "AD", "Ace of Diamonds", "A♦")
+CAH = Card(0x4000000000000, RA, HEART, "AH", "Ace of Hearts", "A♥")
+CAS = Card(0x8000000000000, RA, SPADE, "AS", "Ace of Spades", "A♠")
+
+ALL_CARDS = [
+    C2C, C2D, C2H, C2S,
+    C3C, C3D, C3H, C3S,
+    C4C, C4D, C4H, C4S,
+    C5C, C5D, C5H, C5S,
+    C6C, C6D, C6H, C6S,
+    C7C, C7D, C7H, C7S,
+    C8C, C8D, C8H, C8S,
+    C9C, C9D, C9H, C9S,
+    CTC, CTD, CTH, CTS,
+    CJC, CJD, CJH, CJS,
+    CQC, CQD, CQH, CQS,
+    CKC, CKD, CKH, CKS,
+    CAC, CAD, CAH, CAS,
+]
+
+
+def sort_cards(cards: List[Card]) -> List[Card]:
+    """Sort cards by rank"""
+    return sorted(cards, key=lambda card: card.rank.key)
+
+
+def cards_mask(cards: List[Card]) -> int:
+    """
+    Given an iterable of Card objects with a .id attribute (an int bit‐mask),
+    return the combined mask of all those cards.
+    """
+    return reduce(lambda mask, card: mask | card.key, cards, 0)
+
+
+# def rank_mask_from_cards(cards: int) -> int:
+#     """
+#     Given an int bit-mask of cards, return the combined mask of
+#     all those cards.
+#     """
+#     rmask = 0
+#     for card in ALL_CARDS:
+#         if cards & card.key != 0:
+#             rmask |= card.rank.key
+#     return rmask
+
+
+def extract_cards(cards: int) -> List[Card]:
+    """
+    Given an int bit-mask of cards, return the list of Card objects
+    that make up that mask.
+    """
+    return [
+        card for card in ALL_CARDS if cards & card.key != 0
+    ]

cardspy-0.0.1/cardspy/deck.py

@@ -0,0 +1,118 @@
+"""Deck"""
+from random import shuffle
+from typing import List
+from functools import reduce
+from .rank import (
+    RA,
+    RK,
+    RQ,
+    RJ,
+    RT,
+    R9,
+    R8,
+    R7,
+    R6,
+    R5,
+    R4,
+    R3,
+    R2,
+)
+from .card import ALL_CARDS, Card, cards_mask
+
+
+CLUBS = 0x1111111111111
+DIAMONDS = 0x2222222222222
+HEARTS = 0x4444444444444
+SPADES = 0x8888888888888
+
+SAME_RANKS = [
+    0xF, 0xF0, 0xF00, 0xF000, 0xF0000, 0xF00000,
+    0xF000000, 0xF0000000, 0xF00000000, 0xF000000000,
+    0xF0000000000, 0xF00000000000, 0xF000000000000
+]
+
+RANKS_DESC = [RA, RK, RQ, RJ, RT, R9, R8, R7, R6, R5, R4, R3, R2]
+
+FULL_DECK_MASK = reduce(lambda acc, card: acc | card.key, ALL_CARDS, 0)
+
+
+class Deck:
+    """Deck"""
+    def __init__(self) -> None:
+        self.bitmask = 0
+        for card in ALL_CARDS:
+            self.bitmask |= card.key
+
+    def clear(self) -> None:
+        """Clear the deck"""
+        self.bitmask = 0
+
+    def reset(self) -> None:
+        """Reset the deck"""
+        self.bitmask = FULL_DECK_MASK
+
+    def contains(self, cards: int) -> bool:
+        """Check if the deck contains a list of cards
+
+        Args:
+            cards (int): List of cards to check
+
+        Returns:
+            bool: True if the deck contains all the cards, False otherwise
+        """
+        return cards & self.bitmask == cards
+
+    def get_cards(self) -> List[Card]:
+        """Get all cards in the deck
+
+        Returns:
+            List[Card]: List of cards in the deck
+        """
+        cards: List[Card] = []
+        for card in ALL_CARDS:
+            if self.contains(card.key):
+                cards.append(card)
+        return cards
+
+    def shuffle(self) -> List[Card]:
+        """Shuffle the deck"""
+        cards = self.get_cards()
+        shuffle(cards)
+        return cards
+
+    def add_card(self, card: Card) -> None:
+        """Add a card to the deck"""
+        self.bitmask |= card.key
+
+    def remove_card(self, card: Card) -> None:
+        """Remove a card from the deck"""
+        self.bitmask &= ~card.key
+
+    def deal_cards(self, count: int = 1) -> int:
+        """Deal cards from the deck
+
+        Args:
+            count (int, optional): Number of cards to deal. Defaults to 1.
+
+        Returns:
+            List[Card]: List of cards dealt
+        """
+        cards: List[Card] = []
+        for _ in range(count):
+            card = self.shuffle().pop()
+            self.remove_card(card)
+            cards.append(card)
+        return cards_mask(cards)
+
+    def deal_specific_card(self, card: Card) -> int:
+        """Deal a specific card from the deck"""
+        if not self.contains(card.key):
+            raise ValueError("Card not in deck")
+        self.remove_card(card)
+        return cards_mask([card])
+
+    def deal_specific_cards(self, cards: List[Card]) -> int:
+        """Deal specific cards from the deck"""
+        for card in cards:
+            self.deal_specific_card(card)
+        return cards_mask(cards)

cardspy-0.0.1/cardspy/rank.py

@@ -0,0 +1,33 @@
+"""Rank"""
+from dataclasses import dataclass
+
+
+@dataclass
+class Rank:
+    """Rank"""
+    key: int
+    code: str
+    name: str
+
+    def __str__(self) -> str:
+        return self.code
+
+    def __repr__(self) -> str:
+        return self.code
+
+
+R2 = Rank(0x1, "2", "Two")
+R3 = Rank(0x2, "3", "Three")
+R4 = Rank(0x4, "4", "Four")
+R5 = Rank(0x8, "5", "Five")
+R6 = Rank(0x10, "6", "Six")
+R7 = Rank(0x20, "7", "Seven")
+R8 = Rank(0x40, "8", "Eight")
+R9 = Rank(0x80, "9", "Nine")
+RT = Rank(0x100, "10", "Ten")
+RJ = Rank(0x200, "J", "Jack")
+RQ = Rank(0x400, "Q", "Queen")
+RK = Rank(0x800, "K", "King")
+RA = Rank(0x1000, "A", "Ace")
+
+NUM_RANKS = 13

cardspy-0.0.1/cardspy/suit.py

@@ -0,0 +1,23 @@
+"""Suit"""
+from dataclasses import dataclass
+
+
+@dataclass
+class Suit:
+    """Suit"""
+    key: int
+    code: str
+    name: str
+    symbol: str
+
+    def __str__(self) -> str:
+        return self.symbol
+
+    def __repr__(self) -> str:
+        return self.symbol
+
+
+CLUB = Suit(0x1, "C", "Club", "♣")
+DIAMOND = Suit(0x2, "D", "Diamond", "♦")
+HEART = Suit(0x4, "H", "Heart", "♥")
+SPADE = Suit(0x8, "S", "Spade", "♠")

cardspy-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "cardspy"
+version = "0.0.1"
+description = "Functionalities for playing cards"
+authors = [
+    {name = "bd.noads@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mypy (>=1.15.0,<2.0.0)"
+]
+
+[tool.poetry]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"