xtreys 0.2.0__tar.gz

xtreys-0.2.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: xtreys
+Version: 0.2.0
+Summary: An extended add-on that is mixable with Treys.
+Author: TheCursedOne
+Project-URL: Homepage, https://github.com/bingchiliingsacker-dot/XtreysPF
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: treys
+
+## Description
+
+**Xtreys**(*eXtended treys*) is a lightweight **add-on** to the library **Treys**. **Xtreys** uses integers created from **Treys** to rank hole cards, calculate equity, etc.
+
+
+
+## Installation
+
+
+First, **open** your terminal and **run**:
+```bash
+pip install git+https://github.com/bingchiliingsacker-dot/XtreysPF.git
+```
+
+or:
+
+```bash
+pip install xtreyspf
+```
+
+Note: If you run into any issues installing or using XtreysPF, feel free to open a ticket on the **Issues** tab!
+
+
+## Usages
+
+One of **Xtreys**' goals is to evaluate hole cards only.
+Cards are ranked from 1 to 91 with 'A-A' or pocket Ace's being the strongest and a '2-7' being the weakest pair
+
+The function for this is ```preflop_eval```.
+
+Here is a quick test to see if **Xtreys** is working:
+
+```python
+from treys import Deck
+from xtreys import preflop_eval
+
+d = Deck()
+cards = d.draw(2)
+
+rank = preflop_eval(cards)
+print(f"Pre-flop hand rank:\t{rank}") #Output: Pre-flop hand rank:    1-91
+```
+
+Another usage of **Xtreys** is calculating the approximate and accurate equity of cards.
+```approximate_equity``` gives an approximate equity from 0.1(lowest) to 0.9(highest).
+
+Heres a quick test:
+
+```python
+from xtreys import approximate_equity
+
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+river_board = flop_board + river_card
+
+flop_equity = approximate_equity(cards, flop_board)
+
+print('---Flop---')
+print(f'Approximate equity:\t{flop_equity}')
+print('')
+
+turn_equity = approximate_equity(cards, turn_board)
+
+print('---Turn---')
+print(f'Approximate equity:\t{turn_equity}')
+print('')
+
+river_equity = approximate_equity(cards, river_board)
+
+print('---River---')
+print(f'Approximate equity:\t{river_equity}')
+
+'''
+Output:
+---Flop---
+Approximate equity:     0.2
+
+---Turn---
+Approximate equity:     0.3
+
+---River---
+Approximate equity:     0.2
+'''
+```
+
+Accurate equity outputs a much more pinpoint equity than approximate equity, it needs a cards variable of type list[int], a board variable of type list[int], and how many Monte-Carlo simulations you want to make(default=50).
+
+Heres a quick test for ```accurate_equity```:
+
+```python
+from xtreys import accurate_equity
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+
+flop_equity = accurate_equity(cards, flop_board, 100)
+
+print('---Flop---')
+print(f'Accurate equity:\t{flop_equity:.2f}')
+print('')
+
+turn_equity = accurate_equity(cards, turn_board, 150)
+
+print('---Turn---')
+print(f'Accurate equity:\t{turn_equity:.2f}')
+print('')
+
+river_equity = accurate_equity(cards, river_board)
+
+print('---River---')
+print(f'Accurate equity:\t{river_equity:.2f}')
+river_board = flop_board + river_card
+
+'''
+Output:
+
+---Flop---
+Accurate equity:        0.54
+
+---Turn---
+Accurate equity:        0.39
+
+---River---
+Accurate equity:        0.30
+'''

xtreys-0.2.0/README.md

@@ -0,0 +1,134 @@
+## Description
+
+**Xtreys**(*eXtended treys*) is a lightweight **add-on** to the library **Treys**. **Xtreys** uses integers created from **Treys** to rank hole cards, calculate equity, etc.
+
+
+
+## Installation
+
+
+First, **open** your terminal and **run**:
+```bash
+pip install git+https://github.com/bingchiliingsacker-dot/XtreysPF.git
+```
+
+or:
+
+```bash
+pip install xtreyspf
+```
+
+Note: If you run into any issues installing or using XtreysPF, feel free to open a ticket on the **Issues** tab!
+
+
+## Usages
+
+One of **Xtreys**' goals is to evaluate hole cards only.
+Cards are ranked from 1 to 91 with 'A-A' or pocket Ace's being the strongest and a '2-7' being the weakest pair
+
+The function for this is ```preflop_eval```.
+
+Here is a quick test to see if **Xtreys** is working:
+
+```python
+from treys import Deck
+from xtreys import preflop_eval
+
+d = Deck()
+cards = d.draw(2)
+
+rank = preflop_eval(cards)
+print(f"Pre-flop hand rank:\t{rank}") #Output: Pre-flop hand rank:    1-91
+```
+
+Another usage of **Xtreys** is calculating the approximate and accurate equity of cards.
+```approximate_equity``` gives an approximate equity from 0.1(lowest) to 0.9(highest).
+
+Heres a quick test:
+
+```python
+from xtreys import approximate_equity
+
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+river_board = flop_board + river_card
+
+flop_equity = approximate_equity(cards, flop_board)
+
+print('---Flop---')
+print(f'Approximate equity:\t{flop_equity}')
+print('')
+
+turn_equity = approximate_equity(cards, turn_board)
+
+print('---Turn---')
+print(f'Approximate equity:\t{turn_equity}')
+print('')
+
+river_equity = approximate_equity(cards, river_board)
+
+print('---River---')
+print(f'Approximate equity:\t{river_equity}')
+
+'''
+Output:
+---Flop---
+Approximate equity:     0.2
+
+---Turn---
+Approximate equity:     0.3
+
+---River---
+Approximate equity:     0.2
+'''
+```
+
+Accurate equity outputs a much more pinpoint equity than approximate equity, it needs a cards variable of type list[int], a board variable of type list[int], and how many Monte-Carlo simulations you want to make(default=50).
+
+Heres a quick test for ```accurate_equity```:
+
+```python
+from xtreys import accurate_equity
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+
+flop_equity = accurate_equity(cards, flop_board, 100)
+
+print('---Flop---')
+print(f'Accurate equity:\t{flop_equity:.2f}')
+print('')
+
+turn_equity = accurate_equity(cards, turn_board, 150)
+
+print('---Turn---')
+print(f'Accurate equity:\t{turn_equity:.2f}')
+print('')
+
+river_equity = accurate_equity(cards, river_board)
+
+print('---River---')
+print(f'Accurate equity:\t{river_equity:.2f}')
+river_board = flop_board + river_card
+
+'''
+Output:
+
+---Flop---
+Accurate equity:        0.54
+
+---Turn---
+Accurate equity:        0.39
+
+---River---
+Accurate equity:        0.30
+'''

xtreys-0.2.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ['setuptools>=61.0']
+build-backend = 'setuptools.build_meta'
+
+[project]
+name = 'xtreys'
+version = '0.2.0'
+authors = [
+  { name='TheCursedOne' },
+]
+description = 'An extended add-on that is mixable with Treys.'
+readme = 'README.md'
+requires-python = '>=3.7'
+classifiers = [
+    'Programming Language :: Python :: 3',
+    'License :: OSI Approved :: MIT License',
+    'Operating System :: OS Independent',
+]
+dependencies = [
+    'treys'
+]
+
+[project.urls]
+'Homepage' = 'https://github.com/bingchiliingsacker-dot/XtreysPF'
+

xtreys-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xtreys-0.2.0/xtreys.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: xtreys
+Version: 0.2.0
+Summary: An extended add-on that is mixable with Treys.
+Author: TheCursedOne
+Project-URL: Homepage, https://github.com/bingchiliingsacker-dot/XtreysPF
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: treys
+
+## Description
+
+**Xtreys**(*eXtended treys*) is a lightweight **add-on** to the library **Treys**. **Xtreys** uses integers created from **Treys** to rank hole cards, calculate equity, etc.
+
+
+
+## Installation
+
+
+First, **open** your terminal and **run**:
+```bash
+pip install git+https://github.com/bingchiliingsacker-dot/XtreysPF.git
+```
+
+or:
+
+```bash
+pip install xtreyspf
+```
+
+Note: If you run into any issues installing or using XtreysPF, feel free to open a ticket on the **Issues** tab!
+
+
+## Usages
+
+One of **Xtreys**' goals is to evaluate hole cards only.
+Cards are ranked from 1 to 91 with 'A-A' or pocket Ace's being the strongest and a '2-7' being the weakest pair
+
+The function for this is ```preflop_eval```.
+
+Here is a quick test to see if **Xtreys** is working:
+
+```python
+from treys import Deck
+from xtreys import preflop_eval
+
+d = Deck()
+cards = d.draw(2)
+
+rank = preflop_eval(cards)
+print(f"Pre-flop hand rank:\t{rank}") #Output: Pre-flop hand rank:    1-91
+```
+
+Another usage of **Xtreys** is calculating the approximate and accurate equity of cards.
+```approximate_equity``` gives an approximate equity from 0.1(lowest) to 0.9(highest).
+
+Heres a quick test:
+
+```python
+from xtreys import approximate_equity
+
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+river_board = flop_board + river_card
+
+flop_equity = approximate_equity(cards, flop_board)
+
+print('---Flop---')
+print(f'Approximate equity:\t{flop_equity}')
+print('')
+
+turn_equity = approximate_equity(cards, turn_board)
+
+print('---Turn---')
+print(f'Approximate equity:\t{turn_equity}')
+print('')
+
+river_equity = approximate_equity(cards, river_board)
+
+print('---River---')
+print(f'Approximate equity:\t{river_equity}')
+
+'''
+Output:
+---Flop---
+Approximate equity:     0.2
+
+---Turn---
+Approximate equity:     0.3
+
+---River---
+Approximate equity:     0.2
+'''
+```
+
+Accurate equity outputs a much more pinpoint equity than approximate equity, it needs a cards variable of type list[int], a board variable of type list[int], and how many Monte-Carlo simulations you want to make(default=50).
+
+Heres a quick test for ```accurate_equity```:
+
+```python
+from xtreys import accurate_equity
+d = Deck()
+
+cards = d.draw(2)
+flop_board = d.draw(3)
+turn_card, river_card = d.draw(1), d.draw(1)
+
+turn_board = flop_board + turn_card
+
+flop_equity = accurate_equity(cards, flop_board, 100)
+
+print('---Flop---')
+print(f'Accurate equity:\t{flop_equity:.2f}')
+print('')
+
+turn_equity = accurate_equity(cards, turn_board, 150)
+
+print('---Turn---')
+print(f'Accurate equity:\t{turn_equity:.2f}')
+print('')
+
+river_equity = accurate_equity(cards, river_board)
+
+print('---River---')
+print(f'Accurate equity:\t{river_equity:.2f}')
+river_board = flop_board + river_card
+
+'''
+Output:
+
+---Flop---
+Accurate equity:        0.54
+
+---Turn---
+Accurate equity:        0.39
+
+---River---
+Accurate equity:        0.30
+'''

xtreys-0.2.0/xtreys.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+xtreys.egg-info/PKG-INFO
+xtreys.egg-info/SOURCES.txt
+xtreys.egg-info/dependency_links.txt
+xtreys.egg-info/requires.txt
+xtreys.egg-info/top_level.txt
+xtreyspf/__init__.py
+xtreyspf/equity.py
+xtreyspf/evaluator.py

xtreys-0.2.0/xtreys.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xtreys-0.2.0/xtreys.egg-info/requires.txt

@@ -0,0 +1 @@
+treys

xtreys-0.2.0/xtreys.egg-info/top_level.txt

@@ -0,0 +1 @@
+xtreyspf

xtreys-0.2.0/xtreyspf/__init__.py

@@ -0,0 +1,8 @@
+from .evaluator import preflop_eval
+from .equity import approximate_equity, accurate_equity
+
+__all__ = [
+  'preflop_eval',
+  'approximate_equity',
+  'accurate_equity'
+]

xtreys-0.2.0/xtreyspf/equity.py

@@ -0,0 +1,74 @@
+from treys import Evaluator
+
+evaluator = Evaluator()
+
+def accurate_equity(
+	cards: list[int],
+	board: list[int],
+	simulations: int = 50
+) -> float:
+	'''
+	Accurately finds the equity/win rate of
+	variable cards. Uses Monte-Carlo simulation
+	method to evaluate which kind of makes it less
+	accurate but its still accurate.
+
+	Simulations variable can be changed to what your heart desires.
+
+	Cards variable needs the list of raw strings generated from Deck().
+
+	Board variable also needs the list of raw strings generated from Deck().
+	'''
+	
+	win = 0
+	tie = 0
+	lose = 0
+	player_rank_equivalent = evaluator.evaluate(board, cards)
+	
+	for _ in range(simulations):
+		
+		deck = Deck()
+		
+		hand = deck.draw(2)
+		
+		hand_rank_equivalent = evaluator.evaluate(board, hand)
+		
+		if hand_rank_equivalent > player_rank_equivalent:
+			win += 1
+		elif hand_rank_equivalent == player_rank_equivalent:
+			tie += 1
+		else:
+			lose += 1
+	
+	total_possibility = win + tie + lose
+	return (win + 0.5 * tie) / total_possibility
+
+def approximate_equity(
+	cards: list[int], 
+	board: list[int]
+) -> float:
+	'''
+	Finds the approximate win rate of the card.
+	I do not recommend this function unless
+	you are calculating the equity of post-flop
+	without a worry of hacking.
+
+	Cards and board variables both need the list of raw integers generated from Deck()
+	'''
+	
+	approxy = evaluator.evaluate(board, cards)
+	rank_class = evaluator.get_rank_class(approxy)
+	
+	approximate_book = {
+		1: 0.9,
+		2: 0.8,
+		3: 0.7,
+		4: 0.6,
+		5: 0.5,
+		6: 0.4,
+		7: 0.3,
+		8: 0.2,
+		9: 0.1,
+	}
+	
+	return approximate_book.get(rank_class, 0.0)

xtreys-0.2.0/xtreyspf/evaluator.py

@@ -0,0 +1,60 @@
+#=============================================================================
+#----------------------------OPEN-SOURCE CODE---------------------------------
+#                
+#                 An extended add-on of the library treys.
+#
+#  MADE BY: TheCursedOne
+#=============================================================================
+
+from treys import Card, Evaluator
+
+evaluator = Evaluator()
+
+CARD_COMBINATIONS = {
+    # --- PAIRS TIER (#1 to #13) ---
+    'A-A': 1, 'K-K': 2, 'Q-Q': 3, 'J-J': 4, 'T-T': 5,
+    '9-9': 6, '8-8': 7, '7-7': 8, '6-6': 9, '5-5': 10,
+    '4-4': 11, '3-3': 12, '2-2': 13,
+
+    # --- HIGH CARDS TIER (#14 to #91) ---
+    'A-K': 14, 'A-Q': 15, 'A-J': 16, 'K-Q': 17, 'A-T': 18,
+    'K-J': 19, 'Q-J': 20, 'K-T': 21, 'Q-T': 22, 'J-T': 23,
+
+    'A-9': 24, 'A-8': 25, 'A-7': 26, 'A-6': 27, 'A-5': 28,
+    'A-4': 29, 'A-3': 30, 'A-2': 31,
+
+    'K-9': 32, 'K-8': 33, 'K-7': 34, 'K-6': 35, 'K-5': 36,
+    'K-4': 37, 'K-3': 38, 'K-2': 39,
+
+    'Q-9': 40, 'Q-8': 41, 'Q-7': 42, 'Q-6': 43, 'Q-5': 44,
+    'Q-4': 45, 'Q-3': 46, 'Q-2': 47,
+
+    'J-9': 48, 'J-8': 49, 'J-7': 50, 'T-9': 51, 'J-6': 52,
+    'T-8': 53, 'J-5': 54, 'J-4': 55, 'J-3': 56, 'J-2': 57,
+
+    'T-7': 58, '9-8': 59, 'T-6': 60, '9-7': 61, 'T-5': 62,
+    'T-4': 63, 'T-3': 64, 'T-2': 65, '9-6': 66, '9-5': 67,
+    '9-4': 68, '9-3': 69, '9-2': 70,
+
+    '8-7': 71, '8-6': 72, '8-5': 73, '8-4': 74, '8-3': 75,
+    '8-2': 76, '7-6': 77, '7-5': 78, '7-4': 79, '7-3': 80,
+
+    '6-5': 81, '6-4': 82, '6-3': 83, '5-4': 84, '6-2': 85,
+    '5-3': 86, '4-3': 87, '5-2': 88, '4-2': 89, '3-2': 90,
+    '7-2': 91
+}
+
+
+def preflop_eval(cards: list[int] | list[str]) -> int:
+	'''
+	Note: both [4883929747, 47828274732] and [Ah, Kd] are accepted.
+	'''
+	card_1 = Card.int_to_str(cards[0]) if isinstance(cards[0], int) else cards[0]
+	card_2 = Card.int_to_str(cards[1]) if isinstance(cards[1], int) else cards[1]
+
+	card_rank = f'{card_1[0]}-{card_2[0]}'
+
+	if card_rank not in CARD_COMBINATIONS:
+		card_rank = f'{card_2[0]}-{card_1[0]}'
+		
+	return CARD_COMBINATIONS.get(card_rank, 91)