Initial commit

.gitignore

@@ -0,0 +1,7 @@
+/venv
+/.pytest_cache/*
+/.idea/*
+.env
+holdem_pck
+holdem_calc
+__pycache__/

README.md

@@ -10,3 +10,27 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Introduction
+
+This example is a Streamlit app that supports running OCR inference.
+
+In particular, this app allows you to run inference with uploaded images or images from your camera.
+
+### Target Audience
+We recommend that users have:
+
+- Basic Python programming skills.
+- A basic understanding of the Streamlit library. For more information, go [here](https://docs.streamlit.io/library/get-started/main-concepts).
+
+### Installation
+
+```
+pip install -r examples/apps/ocr/requirements.txt
+```
+
+### Launch the App
+
+```
+streamlit run examples/apps/ocr/app.py
+```

app.py

@@ -0,0 +1,132 @@
+import logging
+from typing import List
+import extra_streamlit_components as stx
+
+import numpy as np
+import streamlit as st
+from landingai.common import Prediction
+from landingai.predict import Predictor
+from landingai.st_utils import render_svg, setup_page
+from landingai.visualize import overlay_predictions
+from PIL import Image
+
+from holdem import run_simulation
+import simulation as s
+
+setup_page(page_title="LandingLens")
+
+Image.MAX_IMAGE_PIXELS = None
+
+_NUM_PLAYERS = 2
+_HAND = "hand"
+_FLOP = "flop"
+
+
+def main():
+    # render_svg(Path("./examples/apps/ocr/static/LandingLens_OCR_logo.svg").read_text())
+    # image_file = st.camera_input("Camera View")
+    tab1, tab2 = st.tabs(["Your hand", "Flop"])
+    with tab1:
+        # image_file_hand = st.file_uploader("Your hand")
+        image_file_hand = image_file = st.camera_input("Your hand")
+        if image_file_hand is not None:
+            preds = _run_inference(image_file_hand)
+            if len(preds) != 2:
+                _show_error_message(2, preds, image_file_hand, "Your hand")
+                image_file_hand = None
+                return
+            st.session_state[_HAND] = preds, image_file_hand
+    with tab2:
+        # image_file_flop = st.file_uploader("Flop")
+        image_file_flop = image_file = st.camera_input(label="Flop")
+        if image_file_flop is not None:
+            preds = _run_inference(image_file_flop)
+            if len(preds) != 3:
+                _show_error_message(3, preds, image_file_flop, "Flop")
+                image_file_flop = None
+                return
+            st.session_state[_FLOP] = preds, image_file_flop
+
+    if _HAND not in st.session_state:
+        st.info("Please take a photo for your hand.")
+        return
+    if _FLOP not in st.session_state:
+        _show_predictions(*st.session_state[_HAND], "Your hand")
+        hand = [_convert_name(det.label_name) for det in st.session_state[_HAND][0]]
+        run_simulation(hand=hand)
+        st.info("Please take a photo for flop to continue.")
+        return
+    col1, col2 = st.columns(2)
+    with col1:
+        _show_predictions(*st.session_state[_HAND], "Your hand")
+    with col2:
+        _show_predictions(*st.session_state[_FLOP], "Flop")
+
+    hand = [_convert_name(det.label_name) for det in st.session_state[_HAND][0]]
+    flop = [_convert_name(det.label_name) for det in st.session_state[_FLOP][0]]
+    if not _validate_cards(hand, flop):
+        return
+    run_simulation(hand=hand, flop=flop)
+
+
+def _validate_cards(hand, flop) -> bool:
+    check = hand + flop
+    if s.dedup(check):
+        st.error("There is a duplicate card.  Please check the board and your hand and try again.", icon="🚨")
+        return False
+    if not s.validate_card(check):
+        st.error("At least one of your cards is not valid.  Please try again.", icon="🚨")
+        return False
+    return True
+
+
+def _convert_name(name: str) -> str:
+    if name.startswith("10"):
+        return f"T{name[2:].lower()}"
+    else:
+        return f"{name[0].upper()}{name[1:].lower()}"
+
+# TODO Rename this here and in `main`
+def _show_error_message(arg0, preds, arg2, arg3):
+    msg = (
+        f"{arg0 - len(preds)} card in your hand is not detected. Please try again with a new image."
+        if len(preds) < arg0
+        else f"More than {len(preds) - arg0} card in your hand is detected. Please try again with a new image."
+    )
+    st.error(msg)
+    _show_predictions(preds, arg2, arg3)
+
+
+@st.cache_data
+def _run_inference(image_file) -> List[Prediction]:
+    image = Image.open(image_file).convert("RGB")
+    predictor = Predictor(endpoint_id="ecab49f5-9047-4d5a-8c92-b7ad8e908324")
+    logging.info("Running Poker prediction")
+    preds = predictor.predict(image)
+    preds = _dedup_preds(preds)
+    logging.info(
+        f"Poker prediction done successfully against {image_file} with {len(preds)} predictions."
+    )
+    # st.write(preds)
+    return preds
+
+
+def _show_predictions(preds, image_file, caption: str) -> None:
+    image = Image.open(image_file).convert("RGB")
+    display_image = overlay_predictions(preds, image)
+    st.image(
+        display_image,
+        channels="RGB",
+        caption=caption,
+    )
+
+
+def _dedup_preds(preds: List[Prediction]) -> List[Prediction]:
+    """Deduplicate predictions by the prediction value."""
+    result = {p.label_name: p for p in preds}
+    return list(result.values())
+
+
+# Run the app
+if __name__ == "__main__":
+    main()

holdem.py

@@ -0,0 +1,97 @@
+from prettytable import PrettyTable
+import simulation as s
+import streamlit as st
+
+
+def run_simulation(
+    hand: list[str],
+    flop: list[str] = None,
+    turn: list[str] = None,
+    river: list[str] = None,
+    sims=100000,
+) -> None:
+    sim = s.simulation_one_player(hand, flop, turn, river, sims)
+    hc_pct = s.percent(sim[1], sim[0])
+    hc_ratio = s.ratio(sim[1], sim[0])
+    pair_pct = s.percent(sim[2], sim[0])
+    pair_ratio = s.ratio(sim[2], sim[0])
+    two_pair_pct = s.percent(sim[3], sim[0])
+    two_pair_ratio = s.ratio(sim[3], sim[0])
+    three_ok_pct = s.percent(sim[4], sim[0])
+    three_ok_ratio = s.ratio(sim[4], sim[0])
+    straight_pct = s.percent(sim[5], sim[0])
+    straight_ratio = s.ratio(sim[5], sim[0])
+    flush_pct = s.percent(sim[6], sim[0])
+    flush_ratio = s.ratio(sim[6], sim[0])
+    boat_pct = s.percent(sim[7], sim[0])
+    boat_ratio = s.ratio(sim[7], sim[0])
+    quads_pct = s.percent(sim[8], sim[0])
+    quads_ratio = s.ratio(sim[8], sim[0])
+    strt_flush_pct = s.percent(sim[9], sim[0])
+    strt_flush_ratio = s.ratio(sim[9], sim[0])
+
+    hole_card_str = f"{hand[0]} {hand[1]}"
+
+    table = PrettyTable()
+    table.field_names = ["Your Hand", "Board"]
+    if flop is None:
+        flop = []
+    if turn is None:
+        turn = []
+    if river is None:
+        river = []
+    board_str = "".join(f"{card} " for card in (flop + turn + river))
+    table.add_row([hole_card_str, board_str])
+
+    odds = PrettyTable()
+    odds.add_column(
+        "Best Final Hand",
+        [
+            "High Card",
+            "Pair",
+            "Two Pair",
+            "Three of a Kind",
+            "Straight",
+            "Flush",
+            "Full House",
+            "Four of a Kind",
+            "Straight Flush",
+        ],
+    )
+    odds.add_column(
+        "% Prob",
+        [
+            hc_pct,
+            pair_pct,
+            two_pair_pct,
+            three_ok_pct,
+            straight_pct,
+            flush_pct,
+            boat_pct,
+            quads_pct,
+            strt_flush_pct,
+        ],
+    )
+    odds.add_column(
+        "Odds",
+        [
+            hc_ratio,
+            pair_ratio,
+            two_pair_ratio,
+            three_ok_ratio,
+            straight_ratio,
+            flush_ratio,
+            boat_ratio,
+            quads_ratio,
+            strt_flush_ratio,
+        ],
+    )
+    st.divider()
+    st.subheader("Odds")
+    st.write(table, "\n")
+    st.write(f"We ran your hand {sims} times.  Here's the odds:\n")
+    st.write(odds, "\n")
+    st.divider()
+
+if __name__ == "__main__":
+    run_simulation(["As", "Ah"], ["2s", "3s", "4s"], sims=10000)

poker_functions.py

@@ -0,0 +1,356 @@
+import random
+from collections import Counter
+from dataclasses import dataclass
+
+card_values = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+ranks = ['2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A']
+rank_value = dict(zip(ranks, card_values))
+value_rank = dict(zip(card_values, ranks))
+suits = ['c', 'd', 'h', 's']
+hand_values = {'hc': 1,
+               'pair': 2,
+               '2pair': 3,
+               '3ok': 4,
+               'straight': 5,
+               'flush': 6,
+               'boat': 7,
+               '4ok': 8,
+               'straight_flush': 9
+               }
+
+HAND_REGISTRY = []
+
+#####     CLASSES     #####
+
+@dataclass
+class Card:
+    def __init__(self, card_str):
+        self.rank = str(card_str[0])
+        self.suit = card_str[1]
+        self.name = self.rank + self.suit
+        self.value = rank_value[self.rank]
+
+    def __str__(self):
+        return self.name
+
+
+    def __getitem__(self, item):
+        if item == 'rank':
+            return self.rank
+        elif item == 'suit':
+            return self.suit
+        elif item == 'name':
+            return self.name
+        elif item == 'value':
+            return self.value
+
+
+@dataclass()
+class Hand:
+    def __init__(self, type, high_value, low_value = 0, kicker=0):
+        """Type = name of hand (e.g. Pair)
+        value = value of the hand (i.e. Straight Flush is the most valuable)
+        high_value = value.  either the high card in straight or flush, the set in full house, the top pair in 2pair, etc
+        low_value = the lower pair in 2 pair or the pair in a full house
+        kicker = value of the kicker in the hand.  Can be null
+        """
+        kicker_rank = value_rank[kicker] if kicker in card_values else 0
+        low_rank = value_rank[low_value] if low_value in card_values else 0
+        self.type = type
+        self.hand_value = hand_values[type]
+        self.kicker = kicker
+        self.kicker_rank = kicker_rank
+        self.high_value = high_value
+        self.high_rank = value_rank[self.high_value]
+        self.low_value = low_value
+        self.low_rank = low_rank
+
+    def __str__(self):
+        return f'{self.type}-{self.high_rank}'
+
+    def __getitem__(self, item):
+        if item in ['hand_value', 'high_value']:
+            return self.high_value
+        elif item == 'high_rank':
+            return self.high_rank
+        elif item == 'kicker':
+            return self.kicker
+        elif item == 'kicker_rank':
+            return self.kicker_rank
+        elif item == 'low_rank':
+            return self.low_rank
+        elif item == 'low_value':
+            return self.low_value
+        elif item == 'type':
+            return self.type
+
+
+class Deck(list):
+    def __init__(self, deck):
+        self.deck = deck
+
+    def __getitem__(self, item):
+        return self.deck[item]
+
+    def __iter__(self):
+        yield from self.deck
+
+    def __len__(self):
+        return len(self.deck)
+
+    def deal_card(self):
+        """Select a random card from the deck.  Return the card and the deck with the card removed"""
+        i = random.randint(0, len(self)-1)
+        card = self[i]
+        self.deck.pop(i)
+        return card, self
+
+    def update_deck(self, card):
+        """Remove card from deck"""
+        deck_names = [card.name for card in self.deck]
+        card_name = card.name if isinstance(card, Card) else card
+        deck_idx = deck_names.index(card_name)
+        self.deck.pop(deck_idx)
+
+
+#####     USEFUL FUNCTIONS     #####
+
+def register(func):
+    """Add a function to the hand register"""
+    HAND_REGISTRY.append(func)
+    return func
+
+def make_card(input_list):
+    """Input_list is either a list of Card objects or string Objects.  If Cards, return the cards.
+      If string, convert to Card and return"""
+    if len(input_list) == 0:
+        return input_list
+    elif isinstance(input_list[0], Card):
+        return input_list
+    else:
+        card_list = [Card(card) for card in input_list]
+        return card_list
+
+
+def generate_deck():
+    deck = []
+    for rank in ranks:
+        for suit in suits:
+            card_str = rank + suit
+            _card = Card(card_str)
+            deck.append(_card)
+    deck = Deck(deck)
+    return deck
+
+
+#####     POKER     #####
+def find_multiple(hand, board, n=2):
+    """Is there a pair, three of a kind, four of a kind/?"""
+    hand = make_card(hand)
+    board = make_card(board)
+    multiple = False
+    multiple_hand = None
+    total_hand = hand + board
+    values = [card.value for card in total_hand]
+    c = Counter(values)
+    for value in set(values):
+        if c[value] == 2 and n == 2:
+            multiple = True
+            hand_type = 'pair'
+            high_value = value
+            low_value = max([value for value in values if value != high_value])
+            kicker = max([value for value in values if value not in [high_value, low_value]])
+            multiple_hand = Hand(hand_type, high_value, low_value=low_value, kicker=kicker)
+            return multiple_hand
+        elif c[value] == 3 and n == 3:
+            multiple = True
+            hand_type = '3ok'
+            high_value = value
+            low_value = max([foo for foo in values if foo != high_value])
+            kicker = max([bar for bar in values if bar not in [high_value, low_value]])
+            multiple_hand = Hand(hand_type, high_value, low_value=low_value, kicker=kicker)
+            return multiple_hand
+        elif c[value] == 4 and n == 4:
+            multiple = True
+            hand_type = '4ok'
+            high_value = value
+            low_value = max([value for value in values if value != high_value])
+            multiple_hand = Hand(hand_type, high_value, low_value=low_value)
+            return multiple_hand
+    return multiple
+
+
+def evaluate_straight(values):
+    """Evaluates a list of card values to determine whether there are 5 consecutive values"""
+    straight = False
+    count = 0
+    straight_hand_values = []
+    sranks = [bit for bit in reversed(range(2, 15))]
+    sranks.append(14)
+    for rank in sranks:
+        if rank in values:
+            count += 1
+            straight_hand_values.append(rank)
+            if count == 5:
+                straight = True
+                return straight, straight_hand_values
+        else:
+            count = 0
+            straight_hand_values = []
+    return straight, straight_hand_values
+
+
+@register
+def find_straight_flush(hand, board):
+    """Find a straight flush in a given hand/board combination"""
+    hand = make_card(hand)
+    board = make_card(board)
+    straight_flush = False
+    flush = find_flush(hand, board)
+    if flush:
+        total_hand = hand + board
+        total_hand = [card for card in total_hand]
+        hand_suits = [card.suit for card in total_hand]
+        c = Counter(hand_suits)
+        flush_suit = c.most_common(1)[0][0]
+        flush_hand = [card.value for card in total_hand if card.suit == flush_suit]
+        straight_flush, straight_hand = evaluate_straight(flush_hand)
+        if straight_flush:
+            high_value = max(straight_hand)
+            hand_type = 'straight_flush'
+            straight_flush_hand = Hand(hand_type,high_value)
+            return straight_flush_hand
+        else:
+            return straight_flush
+    else:
+        return straight_flush
+
+
+@register
+def find_quads(hand, board):
+    quads = find_multiple(hand, board, n=4)
+    return quads
+
+
+@register
+def find_full_house(hand, board):
+    """Is there a full house?"""
+    hand = make_card(hand)
+    board = make_card(board)
+    boat = False
+    boat_hand = None
+    total_hand = hand + board
+    values = [card.value for card in total_hand]
+    c = Counter(values)
+    for value in set(values):
+        if c[value] == 3:
+            high_value = value
+            c.pop(value)
+            for value in set(values):
+                if c[value] > 1:
+                    low_value = value
+                    kicker = max([value for value in values if value != high_value and value != low_value])
+                    boat_hand = Hand('boat', high_value, low_value=low_value, kicker=kicker)
+                    boat = True
+                    return boat_hand
+    return boat
+
+
+@register
+def find_flush(hand, board):
+    """Does any combination of 5 cards in hand or on board amount to 5 of the same suit"""
+    hand = make_card(hand)
+    board = make_card(board)
+    total_hand = hand + board
+    total_hand_suits = [card.suit for card in total_hand]
+    flush = False
+    c = Counter(total_hand_suits)
+    for suit in total_hand_suits:
+        if c[suit] >= 5:
+            flush = True
+    if flush:
+        flush_cards = [card for card in total_hand if card.suit == c.most_common(1)[0][0]]
+        high_value = max([card.value for card in flush_cards])
+        flush_hand = Hand('flush', high_value)
+        return flush_hand
+    else:
+        return flush
+
+
+@register
+def find_straight(hand, board):
+    """Find a straight in a given hand/board combination"""
+    hand = make_card(hand)
+    board = make_card(board)
+    straight = False
+    straight_hand = None
+    high_value = 2
+    reqd_hand_size = 5  # required hand size gives us some flexibility at the cost of more lines.  could be more efficient if we say 'if len(values)<5'
+    total_hand = hand + board
+    values = [*set(card.value for card in total_hand)]
+    slices = len(values) - reqd_hand_size
+    if slices < 0:
+        return straight
+    else:
+        straight, straight_hand_values = evaluate_straight(values)
+        if straight:
+            hand_type = 'straight'
+            if 14 in straight_hand_values:  # all([5,14]) does not work here so using nested ifs.
+                if 5 in straight_hand_values:
+                    high_value = 5
+            else:
+                high_value = max(straight_hand_values)
+            straight_hand = Hand(hand_type, high_value)
+            return straight_hand
+        else:
+            return straight
+
+
+@register
+def find_trips(hand, board):
+    trips = find_multiple(hand, board, n=3)
+    return trips
+
+
+@register
+def find_two_pair(hand, board):
+    """Is there two-pair?"""
+    hand = make_card(hand)
+    board = make_card(board)
+    two_pair = False
+    # two_pair_hand = None
+    total_hand = hand + board
+    values = [card.value for card in total_hand]
+    c = Counter(values)
+    for value in values:
+        if c[value] > 1:
+            pair1 = Hand('pair', value)
+            c.pop(value)
+            for value in values:
+                if c[value] > 1:
+                    pair2 = Hand('pair', value)
+                    kicker = max([value for value in values if value != pair1.high_value and value != pair2.high_value])
+                    two_pair_hand = Hand('2pair', max(pair1.high_value, pair2.high_value), low_value=min(pair1.high_value, pair2.high_value), kicker=kicker)
+                    two_pair = True
+                    return two_pair_hand
+    return two_pair
+
+
+@register
+def find_pair(hand, board):
+    pair = find_multiple(hand, board, n=2)
+    return pair
+
+
+@register
+def find_high_card(hand, board):
+    hand = make_card(hand)
+    board = make_card(board)
+    total_hand = hand + board
+    total_hand_values = [card.value for card in total_hand]
+    total_hand_values.sort()
+    high_value = total_hand_values[-1]
+    low_value = total_hand_values[-2]
+    kicker = total_hand_values[-3]
+    high_card_hand = Hand('hc', high_value,low_value=low_value, kicker=kicker)
+    return high_card_hand

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+extra-streamlit-components
+landingai
+prettytable

simulation.py

@@ -0,0 +1,267 @@
+import poker_functions as p
+from fractions import Fraction
+from collections import Counter
+
+
+class Player:
+    def __init__(self, number, cards=[]):
+        if len(cards) > 0:
+            cards = p.make_card(cards)
+        else:
+            cards = []
+        self.number = number
+        self.cards = cards
+        self.hand = None
+        self.starting_cards = None
+        self.wins = 0
+
+    def __str__(self):
+        return "player_" + str(self.number)
+
+def dedup(board):
+    duplicate = False
+    c = Counter(board)
+    for card in board:
+        if c[card] > 1:
+            duplicate = True
+            return duplicate
+    return duplicate
+
+
+def validate_card(check):
+    """Detect invalid cards in a passed collection"""
+    valid = True
+    deck = p.generate_deck()
+    valid_cards = [card.name for card in deck]
+    for card in check:
+        if card not in valid_cards:
+            valid = False
+            return valid
+    return valid
+
+
+def convert_and_update(deck, cards):
+    if len(cards) == 0:
+        return deck, cards
+    else:
+        cards = p.make_card(cards)
+        for card in cards:
+            deck.update_deck(card)
+        return deck, cards
+
+#####     SIMULATIONS     #####
+def evaluate_hand(hole_cards, flop=[], turn=[], river=[]):
+    board = flop + turn + river
+    hand = None
+    if len(hole_cards + board) < 5:
+        return hand
+    else:
+        for func in p.HAND_REGISTRY:
+            func = func(hole_cards, board)
+            if not func:
+                continue
+            else:
+                return func
+
+
+def score_game(contestants):
+    #  TODO make this more elegant by functionizing repeated code.
+    """Application will determine the highest hand, including low and kicker for each player in player_list"""
+    high = ['flush', 'straight', 'straight_flush']
+    kick = ['4ok']
+    hi_lo = ['boat']
+    hi_lo_kick = ['2pair', 'hc', '3ok', 'pair']
+    high_hand = max(contestants, key=lambda x: x.hand.hand_value)  # contestant with highest hand
+    same_high_hand = [player for player in contestants if player.hand.hand_value == high_hand.hand.hand_value]
+    if len(same_high_hand) == 1:
+        same_high_hand[0].wins += 1
+        return contestants
+    elif high_hand.hand.type in high:
+        high_card = max(same_high_hand, key=lambda x: x.hand.high_value)
+        same_high_card = [player for player in same_high_hand if player.hand.high_value == high_card.hand.high_value]
+        if len(same_high_card) == 1:
+            high_card.wins += 1
+            return contestants
+        else:
+            return contestants
+    elif high_hand.hand.type in hi_lo:
+        over = max(same_high_hand, key=lambda x: x.hand.high_value) # Highest pair in hand
+        same_over = [player for player in same_high_hand if player.hand.high_value == over.hand.high_value]
+        if len(same_over) == 1:
+            over.wins += 1
+            return contestants
+        else:
+            under = max(same_over, key=lambda x: x.hand.low_value) # lowest pair in hand
+            same_under = [player for player in same_over if player.hand.low_value == under.hand.low_value]
+            if len(same_under) == 1:
+                under.wins += 1
+                return contestants
+            else:
+                return contestants
+    elif high_hand.hand.type in hi_lo_kick:
+        over = max(same_high_hand, key=lambda x: x.hand.high_value)  # Highest pair in hand
+        same_over = [player for player in same_high_hand if player.hand.high_value == over.hand.high_value]
+        if len(same_over) == 1:
+            over.wins += 1
+            return contestants
+        else:
+            under = max(same_over, key=lambda x: x.hand.low_value)  # lowest pair in hand
+            same_under = [player for player in same_over if player.hand.low_value == under.hand.low_value]
+            if len(same_under) == 1:
+                under.wins += 1
+                return contestants
+            else:
+                kicker = max(same_under, key=lambda x: x.hand.kicker)
+                same_kicker = [player for player in same_under if player.hand.kicker == kicker.hand.kicker]
+                if len(same_kicker) == 1:
+                    kicker.wins += 1
+                    return contestants
+                else:
+                    return contestants
+    elif high_hand.hand.type in kick:
+        low_val = max(same_high_hand, key=lambda x: x.hand.low_value)
+        same_low_val = [player for player in same_high_hand if player.hand.low_value == low_val.hand.low_value]
+        if len(same_low_val) == 1:
+            low_val.wins += 1
+            return contestants
+        else:
+            return contestants
+
+
+def simulation_one_player(hole, flop=None, turn=None, river=None, sims=100000):
+    if flop is None:
+        flop = []
+    if turn is None:
+        turn = []
+    if river is None:
+        river = []
+    full_board = 7 # number of cards required to run sim
+    passed_cards = len(hole) + len(flop) + len(turn) + len(river)
+    passed_flop = list(flop)
+    high_cards = 0
+    pairs = 0
+    two_pairs = 0
+    trips = 0
+    straights = 0
+    flushes = 0
+    boats = 0
+    quads = 0
+    straight_flushes = 0
+    invalid = 0
+    for i in range(sims):
+        deck = p.generate_deck()
+        deck, hole = convert_and_update(deck, hole)
+        deck, flop = convert_and_update(deck, flop)
+        deck, turn = convert_and_update(deck, turn)
+        deck, river = convert_and_update(deck, river)
+        j = full_board - passed_cards
+        for _ in range(j):
+            deal, deck = deck.deal_card()
+            flop.append(deal)  # Adding to flop because it shouldn't matter, will revert flop back at end of loop
+        hand = evaluate_hand(hole, flop, turn, river)
+        if hand.type == '2pair':
+            two_pairs += 1
+        elif hand.type == '3ok':
+            trips += 1
+        elif hand.type == '4ok':
+            quads += 1
+        elif hand.type == 'boat':
+            boats += 1
+        elif hand.type == 'flush':
+            flushes += 1
+        elif hand.type == 'hc':
+            high_cards += 1
+        elif hand.type == 'pair':
+            pairs += 1
+        elif hand.type == 'straight':
+            straights += 1
+        elif hand.type == 'straight_flush':
+            straight_flushes += 1
+        else:
+            invalid += 1
+        i += 1
+        flop = list(passed_flop)
+    return sims, high_cards, pairs, two_pairs, trips, straights, flushes, boats, quads, straight_flushes
+
+
+def simulation_multiplayer(hole_one, hole_two=[], hole_three=[], hole_four=[], hole_five=[], hole_six=[],
+                           flop = [], turn = [], river = [], opponents=2, sims=10000):
+    contestant_hands = [hole_one, hole_two, hole_three, hole_four, hole_five, hole_six]
+    contestants = []
+    flop = p.make_card(flop)
+    turn = p.make_card(turn)
+    river = p.make_card(river)
+    passed_flop_stable = [card for card in flop]
+    for n in range(opponents):
+        player_name = 'opponent' + str(n+1)
+        player_name = Player(n, contestant_hands[n])
+        contestants.append(player_name)
+    i = 0
+    passed_board = len(flop) + len(turn) + len(river)
+    full_board = 5
+    k = full_board - passed_board
+    for i in range(sims):
+        deck = p.generate_deck()
+        for contestant in contestants:  # TODO move assigning Player.starting_cards to init
+            if len(contestant.cards) == 2:
+                contestant.starting_cards = True
+                for card in contestant.cards:
+                    deck.update_deck(card)  # remove known hole cards from deck
+            else:
+                contestant.starting_cards = False
+                hole_cards = []
+                for j in range(2):
+                    deal, deck = deck.deal_card()
+                    hole_cards.append(deal)
+                contestant.cards = hole_cards #  assign new hole cards if not passed
+        for l in range(k):  # complete the board as needed
+            deal, deck = deck.deal_card()
+            flop.append(deal)
+        for contestant in contestants:
+            hand = evaluate_hand(contestant.cards, flop, turn, river)
+            contestant.hand = hand
+        #  Compare hand values in contestants
+        contestants = score_game(contestants)
+        i += 1
+        #  Revert to starting state
+        flop = [card for card in passed_flop_stable]
+        for contestant in contestants:
+            if contestant.starting_cards is False:
+                contestant.cards = []
+        hole_cards = []
+    return contestants
+
+
+
+#  TODO for single and mult: find and return most likely hand.  Return number of outs and odds.
+
+#####     MATH     #####
+def percent(hits, sims):
+    percent = round((hits / sims) * 100,0)
+    return percent
+
+def ratio(hits, sims):
+    """Return a ratio (e.g. 3:5) for two input numbers"""
+    percent = round((hits / sims),2)
+    fraction = str(Fraction(percent).limit_denominator())
+    fraction = fraction.replace('/', ':')
+    return fraction
+
+
+#####     REFERENCE     #####
+outs = {'1':('46:1','45:1',"22:1"),
+        '2':('22:1','22:1','11:1'),
+        '3':('15:1', '14:1', '7:1'),
+        '4':('11:1','10:1','5:1'),
+        '5':('8.5:1', '8:1','4:1'),
+        '6':('7:1','7:1','3:1'),
+        '7':('6:1','6:1','2.5:1'),
+        '8':('5:1','5:1','2.5:1'),
+        '9':('4:1','4:1','2:1'),
+        '10':('3.5:1','3.5:1','1.5:1'),
+        '11':('3.3:1','3.2:1','1.5:1'),
+        '12':('3:1','3:1','1.2:1'),
+        }
+
+
+rank_value = p.rank_value