def get_all_races(self): # Get all games, even those with no scores API feed, search 2 hours in the past delta = datetime.timedelta(seconds=60 * 70) to_time = datetime.datetime.now() + delta event_types = self.client.list_event_types( MarketFilter(text_query='horse')) horse_racing_id = event_types[0].event_type.id countries = config.get('Scraping', 'countries').split() events = self.client.list_events( filter=MarketFilter(event_type_ids=[horse_racing_id], market_countries=countries, market_start_time=TimeRange(to=to_time))) # market_type_codes=self.interested_types) if len(events) == 0: return [], [] # TODO: shouldn't these be returned as defaultdict? markets = defaultdict(list) for m in self.client.list_market_catalogue( MarketFilter(event_ids=[e.event.id for e in events], market_start_time=TimeRange(to=to_time), market_type_codes=self.interested_types), market_projection=[ MarketProjection['RUNNER_DESCRIPTION'], MarketProjection['EVENT'], MarketProjection['MARKET_DESCRIPTION'], MarketProjection['MARKET_START_TIME'] ]): markets[m.event.id].append((m.market_id, m)) return events, markets
def get_events(self, event_id=None, type_ids=None, inplay=False, time_from=None, time_to=None, market_countries=None): get_logger().debug("asking for events", event_id=event_id, inplay=inplay, time_from=time_from, time_to=time_to) if event_id is not None: events = self.client.list_events( MarketFilter(event_ids=[event_id])) return events events = self.client.list_events( MarketFilter(event_type_ids=type_ids, in_play_only=False, market_start_time=TimeRange(from_=time_from, to=time_to), market_countries=market_countries), ) return events
def handle(self, *args, **kwargs): # XXX: Hardcodign msk = timezone('Europe/Moscow') utc = timezone('UTC') # Loop over configured targets for competition in settings.TARGETS: cid = self.get_competition_id(competition) # Get event list for each target team for target in settings.TARGETS[competition]: events = self.client.list_events( MarketFilter(text_query=target, competition_ids=cid) ) # Event processing for e in events: event_id = int(e.event.id) raw_time = make_aware(e.event.open_date, utc) start_time = localtime(raw_time, msk) # Save persistent data try: event = Event.objects.create(id=event_id, title=e.event.name, start_time=start_time) event.save() self.stdout.write('Event #%d \'%s\' saved' % (event.id, event.title)) except IntegrityError: pass
def get_single_race(self, market_id): events = self.client.list_events(filter=MarketFilter( market_ids=[market_id])) if len(events) == 0: return [], [] # TODO: shouldn't these be returned as defaultdict? markets = defaultdict(list) for m in self.client.list_market_catalogue( MarketFilter(market_ids=[market_id]), market_projection=[ MarketProjection['RUNNER_DESCRIPTION'], MarketProjection['EVENT'], MarketProjection['MARKET_DESCRIPTION'], MarketProjection['MARKET_START_TIME'] ]): markets[m.event.id].append((m.market_id, m)) return events, markets
def get_market_types(competition): """ Retrieves list of market_types :param competition: :return: """ return client.list_market_types( MarketFilter(competition_ids=[competition.id], ), )
def test_list_events(self): delta = datetime.timedelta(seconds=24 * 60 * 60) to_time = datetime.datetime.now() + delta events = self.client.list_events( filter=MarketFilter(event_type_ids=['7'], market_countries=['GB', 'IRL'], market_start_time=TimeRange(to=to_time))) self.assertEqual(len(events), 6) self.assertEqual(events[2].event.id, '3453086') self.assertEqual(events[3].event.open_date, datetime.datetime(2017, 10, 25, 15, 30))
def update_market_list(self): markets = self.client.list_market_catalogue( MarketFilter( event_types_ids=self.event_type, turn_in_play_enabled=True, in_play_only=False, ), sort=MarketSort.FIRST_TO_START, max_results=1000, ) self.market_ids = [market["market_id"] for market in markets]
def test_list_markets(self): markets = self.client.list_market_catalogue( MarketFilter(event_ids=[123, 456, 789], market_type_codes=['WIN']), market_projection=[ MarketProjection['RUNNER_DESCRIPTION'], MarketProjection['EVENT'], MarketProjection['MARKET_DESCRIPTION'], MarketProjection['MARKET_START_TIME'] ]) self.assertEqual(len(markets), 27) self.assertEqual(len(markets[13].runners), 9) self.assertEqual(markets[26].runners[1].selection_id, 13161326)
def get_markets(self, event_id, text_query=""): get_logger().debug("asking for markets", event_id=event_id, text_query=text_query) markets = self.client.list_market_catalogue( MarketFilter(event_type_ids=soccer_type_ids, text_query=text_query, event_ids=[event_id]), max_results=100, market_projection=[v.name for v in MarketProjection], sort=MarketSort.MAXIMUM_TRADED) return markets
def fetch_competitions(self): event_types = self.db_client.get_event_types() for event_type in event_types: competitions = self.betfair_client.list_competitions( filter=MarketFilter(event_type_ids=[event_type.event_type_id])) for competition in competitions: id = competition.competition.id name = competition.competition.name region = competition.competition_region market_count = competition.market_count event_type_id = event_type.event_type_id self.db_client.add_competition(id, name, region, market_count, event_type_id) self.db_client.commit_changes()
def fetch_events(self): competitions = self.db_client.get_competitions() for competition in competitions: events = self.betfair_client.list_events(filter=MarketFilter( competition_ids=[competition.competition_id])) for event in events: event_id = event.event.id name = event.event.name country_code = event.event.country_code timezone = event.event.timezone venue = event.event.venue open_date = event.event.open_date market_count = event.market_count competition_id = competition.competition_id self.db_client.add_event(event_id, name, country_code, timezone, venue, open_date, market_count, competition_id) self.db_client.commit_changes()
def fetch_markets_runners(self): events = self.db_client.get_events() for event in events: markets = self.betfair_client.list_market_catalogue( filter=MarketFilter(event_ids=[event.event_id]), market_projection=[ "RUNNER_DESCRIPTION", 'MARKET_DESCRIPTION', 'MARKET_START_TIME', 'RUNNER_METADATA' ]) for market in markets: market_id = market.market_id name = market.market_name description = market.description.betting_type market_start_time = market.market_start_time event_id = event.event_id get_logger().info("adding market", market_name=name, market_id=market_id, description=description, market_start_time=market_start_time, event_id=event_id) db_market = self.db_client.add_market(market_id, name, market_start_time, description, event_id) for runner in market.runners: selection_id = runner.selection_id runner_name = runner.runner_name handicap = runner.handicap sort_priority = runner.sort_priority meta_data_id = None db_runner = self.db_client.add_runner( selection_id, runner_name, handicap, sort_priority, meta_data_id) if selection_id == 10084745: pass self.db_client.add_runner_map(db_market.market_id, db_runner.selection_id) self.db_client.commit_changes()
def get_markets_ids(competition, market_type_codes): """ Gets all the competition IDS in betfair for a given competiion and a given market_type :param competition: Betfair competition model :param market_type_codes: *String* Betfair market codes, to receive market_ids for games :return: List of betfair MarketCatalogues for inplay markets in the specified league MarketCatalogues will also contain information about the event and description about the runners """ return client.list_market_catalogue( MarketFilter( market_type_codes=[market_type_codes], competition_ids=[competition.id], # Only get games that are currently running/in play in_play_only=True), market_projection=[ MarketProjection.EVENT, MarketProjection.RUNNER_DESCRIPTION ] # also return details about market event )
marketFilter = { 'eventTypeIds': [7], 'marketCountries': ['GB'], 'marketTypeCodes': ["WIN"] } markets_hash = client.list_events(marketFilter) markets = [] print("WRITING TO DB") for market in markets_hash: if ((market.serialize()['event']['openDate'][:10] == date_today)): markets.append( client.list_market_catalogue( MarketFilter(event_ids=market.serialize()['event']['id'], market_type_codes='WIN'), market_projection=[MarketProjection(3), MarketProjection(7)])) for event in markets: for race in event: with connection.cursor() as cursor: cursor.execute( """INSERT IGNORE INTO races VALUES (%s,%s,%s,%s,%s,%s)""", (date_today, race.serialize()['event']['countryCode'], race.serialize()['event']['venue'], race.serialize()['marketStartTime'][11:19], race.serialize()['event']['id'] + ' / ' + race.serialize()['marketId'], race.serialize()['marketName'])) print("DONE")
def get_tennis_event(event_id): market_catalogue = client.list_market_catalogue( MarketFilter(event_ids=[event_id])) return market_catalogue
def getOdds(Sport, User = "******",input_time = "Null",Market = 'MATCH_ODDS'): import pandas as pd import login import pytz import datetime from time import gmtime, strftime from betfair import utils from betfair import models from betfair import exceptions from betfair.models import MarketFilter from betfair.models import PriceProjection from betfair.models import ExBestOffersOverrides from betfair.models import MarketData if User == "Tom": #Tom client = login.login('Np2HwoLYyAQk2X6s', 'tombish22','parksandrec19') else: # Cal client = login.login('eTnX7n6jsiaoGA9g', '*****@*****.**','wyeslsc10') # Grab the sports that match the string provided as an argument event_types = client.list_event_types(MarketFilter(text_query=Sport)) # Grab the ID of the requested sport sport_id = event_types[0].event_type.id # Pull the event details data for the sport and market specified as an argument betting_markets = client.list_market_catalogue(MarketFilter(event_type_ids=[sport_id], market_type_codes=[Market]), market_projection = ['COMPETITION','EVENT','EVENT_TYPE','RUNNER_DESCRIPTION','MARKET_START_TIME']) # #Gets the list of market IDs in the Betting Market sports_market_ids = [] for eachMarket in betting_markets: sports_market_ids = sports_market_ids + [eachMarket.market_id] # #Get the MarketBookResults maxpullsize = 100 index=0 # print len(sports_market_ids) marketbook_result = [] while index+maxpullsize < len(sports_market_ids): marketbook_result = marketbook_result + client.list_market_book([sports_market_ids[index:index+maxpullsize]],PriceProjection(price_data=['EX_BEST_OFFERS'],exBestOffersOverrides=ExBestOffersOverrides(best_prices_depth=1))) index=index+maxpullsize marketbook_result = marketbook_result + client.list_market_book([sports_market_ids[index:len(sports_market_ids)]],PriceProjection(price_data=['EX_BEST_OFFERS'],exBestOffersOverrides=ExBestOffersOverrides(best_prices_depth=1))) print 'Compiling Dataset' market_data = [] for market in betting_markets: next_market_data = MarketData(market,next((x for x in marketbook_result if x.market_id == market.market_id), None)) market_data.append(next_market_data) print 'Creating individual runner data' local = pytz.timezone ("Australia/Melbourne") runner_data = [] for mindex, market in enumerate(market_data): for rindex, runner in enumerate(market.runners): runner_to_add = {'market_id': market.market_id, 'market_name': market.market_name, 'market_start_time': market.market_start_time.replace(tzinfo=pytz.utc).astimezone(local).strftime("%Y-%m-%d %H:%M:%S"), 'market_start_time_dt': market.market_start_time.replace(tzinfo=pytz.utc).astimezone(local), #'total_matched':market.total_matched, #'active_runners':market.number_of_active_runners, 'status':market.status, #'total_available':market.total_available, #'total_matched':market.total_matched, #'selection_id':market.runner_catalog[rindex].selection_id, 'runner_name':market.runner_catalog[rindex].runner_name, 'price_selection_id':runner.selection_id, 'runner_status':runner.status } if len(runner.ex.available_to_back)>0: runner_to_add.update({ 'available_to_back_price':runner.ex.available_to_back[0].price, 'available_to_back_market':runner.ex.available_to_back[0].size }) if len(runner.ex.available_to_lay)>0: runner_to_add.update({ 'available_to_lay_price':runner.ex.available_to_lay[0].price, 'available_to_lay_market':runner.ex.available_to_lay[0].size }) runner_data.append(runner_to_add) MarketDf = pd.DataFrame(runner_data) dt_cutoff = datetime.datetime.now().replace(tzinfo = local) + datetime.timedelta(days=2) # Only interested in open markets MarketDf.query("status == 'OPEN'", inplace=True) # Filter markets for those starting in the next 2 days MarketDf = MarketDf[(MarketDf.market_start_time_dt <= dt_cutoff)] #Add a logged time MarketDf.loc[:,"log_time"] = input_time #Reorder the columns and select cols = ["log_time","market_start_time","market_id","market_name","runner_name","price_selection_id","available_to_back_price","available_to_back_market","available_to_lay_price","available_to_lay_market"] MarketDf = MarketDf.loc[:,cols] return MarketDf
def get_competition(name): c = client.list_competitions(MarketFilter(text_query=name)) if len(c) > 0: return c
#!/usr/bin/env python from betfair import Betfair import sys print "HugeHard Test Script" client = Betfair('fxmlhjiDhNghfmLP', 'C:/Users/Cong/Desktop/betfair/keys/shang.pem') client.login('*****@*****.**', 'wabjtam@123') print 'login successful' sys.exit from betfair.models import MarketFilter event_types = client.list_event_types(MarketFilter(text_query='basketball')) #print (len(event_types)) #print (event_types[0].event_type.name) football_event_type = event_types[0] competitions = client.list_competitions() for comp in competitions: a = comp['competition'] if a.name == u'NBA Matches': id_NBA = a.id events = client.list_events(MarketFilter(competition_ids=[id_NBA])) f = open('C:/Users/Cong/Desktop/betfair/log_basketball.txt', 'w') for eventResult in events: e = eventResult.event c = eventResult.market_count
tab = [] with open('events_schedule', 'r') as f: for line in f: tab.append(line.split(",")) race_time = tab[0][0] marketId = [[row[2][1:9], row[2][12:-1]] for row in tab] with open('temp_schedule', 'w+') as f: del tab[0] for row in tab: f.write(row[0] + ',' + row[1] + ',' + row[2]) rename('temp_schedule', 'events_schedule') hardcoded = marketId[0][1] runners = client.list_market_catalogue(MarketFilter(market_ids=hardcoded, market_type_codes='WIN'), market_projection=[MarketProjection(6)]) selectionId = [] runnerName = [] for i in range(len(runners[0].serialize()['runners'])): selectionId.append(runners[0].serialize()['runners'][i]['selectionId']) runnerName.append(runners[0].serialize()['runners'][i]['runnerName']) d = dict(zip(selectionId, runnerName)) level = 3 projection = { 'priceData': ['EX_BEST_OFFERS', 'SP_AVAILABLE', 'SP_TRADED'], 'virtualise': False, 'exBestOffersOverrides': {
def betfair_get(self, is_ip, counter, sport='Tennis'): start = timezone.now() ip = 'ip' if is_ip else 'ni' client = Betfair('GkhXY3b3KmncnwLe', 'certs/bf.pem') # client = Betfair('uv9hV1EjlFimHmgr', 'certs/bf.pem') client.login('sherst', 'osT1G11nRe35') client.keep_alive() tennis_event_type = self.sports[sport] markets = client.list_market_catalogue( MarketFilter(event_type_ids=[tennis_event_type], market_type_codes=["MATCH_ODDS"], in_play_only=is_ip), market_projection=["EVENT", "RUNNER_METADATA", "COMPETITION"], max_results=200) mids = [m.market_id for m in markets] mids_portions = [mids[x:x + 40] for x in xrange(0, len(mids), 40)] for mp in mids_portions: print(','.join(mp)) books = client.list_market_book( mp, price_projection=PriceProjection( price_data=betfair.constants.PriceData.EX_BEST_OFFERS)) for b in books: m = next((x for x in markets if x.market_id == b.market_id), None) if m.competition == None: continue bfcid = m.competition.id champname = m.competition.name country = m.event.country_code event_id = m.event.id ds = timezone.make_aware(m.event.open_date) p1 = m.runners[0].runner_name if (p1 == None or '/' in p1): continue rid1 = m.runners[0].selection_id p2 = m.runners[1].runner_name rid2 = m.runners[1].selection_id event, created = BFEvent.objects.get_or_create(bfid=event_id) if (created): champ = self.save_champ(bfcid, champname, tennis_event_type, country) player1 = self.save_player(p1) player2 = self.save_player(p2) event.cid = champ event.rid1 = rid1 event.rid2 = rid2 event.pid1 = player1 event.pid2 = player2 event.dt = ds event.status = 1 if is_ip else 0 event.save() p1b1_odds = b.runners[0].ex.available_to_back[0].price if len( b.runners[0].ex.available_to_back) > 0 else 0 p1b1_size = b.runners[0].ex.available_to_back[0].size if len( b.runners[0].ex.available_to_back) > 0 else 0 p1l1_odds = b.runners[0].ex.available_to_lay[0].price if len( b.runners[0].ex.available_to_lay) > 0 else 0 p1l1_size = b.runners[0].ex.available_to_lay[0].size if len( b.runners[0].ex.available_to_lay) > 0 else 0 p2b1_odds = b.runners[1].ex.available_to_back[0].price if len( b.runners[1].ex.available_to_back) > 0 else 0 p2b1_size = b.runners[1].ex.available_to_back[0].size if len( b.runners[1].ex.available_to_back) > 0 else 0 p2l1_odds = b.runners[1].ex.available_to_lay[0].price if len( b.runners[1].ex.available_to_lay) > 0 else 0 p2l1_size = b.runners[1].ex.available_to_lay[0].size if len( b.runners[1].ex.available_to_lay) > 0 else 0 if (self.is_debug): self.stdout.write('*** evid [%s] %s - %s at %s, changed %s\n' % (event.id, event.pid1.name, event.pid2.name, event.dt, event.dtc), ending='') try: odds = BFOdds.objects.filter(eid=event).latest('dtc') if (odds.b1odds != p1b1_odds or odds.b2odds != p2b1_odds or odds.l1odds != p1l1_odds or odds.l2odds != p2l1_odds): self.save_odds(event, p1b1_odds, p2b1_odds, p1l1_odds, p2l1_odds, p1b1_size, p2b1_size, p1l1_size, p2l1_size, is_ip) if (self.is_debug): self.stdout.write( 'evid[%s], mid[%s] %s %s - %s in %s: %s/%s\n' % (event_id, b.market_id, ds, p1.replace( '\\', ''), p2.replace('\\', ''), country, b.total_matched, b.total_available), ending='') self.stdout.write( '[%s]%s:%s@%s\t|%s@%s\n' % (rid1, p1.replace('\\', ''), p1b1_size, p1b1_odds, p1l1_size, p1l1_odds), ending='') self.stdout.write( '[%s]%s:%s@%s\t|%s@%s\n' % (rid2, p2.replace('\\', ''), p2b1_size, p2b1_odds, p2l1_size, p2l1_odds), ending='') except: self.save_odds(event, p1b1_odds, p2b1_odds, p1l1_odds, p2l1_odds, p1b1_size, p2b1_size, p1l1_size, p2l1_size, is_ip) if (self.is_debug): self.stdout.write( 'evid[%s], mid[%s] %s %s - %s in %s: %s/%s\n' % (event_id, b.market_id, ds, p1.replace( '\\', ''), p2.replace('\\', ''), country, b.total_matched, b.total_available), ending='') self.stdout.write('[%s]%s:%s@%s\t|%s@%s\n' % (rid1, p1.replace('\\', ''), p1b1_size, p1b1_odds, p1l1_size, p1l1_odds), ending='') self.stdout.write('[%s]%s:%s@%s\t|%s@%s\n' % (rid2, p2.replace('\\', ''), p2b1_size, p2b1_odds, p2l1_size, p2l1_odds), ending='') end = timezone.now() log = ALog() log.name = 'update_bf_%s_%s' % (sport, ip) log.dts = start log.counter = counter log.duration = (end - start).total_seconds() log.save() if (self.is_debug): self.stdout.write('total execution is %s seconds\n' % (end - start), ending='')
from betfair_wrapper.authenticate import authenticate from list_team import team_list, over_under client = authenticate() from betfair.models import MarketFilter event_types = client.list_event_types(MarketFilter(event_type_ids=[])) print(len(event_types)) for et in event_types: print(et.event_type.name) print(et.event_type.id) # 'Tennis' soccer_type_ids = [1] all_over_under = ','.join(over_under) market_porjection = [ "COMPETITION", "MARKET_START_TIME", "RUNNER_DESCRIPTION", "EVENT" ] markets = client.list_market_catalogue(MarketFilter( event_type_ids=soccer_type_ids, event_types=team_list, text_query="OVER_UNDER_*5"), market_projection=market_porjection, max_results=1000) print("here") #book = client.list_market_book(market_ids=) for market in markets: market._data["event_name"] = market._data["event"]["name"]
def test_event_types(self): event_types = self.client.list_event_types( MarketFilter(text_query='horse')) self.assertEqual(event_types[0].event_type.id, '7')
def get_competition_id(self, name): competitions = self.client.list_competitions( MarketFilter(text_query=name) ) for obj in competitions: return obj.competition.id
<<<<<<< HEAD client = login.login('eTnX7n6jsiaoGA9g', '*****@*****.**','wyeslsc10') ======= #client = login.login('eTnX7n6jsiaoGA9g', '*****@*****.**','wyeslsc10') client.keep_alive() >>>>>>> origin/master from betfair.models import MarketFilter from betfair.models import PriceProjection from betfair.models import ExBestOffersOverrides from betfair.models import MarketData MarketSearch = raw_input('Enter Sports String to search: ') event_types = client.list_event_types(MarketFilter(text_query=MarketSearch)) print 'Sports That Match: ' + str(len(event_types)) key = 0 for events in event_types: print 'Key : ' + str(key) + ' Sport: ' + events.event_type.name key = key+1 SportSearch = raw_input('Enter Key of Sport:') sport_event_type = event_types[int(SportSearch)] print 'Sport Selected: ' + event_types[int(SportSearch)].event_type.name + 'Sport ID: ' + str(sport_event_type.event_type.id) market_types = client.list_market_types(MarketFilter(event_type_ids=[sport_event_type.event_type.id])) key = 0 for markets in market_types:
import betfair from betfair import Betfair client = Betfair('eTnX7n6jsiaoGA9g', ('certs/client-2048.crt', 'certs/client-2048.key')) print 'Logging in' client.login('*****@*****.**', 'wyeslsc10') print 'Keeping alive' client.keep_alive() account_details = client.get_account_details() print account_details a = account_details.currency_code print a from betfair.models import MarketFilter event_types = client.list_event_types(MarketFilter(text_query='tennis')) print event_types print event_types[0] print event_types[0].event_type print(len(event_types)) # 2 print(event_types[0].event_type.name) # 'Tennis' tennis_event_type = event_types[0] markets = client.list_market_catalogue( MarketFilter(event_type_ids=[tennis_event_type.event_type.id])) print markets[0].market_name # 'Djokovic Tournament Wins' client.logout()
from betfair import models from betfair import exceptions #Tom #client = login.login('Np2HwoLYyAQk2X6s', 'tombish22','parksandrec19') # Cal client = login.login('eTnX7n6jsiaoGA9g', '*****@*****.**', 'wyeslsc10') from betfair.models import MarketFilter from betfair.models import PriceProjection from betfair.models import ExBestOffersOverrides from betfair.models import MarketData MarketSearch = raw_input('Enter Sports String to search: ') event_types = client.list_event_types(MarketFilter(text_query=MarketSearch)) print 'Sports That Match: ' + str(len(event_types)) key = 0 for events in event_types: print 'Key : ' + str(key) + ' Sport: ' + events.event_type.name key = key + 1 SportSearch = raw_input('Enter Key of Sport:') sport_event_type = event_types[int(SportSearch)] print 'Sport Selected: ' + event_types[int( SportSearch)].event_type.name + 'Sport ID: ' + str( sport_event_type.event_type.id) market_types = client.list_market_types( MarketFilter(event_type_ids=[sport_event_type.event_type.id]))
#!/usr/bin/env python from betfair import Betfair import sys print "HugeHard Test Script" client = Betfair('fxmlhjiDhNghfmLP', '/home/shang/git/betfair.py/certs/betfair.pem') client.login('*****@*****.**', 'wabjtam@123') print 'login successful' from betfair.models import MarketFilter event_types = client.list_event_types(MarketFilter(text_query='soccer')) print(len(event_types)) print(event_types[0].event_type.name) football_event_type = event_types[0] events = client.list_events( MarketFilter(event_type_ids=[football_event_type.event_type.id])) for eventResult in events: e = eventResult.event c = eventResult.market_count print "id:" + e.id + ", name=" + e.name + ", market_count:" + str(c) markets = client.list_market_catalogue(MarketFilter(event_ids=[e.id])) for m in markets: print " - market: ", m.market_id, m.market_name #markets = client.list_market_catalogue( # MarketFilter(event_type_ids=[football_event_type.event_type.id]) #)