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 = get_best_odds(one_site) profit_function = get_profit(bet, one_site) 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_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_match_pari_gagnant(site, minimum_odd, bet, sport="football", date_max=None, time_max=None, date_min=None, time_min=None): """ Retourne le meilleur match sur lequel miser lorsqu'on doit gagner un pari à une cote donnée sur un site donné. """ odds_function = lambda best_odds, odds_site, i: odds_site profit_function = lambda odds_to_check, i: gain2( odds_to_check, np.argmax(odds_to_check), bet) criteria = lambda odds_to_check, i: all(odd >= minimum_odd for odd in odds_to_check) display_function = lambda best_overall_odds, best_rank: mises2( best_overall_odds, bet, np.argmax(best_overall_odds), True) result_function = lambda best_overall_odds, best_rank: mises2( best_overall_odds, bet, np.argmax(best_overall_odds), 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=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 defined_bets(odds_main, odds_second, main_sites, second_sites): """ second_sites type : [[rank, bet, site],...] """ gain = 0 bets = [] if second_sites: sites = copy.deepcopy(main_sites) odds_adapted = copy.deepcopy(odds_main) for bet in second_sites: odds_adapted[bet[0]] = odds_second[bet[2]][bet[0]] sites[bet[0]] = bet[2] for bet in second_sites: valid = True bets = mises2(odds_adapted, bet[1], bet[0]) gain = bet[1] * odds_adapted[bet[0]] for bet2 in second_sites: if bets[bet2[0]] - bet2[ 1] > 1e-6: # Si on mise plus que ce qui est disponible valid = False break if valid: break index_to_del = [] for i, elem in enumerate(second_sites): second_sites[i][1] -= bets[elem[0]] if elem[1] < 1e-6: index_to_del.append(i) for i in index_to_del[::-1]: del second_sites[i] res = defined_bets(odds_main, odds_second, main_sites, second_sites) return [gain + res[0], [bets] + res[1], [sites] + res[2]] return [0, [], []]
def defined_bets(odds_main, odds_second, main_sites, second_sites): """ second_sites type : [[rank, bet, site],...] """ if second_sites: sites = copy.deepcopy(main_sites) odds_adapted = copy.deepcopy(odds_main) for bet in second_sites: odds_adapted[bet[0]] = odds_second[bet[2]][bet[0]] sites[bet[0]] = bet[2] for bet in second_sites: valid = True bets = mises2(odds_adapted, bet[1], bet[0]) gain_freebets = bet[1] * odds_adapted[bet[0]] for bet2 in second_sites: if bets[bet2[0]] > bet2[1]: valid = False break if valid: break for i, elem in enumerate(second_sites): second_sites[i][1] -= bets[elem[0]] if elem[1] < 1e-6: i_0 = i del second_sites[i_0] res = defined_bets(odds_main, odds_second, main_sites, second_sites) return [gain_freebets + res[0], [bets] + res[1], [sites] + res[2]] return [0, [], []]
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 best_stakes_match(match, site, bet, minimum_odd, sport="football"): """ Pour un match, un bookmaker, une somme à miser sur ce bookmaker et une cote minimale donnés, retourne la meilleure combinaison de paris à placer """ best_match, all_odds = odds_match(match, sport) if not all_odds: print("No match found") return print(best_match) pprint(all_odds) odds_site = all_odds['odds'][site] best_odds = copy.deepcopy(odds_site) best_profit = -float("inf") n = len(all_odds['odds'][site]) best_sites = [site for _ in range(n)] best_i = 0 best_overall_odds = None bets = None sites = None for odds in all_odds['odds'].items(): for i in range(n): if odds[1][i] > best_odds[i] and (odds[1][i] >= 1.1 or odds[0] == "pmu"): best_odds[i] = odds[1][i] best_sites[i] = odds[0] for i in range(n): if odds_site[i] >= minimum_odd: odds_to_check = (best_odds[:i] + [odds_site[i]] + best_odds[i + 1:]) profit = gain2(odds_to_check, i, bet) if profit > best_profit: best_profit = profit best_overall_odds = odds_to_check sites = best_sites[:i] + [site] + best_sites[i + 1:] bets = mises2(odds_to_check, bet, i) best_i = i if best_overall_odds: mises2(best_overall_odds, bet, best_i, True) afficher_mises_combine(best_match.split(" / "), [sites], [bets], all_odds["odds"], sport) else: print("No match found")
def compute_odds(window, values): try: sport = values["SPORT_ODDS"][0] stake = float(values["STAKE_ODDS"]) match = values["MATCHES_ODDS"][0] _, bookmakers, best_odds = trj_match(sb.ODDS[sport][match]) except (ValueError, IndexError) as _: return if values["OUTCOME_ODDS_SPLIT_STAKE"]: old_stdout = sys.stdout # Memorize the default stdout stream sys.stdout = buffer = io.StringIO() mises(best_odds, stake, True) sys.stdout = old_stdout # Put the old stream back in place what_was_printed = buffer.getvalue() profit = float(what_was_printed.split("\n")[4].split(' = ')[1]) stakes = eval(what_was_printed.split("\n")[5].split(' = ')[1]) else: outcomes = ["1", "2"] if get_nb_outcomes(sport) == 3: outcomes.insert(1, "N") outcome = 0 for i, outcome_i in enumerate(outcomes): if values["OUTCOME_ODDS_"+outcome_i]: outcome = i break old_stdout = sys.stdout # Memorize the default stdout stream sys.stdout = buffer = io.StringIO() mises2(best_odds, stake, outcome, True) sys.stdout = old_stdout # Put the old stream back in place what_was_printed = buffer.getvalue() profit = float(what_was_printed.split("\n")[5].split(' = ')[1]) stakes = eval(what_was_printed.split("\n")[6].split(' = ')[1]) teams = match.split(" - ") if get_nb_outcomes(sport) == 3: teams.insert(1, "Nul") totals = [round(stake_i * odd_i, 2) for stake_i, odd_i in zip(stakes, best_odds)] table = {"Issue": teams, "Bookmaker": bookmakers, "Cote": best_odds, "Mise": stakes, "Total": totals} text = tabulate.tabulate(table, headers='keys', tablefmt='fancy_grid') window["RESULT_ODDS"].update(text + "\nPlus-value : {}".format(profit), visible=True) if sys.platform.startswith("win"): copy_to_clipboard(text)
def best_combine_reduit(matches, combinaison_boostee, site_combinaison, mise, sport, cote_boostee=0): def get_odd(combinaison, matches, site_combinaison=None): sites = [ 'betclic', 'betstars', 'bwin', 'france_pari', 'joa', 'netbet', 'parionssport', 'pasinobet', 'pmu', 'unibet', 'winamax', 'zebet' ] 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 sportsbetting.ODDS[sport][match]["odds"].keys(): odd *= sportsbetting.ODDS[sport][match]["odds"][site][ i] else: break if odd > best_odd: best_odd = odd best_site = site # print(best_odd, best_site) return best_odd, best_site odds = {} for match in matches: odds[match] = sportsbetting.ODDS[sport][match] best_combinaison = [] best_cotes = [] best_sites = [] best_gain = -mise best_i = -1 for combinaisons in combine_reduit_rec(combinaison_boostee, 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]) new_gain = gain2(cotes, i_boost, mise) if new_gain > best_gain: best_cotes = cotes best_sites = sites best_combinaison = combinaisons best_gain = new_gain best_i = i_boost matches_name = " / ".join(matches) print(matches_name) mises = mises2(best_cotes, mise, best_i) out = {} def get_issue(match, i, sport): if i == float("inf"): return elif sport in ["basketball", "tennis"]: return match.split(" - ")[i] elif i == 1: return "Nul" else: return match.split(" - ")[i // 2] 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 = [ 'betclic', 'betstars', 'bwin', 'france_pari', 'joa', 'netbet', 'parionssport', 'pasinobet', 'pmu', 'unibet', 'winamax', 'zebet' ] odds = { site: [get_odd(combine, matches, site)[0] for combine in best_combinaison] for site in sites } pprint( { "date": max(date for date in [ sportsbetting.ODDS[sport][match]["date"] for match in matches ]), "odds": odds }, compact=True) print("plus-value =", round(best_gain, 2)) print() print( "Répartition des mises (les totaux affichés prennent en compte les éventuels freebets):" ) for combine, mise, cote, site in zip(best_combinaison, mises, 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) sites_bet_combinaison = { site: { "mise": round(mise, 2), "cote": round(cote, 2) }, "total": round(round(mise, 2) * cote, 2) } print(name_combine + " " * diff + "\t", sites_bet_combinaison)
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 best_matches_combine2(site, minimum_odd, bet, sport, minimum_odd_selection, date_max=None, time_max=None, date_min=None, time_min=None): nb_matches = 2 all_odds = filter_dict_dates(sb.ODDS[sport], date_max, time_max, date_min, time_min) all_odds = filter_dict_minimum_odd(all_odds, minimum_odd_selection, site) odds_combine_opt = [{} for _ in range(6)] nb_combine = binomial(len(all_odds), nb_matches) sb.PROGRESS = 0 combis = cotes_combine_optimise([[1 for _ in range(3)] for i in range(nb_matches)])[1] print(combis) def compute_all_odds_combine_optimise(nb_combine, combine, odds_combine_opt): sb.PROGRESS += 100 / nb_combine try: cotes_combination = cotes_combine_reduit_all_sites( *[match[1] for match in combine]) for i in range(6): odds_combine_opt[i][" / ".join([match[0] for match in combine ])] = cotes_combination[i] # combis[i] = cotes_combination[i][1] except KeyError: pass ThreadPool(4).map( lambda x: compute_all_odds_combine_optimise(nb_combine, x, odds_combine_opt), combinations(all_odds.items(), nb_matches)) sb.PROGRESS = 0 odds_function = get_best_odds(False) profit_function = get_profit(bet, False) criteria = lambda odds_to_check, i: all(odd >= minimum_odd for odd in odds_to_check) for i, combination in enumerate(combis): sb.ALL_ODDS_COMBINE = odds_combine_opt[i] # display_function = lambda odds_to_check, i: mises_combine_optimise(odds_to_check, combination, bet, minimum_odd, True) # result_function = lambda odds_to_check, i: mises_combine_optimise(odds_to_check, combination, bet, minimum_odd, False) display_function = lambda best_overall_odds, best_rank: mises2( best_overall_odds, bet, best_rank, True) result_function = lambda best_overall_odds, best_rank: mises2( best_overall_odds, bet, best_rank, 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, combine_opt=True)
def best_combine_reduit(matches, combinaison_boostee, cote, site_booste, mise_max): def get_odd(combinaison, matches): sites = [ 'betclic', 'betstars', 'bwin', 'france_pari', 'joa', 'netbet', 'parionssport', 'pasinobet', 'pmu', 'unibet', 'winamax', 'zebet' ] best_odd = 1 best_site = "" for site in sites: odd = 1 for i, match in zip(combinaison, matches): if i != -1: if site in sportsbetting.ODDS["football"][match][ "odds"].keys(): odd *= sportsbetting.ODDS["football"][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] = sportsbetting.ODDS["football"][match] best_combinaison = [] best_cotes = [] best_sites = [] best_gain = -mise_max best_i = -1 for combinaisons in combine_reduit(len(matches), combinaison_boostee): cotes = [] sites = [] for i, combinaison in enumerate(combinaisons): if list(combinaison) == combinaison_boostee: cotes.append(cote) sites.append(site_booste) i_boost = i else: res = get_odd(combinaison, matches) cotes.append(res[0]) sites.append(res[1]) new_gain = gain2(cotes, i_boost, mise_max) if new_gain > best_gain: best_cotes = cotes best_sites = sites best_combinaison = combinaisons best_gain = new_gain best_i = i_boost print(best_gain) mises = mises2(best_cotes, mise_max, best_i) # return best_cotes, best_sites, best_combinaison out = {} def get_issue(match, i): if i == -1: return elif i == 1: return "Nul" else: return match.split(" - ")[i // 2] opponents = [] for match in matches: opponents_match = match.split(" - ") opponents_match.insert(1, "Nul") opponents.append(opponents_match) nb_chars = max(map(lambda x: len(" / ".join(x)), product(*opponents))) for combine, mise, cote, site in zip(best_combinaison, mises, best_cotes, best_sites): names = [ opponents_match[i] if i > -1 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) sites_bet_combinaison = { site: { "mise": mise, "cote": cote }, "total": mise * cote } print(name_combine + " " * diff + "\t", sites_bet_combinaison)