def __init__(self, price, kind_of_bet):
Bet.__init__(self, price, kind_of_bet)
bet_types = [
'', self.low_high, self.red_black, self.even_odd, self.dozen,
self.column, self.single, self.split, self.street, self.square,
self.neighbors_of_zero
]
function = bet_types[self.type]
function()
def test_place_bet():
wheel = create_wheel()
table = Table(wheel)
zerozero = Outcome("00", 35)
zerozero_bet = Bet(900, zerozero)
red_bet = Bet(60, Outcome("Red", 1))
table.place_bet(zerozero_bet)
table.place_bet(red_bet)
assert [x.bet_amount for x in table] == [900, 60]
with pytest.raises(InvalidBet):
table.place_bet(red_bet)
def __init__(self):
# Initialisation des joueurs
self.user = User([])
# Appel de la méthode pour créer les joueurs
self.user.generate_player()
# Appel du nom des joueurs
self.players = self.user.players
# Initialisation des paris
self.bet = Bet(1000)
# Initialisation du paquet
self.deck = Deck()
# Appel de la méthode pour mélanger le paquet
self.deck.shuffle()
class BetTestCase(unittest.TestCase):
def setUp(self):
self.outcome_five = Outcome("00-0-1-2-3", RouletteGame.FiveBet)
self.outcome_zero = Outcome("Number 0", RouletteGame.StraightBet)
self.bet_five = Bet(1000, self.outcome_five)
self.bet_zero = Bet(1000, self.outcome_zero)
def test_win_amount(self):
self.assertEqual(self.bet_five.win_amount(), 1000 + 1000 * 6)
self.assertEqual(self.bet_zero.win_amount(), 1000 + 1000 * 35)
def test_lose_amount(self):
self.assertEqual(self.bet_five.lose_amount(), 1000)
self.assertEqual(self.bet_zero.lose_amount(), 1000)
def bet(self, player):
super().bet(player)
betTypes = ['', self.altoBaixo, self.vermelhoPreto, self.parImpar,
self.duzia, self.coluna, self.single, self.split,
self.street, self.square, self.neighborsOfZero]
if self.betType == 0:
player.bet = Bet(0, 0, '', '')
return
function = betTypes[self.betType]
function()
winningPrize = super().getWinningPrize()
player.bet = Bet(self.betValue, self.betType, self.winningRange, winningPrize)
def scrape_match_bets(self, match):
t = time.time()
self.renderer.get(match.url)
try:
teams = match.title.raw_teams
except AttributeError:
teams = match.title.teams
main_row = self.renderer.find_element_by_class_name('sub-row')
main_odds = main_row.find_elements_by_class_name('selection-link')
main_bet_titles = ['Result ' + team + ' To Win' for team in teams]
if len(main_odds) == 3:
main_bet_titles.insert(1, 'Result Draw')
match.bets += [
Bet(main_bet_titles[i], main_odds[i].text, MarathonScraper._NAME,
match.url) for i in range(len(teams))
]
try:
element = self.renderer.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'details-description')))
all_markets_button = element.find_element_by_tag_name('td')
self.renderer.click(all_markets_button)
except Exception:
print(self._NAME, time.time() - t)
return match
self._parse_marketblocks(match.bets, match.url)
print(self._NAME, time.time() - t)
return match
def predictGame(team1, team2, spread):
game = Game(team1, team2, spread=spread)
os.remove('predictionGame.csv')
header = "date,home_team,visitor_team,home_points,visitor_points,home_margin_of_victory,favorite,spread,total," \
"cover,over,team_points,team_total_yards,team_plays_offense,team_yds_per_play_offense,team_turnovers," \
"team_fumbles_lost,team_first_down,team_pass_cmp,team_pass_att,team_pass_yds,team_pass_td,team_pass_int," \
"team_pass_net_yds_per_att,team_pass_fd,team_rush_att,team_rush_yds,team_rush_td,team_rush_yds_per_att," \
"team_rush_fd,team_penalties,team_penalties_yds,team_pen_fd,team_drives,team_score_pct," \
"team_turnover_pct,team_start_avg,team_time_avg,team_plays_per_drive,team_yds_per_drive,team_points_avg," \
"opp_points,opp_total_yards,opp_plays_offense,opp_yds_per_play_offense,opp_turnovers,opp_fumbles_lost," \
"opp_first_down,opp_pass_cmp,opp_pass_att,opp_pass_yds,opp_pass_td,opp_pass_int," \
"opp_pass_net_yds_per_att,opp_pass_fd,opp_rush_att,opp_rush_yds,opp_rush_td,opp_rush_yds_per_att," \
"opp_rush_fd,opp_penalties,opp_penalties_yds,opp_pen_fd,opp_drives,opp_score_pct,opp_turnover_pct," \
"opp_start_avg,opp_time_avg,opp_plays_per_drive,opp_yds_per_drive,opp_points_avg" + '\n'
with open('predictionGame.csv', 'a') as fd:
fd.write(header)
fd.write(game.getCSVString())
fd.write(game.getCSVString())
dataset = pd.read_csv('predictionGame.csv', delimiter=',')
dataset = dataset.drop([
'home_team', 'visitor_team', 'home_points', 'visitor_points',
'favorite', 'total', 'cover', 'home_margin_of_victory', 'over', 'date'
],
axis=1)
dataset = dataset.to_numpy()
if dataset[0][0] == 'OTB':
return "Game OTB"
predictions = model.predict_proba(dataset)
return Bet(
('%s %s %s \nPick: %s (%d' %
(team1.name, spread, team2.name, team1.name if
predictions[0][0] * 100 > 50 else team2.name, predictions[0][0] * 100
if predictions[0][0] * 100 > 50 else 100 - predictions[0][0] * 100) +
"%)\n\n"))
def next_bet(self):
""" Implements Player.next_bet.
Bet on Black with the correct bet amount
"""
black = self.table.wheel.get_outcome("Black")
return Bet(self.bet_amount, black)
def next_bet(self):
""" Make only one bet: 10 on black, and
place it on the table
"""
black = self.table.wheel.get_outcome("Black")
return Bet(self.bet_amount, black)
def get_ml_bet(self, row, team, pinnacle):
line_class = 'linesMl' if team == 'draw' else 'linesTotal'
line = row.find_element_by_class_name(line_class)
add_bet_line = line.get_attribute('onclick')
if add_bet_line:
bet_line = add_bet_line.split(',')
odds = int(bet_line[5].replace("'", ""))
pinnacle_odds = pinnacle.get_ml_odds(
self.period,
self.period_text,
team,
self.is_last_name(),
)
if pinnacle_odds:
bet = Bet(
sport = self.sport,
title = self.title,
team = team,
action_odds = odds,
pinnacle_odds = pinnacle_odds,
bet_type = 'ml',
add_bet_line = add_bet_line,
)
return bet
def get_ou_bet(self, row, team, pinnacle, home_or_away):
line = row.find_element_by_class_name('linesMl')
add_bet_line = line.get_attribute('onclick')
if add_bet_line:
bet_line = add_bet_line.split(',')
bet_type = 'over' if bet_line[2].lower() == "'ov'" else 'under'
line = float(bet_line[4].replace("'", ""))
odds = int(bet_line[5].replace("'", ""))
pinnacle_odds = pinnacle.get_ou_odds(
self.period,
self.period_text,
self.get_total_type(),
bet_type,
line,
home_or_away,
self.ou_multiplier,
)
if pinnacle_odds:
bet = Bet(
sport=self.sport,
title=self.title,
team=team,
action_line=line,
action_odds=odds,
pinnacle_odds=pinnacle_odds,
bet_type=bet_type,
add_bet_line=add_bet_line,
)
return bet
def get_user_bk_info(self):
"""Получает данные аккаунта пользователя"""
self.browser.get(self.make_url('myaccount/myaccount.htm'))
WebDriverWait(self.browser, self.timeout).until(
EC.presence_of_element_located((By.CLASS_NAME, 'history-result')))
# Вытягиваем основной баланс
total_summ_element = self.browser.find_element_by_css_selector(
'[data-punter-balance-value]')
total_summ = float(
total_summ_element.get_attribute('data-punter-balance-value'))
# Вытягиваем нерассчитанные ставки
bets_summ_element = self.browser.find_element_by_xpath(
'//*[contains(text(), "Нерассчитанные")]/ancestor::tr/*[contains(@class, "value")]'
)
bets_summ = float(re.sub('[^.0-9]', '', bets_summ_element.text))
# Вытягиваем историю пари
bets = []
history_results = self.browser.find_elements_by_class_name(
'history-result-main')
for history_result in history_results:
# Выплата
result = history_result.find_element_by_class_name(
'result').text.strip().replace('₽ ', '')
try:
result = float(result)
except:
result = None
# Статус ставки
open_bet_element = history_result.find_element_by_class_name(
'open-bet')
open_bet = -1
try:
open_bet_element.find_element_by_xpath(
'*[contains(@src, "win-icon")]')
open_bet = 1
except:
try:
open_bet_element.find_element_by_xpath(
'*[contains(@src, "lose-icon")]')
open_bet = 0
except:
pass
# Добавляем запись истории
bets.append(
Bet(
history_result.find_element_by_class_name(
'bet-number').text.strip(),
history_result.find_element_by_class_name(
'date').text.strip(),
history_result.find_element_by_class_name('bet-title').
find_elements_by_tag_name('span')[1].text.strip(),
float(
re.sub(
'[^.0-9]', '',
history_result.find_element_by_class_name(
'total-stake').text)), result,
float(
history_result.find_element_by_class_name(
'coefficient').text.strip()), open_bet))
return UserBkInfo(total_summ, bets_summ, bets)
def _get_bets_from_url(self, match_url):
self.renderer(match_url)
event = self.renderer.find_element_by_class_name(
'category-content').find_element_by_class_name('bg')
# match = self._get_bets(event)
bets = []
match = self._get_match_basic_data(event)
teams = match.title.teams
main_odds = event.find_elements_by_class_name('selection-link')
if len(main_odds) == 3:
teams.insert(1, 'draw')
bets += [
Bet(teams[i] + ' will win', main_odds[i].text,
MarathonScraper._NAME, match.url) for i in range(len(teams))
]
try:
element = self.renderer.wait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'details-description')))
all_markets_button = element.find_element_by_tag_name('td')
self.renderer.click(all_markets_button)
except Exception:
return match
time.sleep(0.5)
try:
self._parse_marketblocks(bets, match.url)
except Exception:
return match
match.bets = bets
time.sleep(0.2)
return match
def get_handicap_bet(self, row, team, pinnacle, home_or_away):
line = row.find_element_by_class_name('linesSpread')
add_bet_line = line.get_attribute('onclick')
if add_bet_line:
bet_line = add_bet_line.split(',')
line = float(bet_line[4].replace("'", "").replace("PK", "0"))
odds = int(bet_line[5].replace("'", ""))
pinnacle_odds = pinnacle.get_handicap_odds(
self.period,
self.period_text,
home_or_away,
line,
self.handicap_multiplier,
)
if pinnacle_odds:
bet = Bet(
sport=self.sport,
title=self.title,
team=team,
action_line=line,
action_odds=odds,
pinnacle_odds=pinnacle_odds,
bet_type='handicap',
add_bet_line=add_bet_line,
)
return bet
def next_bet(self):
""" Make a random bet by choosing a random outcome from
all the possible outcomes
"""
outcome = self.rng.choice(self.outcomes_pool)
bet = Bet(self.bet_amount, outcome)
return bet
def create_bets_with_outcome_lowest_quote(self):
self.bets = []
for match in self.matches:
outcome = match.get_outcome_with_lowest_quote()
self.bets.append(Bet(match, outcome))
return self.bets
class TestBet(unittest.TestCase):
bet1 = Bet(10, TestOutcome.oc1)
bet2 = Bet(25, TestOutcome.oc2)
bet3 = Bet(10, TestOutcome.oc4)
bet4 = Bet(1, TestOutcome.oc1)
def test_bet_win_amount(self):
self.assertEqual(self.bet1.winAmount(), 360, "Should be 360.")
def test_bet_lose_amount(self):
self.assertEqual(self.bet1.loseAmount(), 10, "Should be 10.")
def test_str(self):
self.assertEqual(self.bet1.__str__(), "10 on 0", "Should be 10 on 0")
def test_repr(self):
self.assertEqual(self.bet1.__repr__(), "Bet(10, Outcome('0', 35))",
"Should be Bet(10, Outcome(0, 35))")
def default_no_compensation(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Same as default, but it does not compensate a lower probability. ''' firstRate = rates[0] firstWeight = weights[0] betAmmount = int(balance * utils.PERCENAGE_FOR_BET) return Bet(0, betAmmount)
def test_state(self):
noWins = Player1326NoWins(self.player)
print(noWins.currentBet())
self.assertEqual(noWins.currentBet().__repr__(),
Bet(1, Outcome('black', 1)).__repr__())
oneWin = noWins.nextWon()
print(oneWin.currentBet())
twoWins = oneWin.nextWon()
print(twoWins.currentBet())
threeWins = twoWins.nextWon()
print(threeWins.currentBet())
def other(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Randomly bets to the lower probability (but higher reward) horse. Fallbacks to default. ''' lastHorseWeight = weights[-1] lastHorseMaxWeight = utils.MAX_HORSE_WEIGHTS[-1] sigma = lastHorseWeight / lastHorseMaxWeight betAmmount = int(balance * utils.PERCENAGE_FOR_BET * sigma) if random.random() < lastHorseMaxWeight: return Bet(5, betAmmount) return self.default(balance, rates, weights)
def __init__(self, bankroll=500):
self.bet = Bet()
self.point = None
self.bankroll = bankroll
# stats
self.max_bank = bankroll
self.min_bank = bankroll
self.points_made = 0
self.seven_outs = 0
self.come_out_naturals = 0
self.come_out_craps = 0
self.longest_roll = 0
# logging
self.history = OrderedDict()
self.bankroll_history = [bankroll]
def _parse_live_marketblocks(self, bets, url):
market_blocks = self.renderer.find_elements_by_class_name(
'markets--block')
for mb in market_blocks:
try:
block_title_head = mb.find_element_by_class_name(
'markets--head').get_attribute('innerHTML')
b = True
for s in self._SKIP_TITLES:
if s in block_title_head:
b = False
break
if not b:
# print(block_title_head)
continue
print(market_blocks.index(mb))
sub_block_titles = mb.find_elements_by_class_name(
'result--type--head')
sub_blocks = mb.find_elements_by_class_name('outcome--list')
for sub_block in sub_blocks:
block_title_tail = ' ' + sub_block_titles[sub_blocks.index(
sub_block)].find_element_by_tag_name(
'span').get_attribute('innerHTML')
block_title = block_title_head + block_title_tail
block = sub_block
if mb.find_elements_by_class_name('mtype--7'):
break
else:
labels = block.find_elements_by_tag_name('label')
for label in labels:
if label.get_attribute(
'class') == 'outcome--empty':
continue
bet_type = label.find_element_by_tag_name(
'span').get_attribute('title')
bet_title = block_title + ' ' + bet_type
button = label.find_element_by_tag_name('button')
odds = button.text
bet = Bet(bet_title, odds, self._NAME, url)
bets.append(bet)
except Exception:
pass
return bets
def from_dict(cls, match_dict):
url = None
date_time = None
title = None
key = list(match_dict.keys())[0]
found = re.search(r'^(https://.+?) (.+?): (.+?)$', key)
if found:
url = found.group(1)
date_time = DateTime.fromisoformat(found.group(2))
title = MatchTitle.from_str(found.group(3))
bets_dict = list(match_dict.values())[0][0]
bets = [
Bet.from_dict({bet_title: odds})
for bet_title, odds in bets_dict.items()
]
return cls(title, url, date_time, None, bets)
def default(self, balance: int, rates: np.ndarray, weights: np.ndarray) -> Bet: ''' Always bets on the horse with the highest probability to win and compensates the lower probabilities by reducing the amount to bet: # ... sigma = horse_weight / max_horse_weight amount = amount * sigma # ... ''' firstRate = rates[0] firstWeight = weights[0] sigma = firstWeight / utils.MAX_FIRST_HORSE_WEIGHT betAmmount = int(balance * utils.PERCENAGE_FOR_BET * sigma) return Bet(0, betAmmount)
def get_odds_to_win(self, row, team, pinnacle):
line_class = 'linesSpread'
line = row.find_element_by_class_name(line_class)
add_bet_line = line.get_attribute('onclick')
if add_bet_line:
bet_line = add_bet_line.split(',')
odds = int(bet_line[5].replace("'", ""))
pinnacle_odds = pinnacle.get_odds_to_win(team)
if pinnacle_odds:
bet = Bet(
sport=self.sport,
title=self.title,
team=team,
action_odds=odds,
pinnacle_odds=pinnacle_odds,
bet_type='ml',
add_bet_line=add_bet_line,
)
return bet
def _parse_marketblocks(self, bets, url):
soup = self.renderer.soup()
market_blocks = soup.find_all(class_='markets--block')
try:
for mb in market_blocks:
block_title_head = mb.find(class_='markets--head').text
b = True
for s in FavoritScraper._SKIP_TITLES:
if s in block_title_head:
b = False
break
if not b:
# print(block_title_head)
continue
# print(block_title_head)
sub_block_titles = mb.find_all(class_='result--type--head')
sub_blocks = mb.find_all(class_='outcome--list')
for sub_block in sub_blocks:
block_title_tail = ' ' + sub_block_titles[sub_blocks.index(
sub_block)].find('span').text
block_title = block_title_head + block_title_tail
block = sub_block
if mb.find_all(class_='mtype--7'):
break
else:
labels = block.find_all('label')
for label in labels:
if label.get('class') == 'outcome--empty':
continue
bet_type = label.find('span').get('title')
bet_title = block_title + ' ' + bet_type
button = label.find('button')
odds = button.text
bet = Bet(bet_title, odds, FavoritScraper._NAME,
url)
bets.append(bet)
except StaleElementReferenceException:
self._parse_marketblocks(bets, url)
def __init__(self, minimum, player):
self.bet = Bet()
self.player = player
self.dice = Dice()
self.point = None
self.minimum = minimum
# metadata
self.shooters = 1
self.rolls = 1
self.longest_roll = 0
self.points_won = 0
self.points_lost = 0
self.naturals_won = 0
self.naturals_lost = 0
self.come_out_naturals = 0
self.craps_won = 0
self.craps_lost = 0
self.come_out_craps = 0
self.roll_history = []
self.delta = (0, 0)
def _parse_marketblocks(self, bets, match_url):
soup = self.renderer.soup()
market_tables = soup.find_all(class_='marketTable__table___dvHTz')
for mt in market_tables:
flag = False
table_title = mt.find(
class_='marketTable__header___mSHxT').get('title')
for title in self._BAD_TITLES:
if title in table_title:
flag = True
buttons = mt.find_all('button')
for button in buttons:
bet = button.get('title')
if bet != 'Deactivated':
pos = bet.find(': ')
bet_type = bet[:pos]
if flag:
bet_type = self.handle_flag_is_true_case(
buttons, button, bet)
odds = bet[pos + 2:]
bet_title = table_title + ' ' + bet_type
bet = Bet(bet_title, odds, self._NAME, match_url)
bets.append(bet)
def scrape_match_bets(self, match: Match):
t = time.time()
self.renderer.get(match.url)
self._open_bets()
soup = self.renderer.soup()
bet_groups = soup.find_all(class_='bet_group')
for bet_group in bet_groups:
bet_title = bet_group.find(class_='bet-title').text
if ' '.join(bet_title.split()) in OneXBetScraper._SKIP_TITLES:
continue
if '\nSlider' in bet_title:
bet_title = bet_title[:-len('\nSlider')]
bet_types = [
el.text for el in bet_group.find_all(class_='bet_type')
]
odds = [el.text for el in bet_group.find_all(class_='koeff')]
for i in range(len(bet_types)):
bet = Bet(bet_title + '. ' + bet_types[i], odds[i],
OneXBetScraper._NAME, match.url)
match.bets.append(bet)
print(self._NAME, time.time() - t)
def bet(bets):
initial_amount = get_amount_for_bet()
max_martingale = get_bot_config()['max-martingale']
threads = []
for bet in bets:
thread = Bet(
kwargs={
'api': API,
'bet': bet,
'initial_amount': initial_amount,
'max_martingale': max_martingale
})
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
check_needs_to_stop()
sys.exit()
def test_win_loose():
zerozero = Outcome("00", 35)
bet = Bet(10, zerozero)
assert bet.win_amount() == 350
def setUp(self):
self.outcome_five = Outcome("00-0-1-2-3", RouletteGame.FiveBet)
self.outcome_zero = Outcome("Number 0", RouletteGame.StraightBet)
self.bet_five = Bet(1000, self.outcome_five)
self.bet_zero = Bet(1000, self.outcome_zero)
def next_bet(self):
""" Implements Player.next_bet """
if self.red_count <= 0:
black = self.table.wheel.get_outcome("Black")
return Bet(self.bet_amount, black)
class Player(object):
"""Common base class for all players.\nDefault: 2x odds."""
def __init__(self, bankroll=500):
self.bet = Bet()
self.point = None
self.bankroll = bankroll
# stats
self.max_bank = bankroll
self.min_bank = bankroll
self.points_made = 0
self.seven_outs = 0
self.come_out_naturals = 0
self.come_out_craps = 0
self.longest_roll = 0
# logging
self.history = OrderedDict()
self.bankroll_history = [bankroll]
def add_money(self, amount):
self.bankroll += amount
self.update_max_min()
def use_money(self, amount):
if amount > self.bankroll:
amount = self.bankroll
self.bankroll -= amount
self.update_max_min()
return amount
def update_max_min(self):
self.max_bank = max(self.bankroll, self.max_bank)
self.min_bank = min(self.bankroll, self.min_bank)
def log_bankroll(self):
self.bankroll_history.append(self.bankroll)
def catalogue(self, table, log):
self.history[table.rolls] = log
self.longest_roll = max(self.longest_roll, table.dice.current_roll)
def collect_wager(self):
self.bankroll += self.bet.get_wager()
self.log_bankroll()
def tabulate(self):
headers = ['#', 'Shooter', 'BankRoll', 'Wager', 'Dice', 'Point', 'Won', 'Lost']
print tabulate(self.history.values(), headers)
print 'Wager on table: {}'.format(self.bet.get_wager())
print '\nBANKROLL: {} --> {}\n'.format(self.bankroll_history[0], self.bankroll_history[-1])
print 'MAX BANKROLL: {}\tMIN BANKROLL: {}'.format(self.max_bank, self.min_bank)
print 'POINTS WON: {}\t\tSEVEN OUTS: {}'.format(self.points_made, self.seven_outs)
print 'NATURALS: {}\t\tCRAPS: {}'.format(self.come_out_naturals, self.come_out_craps)
print 'LONGEST ROLL: {}\tAVG ROLL: {}'.format(self.longest_roll, self.get_avg_roll())
# line_plot(self.bankroll_history)
# pie_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values())
# bar_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values(), 11)
def get_avg_roll(self):
last_log = self.history[self.history.keys()[-1]]
return last_log.rollNumber / float(last_log.shooter)
@staticmethod
def get_come_odds(number, amount):
if number in (4, 5, 6, 8, 9, 10):
return 2 * amount
@staticmethod
def get_dont_come_odds(number, amount):
if number in (6, 8):
return int(2.4 * amount)
elif number in (5, 9):
return 3 * amount
elif number in (4, 10):
return 4 * amount
def __init__(self, name, initBalance):
self.name = name
self.hand = Hand()
self.wallet = Wallet(initBalance)
self.bet = Bet()
def runMarketLoop():
t = time.localtime()
current_time = time.strftime("%H:%M:%S", t)
outputString = (current_time)
for i in range(0, len(markets) - 1):
market = markets[i]
api_url = "https://www.predictit.org/api/marketdata/markets/" + str(
market)
r = requests.get(api_url)
data = r.json()
contracts = []
yesList = []
noList = []
for i in data['contracts']:
yesCost = i["bestBuyYesCost"]
noCost = i["bestBuyNoCost"]
name = i['name']
if yesCost is None:
yesList.append(-1)
else:
yesList.append(yesCost)
if noCost is None:
noList.append(-1)
else:
noList.append(noCost)
yesList = sorted(yesList)
noList = sorted(noList)
yesProfit = []
noProfit = []
for i in yesList:
if (i != -1):
yesProfit.append(round((1 - i) * 0.9, 4))
else:
yesProfit.append(-1)
for i in noList:
if (i != -1):
noProfit.append(round((1 - i) * 0.9, 4))
else:
noProfit.append(-1)
#Calculating the yes profit
yesSum = 0
for i in range(0, len(yesList) - 1):
yesSum += yesList[i] if yesList[i] != -1 else yesSum
yesSum = yesProfit[len(yesProfit) - 1] - yesSum
#Calculating the no profit
noSum = 0
for i in range(0, len(noProfit) - 1):
noSum += noProfit[i] if noProfit[i] != -1 else noSum
noSum = noSum - noList[len(noList) - 1]
if len(marketsBetList) != len(markets):
marketBet = Bet(market, -1, noSum, -1, -1)
marketsBetList.append(marketBet)
outputString += ("\n\nMarket: " + market)
outputString += ("\nYes profit")
outputString += (
"\n\t single: " + str(yesSum) + " \t max: " +
str(math.floor(yesSum * (850 / yesList[len(yesList) - 1]))))
outputString += ("\nNo profit")
outputString += (
"\n\t single: " + str(noSum) + "\t max: " +
str(math.floor(noSum * (850 / noList[len(noList) - 1]))))
outputString += (
"\n____________________________________________________________________________"
)
print(outputString)
requests.post("WEBHOOK_LINK", {"content": outputString})
marketSort()
class Table(object):
def __init__(self, minimum, player):
self.bet = Bet()
self.player = player
self.dice = Dice()
self.point = None
self.minimum = minimum
# metadata
self.shooters = 1
self.rolls = 1
self.longest_roll = 0
self.points_won = 0
self.points_lost = 0
self.naturals_won = 0
self.naturals_lost = 0
self.come_out_naturals = 0
self.craps_won = 0
self.craps_lost = 0
self.come_out_craps = 0
self.roll_history = []
self.delta = (0, 0)
def simulate(self):
while self.stop_condition():
log = Log()
self.player.strategy(self)
log.pre_roll(self)
self.shoot()
self.delta = self.evaluate_roll()
log.post_roll(self)
self.player.catalogue(self, log)
self.player.tabulate()
def evaluate_roll(self):
delta = (0, 0)
if self.point is None:
if self.dice.total in NATURALS:
delta = self.bet.assess_naturals(self)
self.come_out_naturals += 1
elif self.dice.total in CRAPS:
delta = self.bet.assess_craps(self)
self.come_out_craps += 1
elif self.dice.total in BOXES:
delta = self.bet.assess_box(self)
else:
raise Exception('Invalid Roll')
else:
if self.dice.total == SEVEN:
delta = self.bet.assess_seven_out(self)
elif self.dice.total == YOLEVEN:
delta = self.bet.assess_yoleven(self)
elif self.dice.total in CRAPS:
delta = self.bet.assess_craps(self)
elif self.dice.total in BOXES:
delta = self.bet.assess_box(self)
else:
raise Exception('Invalid Roll')
self.player.log_bankroll()
return delta
def log(self):
line_plot(self.bankroll_history)
# pie_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values())
# bar_chart([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], self.dice.history.values(), 11)
def shoot(self):
self.dice.roll()
self.rolls += 1
return self.dice
def stop_condition(self):
if self.rolls == 100 or self.player.bankroll <= 0:
return False
else:
return True
def update_seven_out_stats(self):
self.shooters += 1
self.longest_roll = max(self.longest_roll, self.dice.current_roll)
self.dice.current_roll = 0
