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)