def best_match_under_conditions(site, minimum_odd, bet, sport="football", date_max=None,
time_max=None, date_min=None, time_min=None, one_site=False,
live=False):
"""
Retourne le meilleur match sur lequel miser lorsqu'on doit miser une somme
donnée à une cote donnée. Cette somme peut-être sur seulement une issue
(one_site=False) ou bien répartie sur plusieurs issues d'un même match
(one_site=True), auquel cas, chacune des cotes du match doivent respecter le
critère de cote minimale.
"""
odds_function = lambda best_odds, odds_site, i: ((best_odds[:i]
+ [odds_site[i] * 0.9 if live else odds_site[
i]]
+ best_odds[i + 1:]) if not one_site
else (odds_site[:i]
+ [odds_site[i] * 0.9 if live
else odds_site[i]]
+ odds_site[i + 1:]))
profit_function = lambda odds_to_check, i: (gain(odds_to_check, bet) - bet if one_site
else gain2(odds_to_check, i, bet))
criteria = lambda odds_to_check, i: ((not one_site and odds_to_check[i] >= minimum_odd)
or (one_site and all(odd >= minimum_odd
for odd in odds_to_check)))
display_function = lambda best_overall_odds, best_rank: (mises2(best_overall_odds, bet,
best_rank, True) if not one_site
else mises(best_overall_odds, bet,
True))
result_function = lambda best_overall_odds, best_rank: (mises2(best_overall_odds, bet,
best_rank, False) if not one_site
else mises(best_overall_odds, bet,
False))
best_match_base(odds_function, profit_function, criteria, display_function,
result_function, site, sport, date_max, time_max, date_min,
time_min, one_site=one_site)
def best_matches_combine_cashback_une_selection_perdante(site, cote_minimale_selection, combi_max=0,
nb_matches=2, date_max=None, time_max=None,
date_min=None, time_min=None):
"""
Calcule la meilleure combinaison de matches et les mises à jouer pour une promotion du type
"Combiné remboursé si une seule selection perdante, sans limite du nombre de paris remboursés"
"""
sport = "football"
bet = 10000
all_odds = sportsbetting.ODDS[sport]
sportsbetting.ALL_ODDS_COMBINE = {}
for combine in combinations(all_odds.items(), nb_matches):
try:
if all([odd >= cote_minimale_selection for odds in list(all_odds[match[0]]["odds"][site]
for match in combine)
for odd in odds]):
(sportsbetting
.ALL_ODDS_COMBINE[" / "
.join([match[0]
for match
in combine])]) = cotes_combine_all_sites(*[match[1]
for match
in combine])
except KeyError:
pass
odds_function = lambda best_odds, odds_site, i: list(
map(lambda x: x * (1 + combi_max) - combi_max,
odds_site))
profit_function = lambda odds_to_check, i: gain(odds_to_check, bet) - bet
criteria = lambda odds_to_check, i: (odds_to_check[i] + combi_max) / (1 + combi_max) >= 1.1
display_function = lambda x, i: mises(x, bet, True)
return_function = lambda x, i: mises(x, bet, False)
best_match_base(odds_function, profit_function, criteria, display_function,
return_function, site, sport, date_max, time_max, date_min,
time_min, True, nb_matches, one_site=True, recalcul=True)
def best_matches_combine(site,
minimum_odd,
bet,
sport="football",
nb_matches=2,
one_site=False,
date_max=None,
time_max=None,
date_min=None,
time_min=None,
minimum_odd_selection=1.01):
"""
Retourne les meilleurs matches sur lesquels miser lorsqu'on doit miser une somme
donnée à une cote donnée sur un combiné
"""
all_odds = filter_dict_dates(sportsbetting.ODDS[sport], date_max, time_max,
date_min, time_min)
sportsbetting.ALL_ODDS_COMBINE = {}
for combine in combinations(all_odds.items(), nb_matches):
try:
if all([
odd >= minimum_odd_selection for odds in list(
all_odds[match[0]]["odds"][site] for match in combine)
for odd in odds
]):
(sportsbetting.ALL_ODDS_COMBINE[" / ".join([
match[0] for match in combine
])]) = cotes_combine_all_sites(
*[match[1] for match in combine])
except KeyError:
pass
odds_function = lambda best_odds, odds_site, i: (
(best_odds[:i] + [odds_site[i]] + best_odds[i + 1:])
if not one_site else odds_site)
profit_function = lambda odds_to_check, i: (gain(odds_to_check, bet) - bet
if one_site else gain2(
odds_to_check, i, bet))
criteria = lambda odds_to_check, i: (
(not one_site and odds_to_check[i] >= minimum_odd) or
(one_site and all(odd >= minimum_odd for odd in odds_to_check)))
display_function = lambda best_overall_odds, best_rank: (
mises2(best_overall_odds, bet, best_rank, True)
if not one_site else mises(best_overall_odds, bet, True))
result_function = lambda best_overall_odds, best_rank: (
mises2(best_overall_odds, bet, best_rank, False)
if not one_site else mises(best_overall_odds, bet, False))
best_match_base(odds_function,
profit_function,
criteria,
display_function,
result_function,
site,
sport,
date_max,
time_max,
date_min,
time_min,
True,
nb_matches,
one_site=one_site)
def calculator(odds, lay, commissions, stake, reference, outcomes, sites):
real_odds = []
back_odds = []
lay_odds = []
stakes = []
backers_stakes = []
trj = 0
profit = 0
try:
back_odds = ["" if lay else odd for odd, lay in zip(odds, lay)]
lay_odds = [odd if lay else "" for odd, lay in zip(odds, lay)]
real_odds = [
get_real_odd(odd, commission, is_lay)
for odd, commission, is_lay in zip(odds, commissions, lay)
]
stakes = list(
map(lambda x: round(x, 2), mises2(real_odds, stake, reference)))
backers_stakes = [
round(stake_i / (odd_i - 1), 2) if lay_i else ""
for stake_i, lay_i, odd_i in zip(stakes, lay, odds)
]
trj = gain(real_odds)
profit = stake * real_odds[reference] - sum(stakes)
except ZeroDivisionError:
pass
table = {
"Site":
sites,
"Issue":
outcomes,
"Lay":
lay_odds,
"Cote":
real_odds,
"Mise":
stakes,
"Stake":
backers_stakes,
"Total": [
round(odd_i * stake_i, 2)
for odd_i, stake_i in zip(real_odds, stakes)
]
}
infos = {
"TRJ": [str(round(trj * 100, 3)) + "%"],
"Plus-value": [round(profit, 2)]
}
if not any(lay):
del table["Lay"]
del table["Stake"]
text = "\n".join([
tabulate.tabulate(table, headers='keys', tablefmt='fancy_grid'),
tabulate.tabulate(infos, headers='keys', tablefmt='fancy_grid')
])
print(text)
if sys.platform.startswith("win"):
copy_to_clipboard(text)
def trj_match(match_odds):
odds = []
for bookmaker in match_odds["odds"]:
tmp_odds = match_odds["odds"][bookmaker]
if not odds:
odds = copy.deepcopy(tmp_odds)
continue
for i, tmp_odd in enumerate(tmp_odds):
if tmp_odd > odds[i]:
odds[i] = tmp_odd
return gain(odds)
def trj_match(match_odds):
odds = []
bookmakers = []
for bookmaker in match_odds["odds"]:
tmp_odds = match_odds["odds"][bookmaker]
tmp_bookmakers = [bookmaker for _ in tmp_odds]
if not odds:
odds = copy.deepcopy(tmp_odds)
bookmakers = copy.deepcopy(tmp_bookmakers)
continue
for i, tmp_odd in enumerate(tmp_odds):
if tmp_odd > odds[i]:
odds[i] = tmp_odd
bookmakers[i] = bookmaker
return gain(odds), bookmakers, odds
def best_matches_combine(site, minimum_odd, bet, sport="football", nb_matches=2, one_site=False,
date_max=None, time_max=None, date_min=None, time_min=None,
minimum_odd_selection=1.01):
"""
Retourne les meilleurs matches sur lesquels miser lorsqu'on doit miser une somme
donnée à une cote donnée sur un combiné
"""
all_odds = filter_dict_dates(sportsbetting.ODDS[sport], date_max, time_max, date_min, time_min)
all_odds = filter_dict_minimum_odd(all_odds, minimum_odd_selection, site)
sportsbetting.ALL_ODDS_COMBINE = {}
nb_combine = binomial(len(all_odds), nb_matches)
sportsbetting.PROGRESS = 0
def compute_all_odds_combine(nb_combine, combine):
sportsbetting.PROGRESS += 100/nb_combine
try:
sportsbetting.ALL_ODDS_COMBINE[" / ".join([match[0] for match in combine])] = cotes_combine_all_sites(*[match[1]
for match
in combine])
except KeyError:
pass
ThreadPool(4).map(lambda x: compute_all_odds_combine(nb_combine, x),
combinations(all_odds.items(), nb_matches))
sportsbetting.PROGRESS = 0
odds_function = lambda best_odds, odds_site, i: ((best_odds[:i] + [odds_site[i]]
+ best_odds[i + 1:]) if not one_site
else odds_site)
profit_function = lambda odds_to_check, i: (gain(odds_to_check, bet) - bet if one_site
else gain2(odds_to_check, i, bet))
criteria = lambda odds_to_check, i: ((not one_site and odds_to_check[i] >= minimum_odd)
or (one_site and all(odd >= minimum_odd for
odd in odds_to_check)))
display_function = lambda best_overall_odds, best_rank: (mises2(best_overall_odds, bet,
best_rank, True) if not one_site
else mises(best_overall_odds, bet,
True))
result_function = lambda best_overall_odds, best_rank: (mises2(best_overall_odds, bet,
best_rank, False) if not one_site
else mises(best_overall_odds, bet,
False))
best_match_base(odds_function, profit_function, criteria, display_function,
result_function, site, sport, date_max, time_max, date_min,
time_min, True, nb_matches, one_site=one_site, combine_opt=True)
def best_matches_freebet_one_site(site,
freebet,
sport="football",
nb_matches=2,
minimum_odd=1.1,
date_max=None,
time_max=None,
date_min=None,
time_min=None):
"""
Calcule la répartition des paris gratuits sur un unique site
"""
all_odds = sportsbetting.ODDS[sport]
sportsbetting.ALL_ODDS_COMBINE = {}
for combine in combinations(all_odds.items(), nb_matches):
(sportsbetting.ALL_ODDS_COMBINE[" / ".join([
match[0] for match in combine
])]) = cotes_combine_all_sites(*[match[1] for match in combine])
odds_function = lambda best_odds, odds_site, i: cotes_freebet(odds_site)
profit_function = lambda odds_to_check, i: gain(odds_to_check, freebet
) - freebet
criteria = lambda odds_to_check, i: all(odd >= minimum_odd
for odd in odds_to_check)
display_function = lambda best_overall_odds, best_rank: mises(
best_overall_odds, freebet, True)
result_function = lambda best_overall_odds, best_rank: mises(
best_overall_odds, freebet, False)
best_match_base(odds_function,
profit_function,
criteria,
display_function,
result_function,
site,
sport,
date_max,
time_max,
date_min,
time_min,
True,
nb_matches,
True,
one_site=True)
def best_combine_reduit(matches,
combinaison_boostee,
site_combinaison,
mise,
sport,
cote_boostee=0,
taux_cashback=0,
cashback_freebet=True,
freebet=False,
output=True):
def get_odd(combinaison, matches, site_combinaison=None):
sites = sb.BOOKMAKERS
if site_combinaison:
sites = [site_combinaison]
best_odd = 1
best_site = ""
for site in sites:
odd = 1
for i, match in zip(combinaison, matches):
if i != float("inf"):
if site in sb.ODDS[sport][match]["odds"].keys():
odd *= sb.ODDS[sport][match]["odds"][site][i]
else:
break
if odd > best_odd:
best_odd = odd
best_site = site
return best_odd, best_site
odds = {}
for match in matches:
odds[match] = sb.ODDS[sport][match]
best_combinaison = []
best_cotes = []
best_sites = []
best_gain = -float("inf")
best_i = -1
for combinaisons in combine_reduit_rec(combinaison_boostee,
get_nb_outcomes(sport)):
cotes = []
sites = []
for i, combinaison in enumerate(combinaisons):
if list(combinaison) == combinaison_boostee:
i_boost = i
sites.append(site_combinaison)
if cote_boostee:
cotes.append(cote_boostee)
else:
cotes.append(
get_odd(combinaison, matches, site_combinaison)[0])
else:
res = get_odd(combinaison, matches)
cotes.append(res[0])
sites.append(res[1])
if not taux_cashback:
new_gain = gain2(cotes, i_boost, mise)
else:
new_gain = gain_pari_rembourse_si_perdant(cotes, mise, i_boost,
cashback_freebet,
taux_cashback)
if new_gain > best_gain: # and all(cote>cote_minimale for cote in cotes:
best_cotes = cotes
best_sites = sites
best_combinaison = combinaisons
best_gain = new_gain
best_i = i_boost
matches_name = " / ".join(matches)
if output:
print(matches_name)
if not taux_cashback:
stakes = mises2(best_cotes, mise, best_i)
else:
stakes = mises_pari_rembourse_si_perdant(best_cotes, mise, best_i,
cashback_freebet,
taux_cashback)
opponents = []
for match in matches:
opponents_match = match.split(" - ")
if sport not in ["basketball", "tennis"]:
opponents_match.insert(1, "Nul")
opponents.append(opponents_match)
nb_chars = max(map(lambda x: len(" / ".join(x)), product(*opponents)))
sites = sb.BOOKMAKERS
odds = {
site:
[get_odd(combine, matches, site)[0] for combine in best_combinaison]
for site in sites
}
if not output:
return best_gain
pprint(
{
"date":
max(date for date in
[sb.ODDS[sport][match]["date"] for match in matches]),
"odds":
odds
},
compact=True)
print("plus-value =", round(best_gain + freebet * mise, 2))
if freebet:
print("taux de conversion =", round((best_gain + mise) / mise * 100,
3), "%")
print("taux de retour au joueur =", round(gain(best_cotes) * 100, 3), "%")
print()
print(
"Répartition des mises (les totaux affichés prennent en compte les éventuels freebets):"
)
table_teams = []
table_odds = []
table_stakes = []
table_totals = []
table_bookmakers = []
for combine, stake, cote, site in zip(best_combinaison, stakes, best_cotes,
best_sites):
names = [
opponents_match[i] if i != float("inf") else ""
for match, i, opponents_match in zip(matches, combine, opponents)
]
name_combine = " / ".join(x for x in names if x)
diff = nb_chars - len(name_combine)
if freebet and combine == combinaison_boostee:
sites_bet_combinaison = {
site: {
"mise freebet": round(stake, 2),
"cote": round(cote + 1, 3)
},
"total": round(round(stake, 2) * cote, 2)
}
table_stakes.append("{} (freebet)".format(stake))
table_odds.append(round(cote + 1, 3))
else:
sites_bet_combinaison = {
site: {
"mise": round(stake, 2),
"cote": round(cote, 3)
},
"total": round(round(stake, 2) * cote, 2)
}
table_stakes.append(round(stake, 2))
table_odds.append(round(cote, 3))
table_teams.append(name_combine)
table_totals.append(round(round(stake, 2) * cote, 2))
table_bookmakers.append(site)
table = {
"Issue": table_teams,
"Bookmaker": table_bookmakers,
"Cote": table_odds,
"Mise": table_stakes,
"Total": table_totals
}
text = tabulate.tabulate(table, headers='keys', tablefmt='fancy_grid')
print(text)
if sys.platform.startswith("win"):
copy_to_clipboard(text)
def afficher_mises_combine(matches,
sites,
list_mises,
cotes,
sport="football",
rang_freebet=None,
uniquement_freebet=False,
cotes_boostees=None,
rang_2e_freebet=-1,
combinaisons=None,
profit=0):
"""
Affichage de la répartition des mises
"""
opponents = []
is_1n2 = get_nb_outcomes(sport) == 3
for match in matches:
opponents_match = match.split(" - ")
if is_1n2:
opponents_match.insert(1, "Nul")
opponents.append(opponents_match)
dict_combinaison = {}
if not combinaisons:
combinaisons = list(product(*opponents))
nb_chars = max(map(lambda x: len(" / ".join(x)), combinaisons))
table_teams = []
table_odds = []
table_stakes = []
table_totals = []
table_bookmakers = []
print(
"\nRépartition des mises (les totaux affichés prennent en compte les "
"éventuels freebets):")
for i, combinaison in enumerate(combinaisons):
diff = nb_chars - len(" / ".join(combinaison))
sites_bet_combinaison = {}
for j, list_sites in enumerate(sites):
if list_sites[i] in sites_bet_combinaison:
if i in [rang_freebet, rang_2e_freebet] or uniquement_freebet:
sites_bet_combinaison[
list_sites[i]]["mise freebet"] += list_mises[j][i]
else:
sites_bet_combinaison[
list_sites[i]]["mise"] += list_mises[j][i]
else:
sites_bet_combinaison[list_sites[i]] = {}
if uniquement_freebet:
sites_bet_combinaison[
list_sites[i]]["mise freebet"] = list_mises[j][i]
sites_bet_combinaison[list_sites[i]]["cote"] = cotes[
list_sites[i]][i]
elif i in [rang_freebet, rang_2e_freebet]:
sites_bet_combinaison[
list_sites[i]]["mise freebet"] = list_mises[j][i]
sites_bet_combinaison[list_sites[i]]["cote"] = (
cotes[list_sites[i]][i] + (not rang_freebet == i) -
(rang_2e_freebet == i))
else:
sites_bet_combinaison[
list_sites[i]]["mise"] = list_mises[j][i]
sites_bet_combinaison[list_sites[i]]["cote"] = cotes[
list_sites[i]][i]
for site in sites_bet_combinaison:
try:
sites_bet_combinaison[site]["mise"] = round(
sites_bet_combinaison[site]["mise"], 2)
except KeyError:
sites_bet_combinaison[site]["mise freebet"] = round(
(sites_bet_combinaison[site]["mise freebet"]), 2)
if cotes_boostees and cotes_boostees[i] > cotes[sites[0][i]][i]:
# Valable que s'il n'y a qu'un seul match
sites_bet_combinaison["total boosté"] = round(
cotes_boostees[i] *
(sites_bet_combinaison[sites[0][i]]["mise"]), 2)
else:
try:
sites_bet_combinaison["total"] = round(
sum(x["cote"] * x["mise"]
for x in sites_bet_combinaison.values()), 2)
except KeyError:
sites_bet_combinaison["total"] = round(
sum((x["cote"] - 1) * x["mise freebet"]
for x in sites_bet_combinaison.values()), 2)
dict_combinaison[combinaison] = sites_bet_combinaison
table_name = combinaison
combinaison_odds = []
combinaison_stakes = []
combinaison_bookmakers = []
for site in sites_bet_combinaison:
if "total" in site:
table_total = sites_bet_combinaison[site]
continue
combinaison_bookmakers.append(site)
combinaison_odds.append(sites_bet_combinaison[site]["cote"])
if "mise" in sites_bet_combinaison[site]:
combinaison_stakes.append(sites_bet_combinaison[site]["mise"])
else:
combinaison_stakes.append("{} (freebet)".format(
sites_bet_combinaison[site]["mise freebet"]))
table_teams.append(" / ".join(combinaison))
table_totals.append(table_total)
table_odds.append("\n".join(map(str, combinaison_odds)))
table_stakes.append("\n".join(map(str, combinaison_stakes)))
table_bookmakers.append("\n".join(combinaison_bookmakers))
is_pari_gagnant = "\n" in "".join(table_stakes)
cash_stakes = [
sum([float(sub_stake) for sub_stake in stake.split("\n")])
for stake in table_stakes if "freebet" not in stake
]
freebet_stakes = [
float(stake.split(" (")[0]) for stake in table_stakes
if "freebet" in stake
]
table = {
"Issue": table_teams,
"Bookmaker": table_bookmakers,
"Cote": table_odds,
"Mise": table_stakes,
"Total": table_totals
}
trj = min(table_totals) / sum(cash_stakes) if is_pari_gagnant else gain(
map(lambda x: float(x), table_odds))
infos = {
"TRJ": [str(round(trj * 100, 3)) + "%"],
"Plus-value": [round(profit, 2)],
"Compétition":
[sb.ODDS[sport].get(match, {}).get("competition", "Indéterminée")]
}
if profit and rang_freebet or uniquement_freebet:
del infos["Plus-value"]
infos["Taux de conversion"] = [str(round(profit * 100, 2)) + "%"]
text = "\n".join([
tabulate.tabulate(table, headers='keys', tablefmt='fancy_grid'),
tabulate.tabulate(infos, headers='keys', tablefmt='fancy_grid')
])
print(text)
if sys.platform.startswith("win"):
copy_to_clipboard(text)
def aux(odds_to_check, i):
if one_site:
return gain(odds_to_check, stake) - stake
return gain2(odds_to_check, i, stake)
