# Estimate Equities Headsup All in Texas Holdem
# Python3


import treys # https://github.com/ihendley/treys
from treys import Deck, Card, Evaluator
from random import shuffle
from multiprocessing import Pool # to speed up calculations


# Set some params for the equity calculation later 
POOL_SIZE = 4
NUM_SIMULATIONS = 10000


# We need only one instance of the Evaluator
# use the Evaluator to check the winner once the board has been dealt
evaluator = Evaluator()

def _deal_random_board_evaluate(hands):
    '''
    Given two Texas Holdem Starting hands, run out one five card board and check the winner
    
    :param hands: string like 'Ah2dKdKc'   
    :returns: True if player1_hand wins else False
    
    '''
    
    # instantiate a new deck and shuffle it
    deck = Deck().GetFullDeck()
    shuffle(deck)
    
    # create the players' hands and pop them from the deck
    # so that they do not conflict with the board
    # eg assert len(deck) == 48
    
    player1_hand= [deck.pop(deck.index(Card.new(hands[:2]))), deck.pop(deck.index(Card.new(hands[2:4])))]
    player2_hand= [deck.pop(deck.index(Card.new(hands[4:6]))), deck.pop(deck.index(Card.new(hands[6:])))]
    

    board = deck[:5]
    
    
    # returns TRUE if player1_hand is the winning poker hand
    # in treys, the lower the number the better the hand
    
    return evaluator.evaluate(board, player1_hand) < evaluator.evaluate(board, player2_hand)


def estimate_equity(hands,num_simulations=NUM_SIMULATIONS, pool_size=POOL_SIZE):
    ''' Estimate the Heads up All in Equity of a given Texas Holdem Starting Hand against one other hand
    
    :param hands: string of the two starting hands with no spaces, eg 'AhAdKcKd'
    :param num_simulations: integer, the number of simulations to run, one simulation deals one 5 card board and checks the winner
    :param pool_size: integer the number of processes to start via multiprocessing
    
    
    :returns: float the equity estimate
    
    '''
    pool = Pool(pool_size)
    results = pool.map(_deal_random_board_evaluate, [hands]*num_simulations)
    
    return sum(results)/num_simulations

# Estimate Equities Headsup All in Texas Holdem
# Python3
# use eg estimate_equity.py AhAdKhKd 100 
# 0.81


import treys # https://github.com/ihendley/treys
from treys import Deck, Card, Evaluator
from random import shuffle
import sys
from multiprocessing import Pool, Process # to speed up calculations


# Set some params for the equity calculation later 
POOL_SIZE = 4
HANDS = str(sys.argv[1])
NUM_SIMULATIONS = int(sys.argv[2])



# We need only one instance of the Evaluator
# use the Evaluator to check the winner once the board has been dealt
evaluator = Evaluator()

def _deal_random_board_evaluate(hands):
    '''
    Given two Texas Holdem Starting hands, run out one five card board and check the winner
    
    :param hands: string like 'Ah2dKdKc'   
    :returns: True if player1_hand wins else False
    
    '''
    
    # instantiate a new deck and shuffle it
    deck = Deck().GetFullDeck()
    shuffle(deck)
    
    # create the players' hands and pop them from the deck
    # so that they do not conflict with the board
    # eg assert len(deck) == 48
    
    player1_hand= [deck.pop(deck.index(Card.new(hands[:2]))), deck.pop(deck.index(Card.new(hands[2:4])))]
    player2_hand= [deck.pop(deck.index(Card.new(hands[4:6]))), deck.pop(deck.index(Card.new(hands[6:])))]
    

    board = deck[:5]
    
    
    # returns TRUE if player1_hand is the winning poker hand
    # in treys, the lower the number the better the hand
    
    return evaluator.evaluate(board, player1_hand) < evaluator.evaluate(board, player2_hand)


    
    
if __name__ == '__main__':
    
    data = [HANDS]*NUM_SIMULATIONS
    
    with Pool(processes=POOL_SIZE) as pool:
        results = pool.map(_deal_random_board_evaluate, data)
        
        print(sum(results)/NUM_SIMULATIONS)

import treys # https://github.com/ihendley/treys
from treys import Deck, Card, Evaluator
from random import shuffle
import sys
from multiprocessing import Pool, Process # to speed up calculations


# Set some params for the equity calculation later 
POOL_SIZE = 4
HANDS = str(sys.argv[1])
NUM_SIMULATIONS = int(sys.argv[2])

# We need only one instance of the Evaluator
# use the Evaluator to check the winner once the board has been dealt
evaluator = Evaluator()


def _deal_random_board_evaluate(a):
    hands, count = a

    wins = 0
    deck = Deck().GetFullDeck()

    player1_hand = [deck.pop(deck.index(Card.new(hands[:2]))), deck.pop(deck.index(Card.new(hands[2:4])))]
    player2_hand = [deck.pop(deck.index(Card.new(hands[4:6]))), deck.pop(deck.index(Card.new(hands[6:])))]

    for i in range(count):
        shuffle(deck)
        diff = evaluator.evaluate(deck[:5], player1_hand) - evaluator.evaluate(deck[:5], player2_hand)
        wins += (diff < 0) if diff else 0.5

    return wins



if __name__ == '__main__':
    parts = POOL_SIZE*8
    data = [(HANDS, int(NUM_SIMULATIONS/parts))]*parts
    real_num_sims = int(NUM_SIMULATIONS/parts)*parts

    with Pool(processes=POOL_SIZE) as pool:
        total_wins = sum(pool.map(_deal_random_board_evaluate, data))

        print(total_wins/real_num_sims)
        
        print(total_wins/NUM_SIMULATIONS)

# Speed test I just ran for you


# your function in py_ev
def build_deck():
    new = []
    for f in range(2, 15):
        for s in range(1, 5):
            new.append((f, s))
    return new

# an alternative 
def new_deck():
    return list(itertools.product(range(2,15), range(1,5)))
    # you might not even need to call list() here
    # depending on how you intend to use this


%timeit build_deck()

# 10000 loops, best of 3: 20.5 µs per loop

import itertools # ships with python
%timeit new_deck()

# 100000 loops, best of 3: 6.95 µs per loop