class Command(BaseCommand):
def __init__(self, *args, **kwargs):
super(Command, self).__init__(*args, **kwargs)
# Setup connection to Betfair API-NG
self.client = Betfair(settings.BETFAIR_APP, settings.BETFAIR_CERT)
self.client.login(settings.BETFAIR_USER, settings.BETFAIR_PASS)
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_competition_id(self, name):
competitions = self.client.list_competitions(
MarketFilter(text_query=name)
)
for obj in competitions:
return obj.competition.id
connection = pymysql.connect(host='localhost',
user='******',
password='******',
db='DATABASE NAME',
charset='utf8mb4',
autocommit=True,
cursorclass=pymysql.cursors.DictCursor)
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(
class Container(object, metaclass=Singleton):
interested_types = ['WIN']
refresh_interval = 1
pre_match_interval = 30
historic_data_url = r'https://historicdata.betfair.com/api/GetMyData'
def __init__(self, sandbox_key=False):
self.selected_events = {}
self.markets = {}
self.client = None
self.sandbox_key = sandbox_key # if true use sandbox,, if false use prod
self.do_login()
def do_login(self):
__location = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
username = config.get('Betfair', 'username')
password = config.get('Betfair', 'password')
certfile = config.get('Betfair', 'cert_file')
devkey = config.get('Betfair', 'dev_app')
prodkey = config.get('Betfair', 'prod_app')
full_certfile = os.path.join(__location, certfile)
self.client = Betfair(prodkey if not self.sandbox_key else devkey,
full_certfile)
self.client.login(username, password)
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_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 update_markets(self, events, markets):
pp = PriceProjection(price_data=[
'EX_BEST_OFFERS', 'EX_TRADED', 'SP_AVAILABLE', 'SP_TRADED'
])
market_ids = []
for m in markets.values():
for r in m:
market_ids.append(r[0])
markets_resp = []
for market_list in _split_list(market_ids):
markets_resp.extend(
self.client.list_market_book(market_ids=market_list,
price_projection=pp))
return markets_resp
def get_single_market(self, market_id):
pp = PriceProjection(
price_data=['EX_BEST_OFFERS', 'SP_AVAILABLE', 'SP_TRADED'])
markets = self.client.list_market_book(market_ids=[market_id],
price_projection=pp)
return markets
def place_limit_order(self,
market,
selection,
stake,
odds,
side='BACK',
persist='LAPSE',
strategy=None):
persist = config.getboolean("Betting", "persist")
persist = 'LAPSE' if persist == False else 'PERSIST'
bet = LimitOrder(
size=max(2, stake)
if side == 'BACK' else stake, # stake is minimum 2 GBP
price=odds,
persistence_type=persist)
order = PlaceInstruction(order_type='LIMIT',
selection_id=int(selection),
side=side,
limit_order=bet)
return self.client.place_orders(market, [order],
customer_ref="MRE-{}-{}".format(
market, selection),
strategy_ref=strategy)
def place_fill_or_kill(self,
market,
selection,
stake,
odds,
side='BACK',
strategy=None):
bet = LimitOrder(
size=max(2, stake) if side == 'BACK' else stake,
price=odds,
persistence_type='LAPSE',
time_in_force='FILL_OR_KILL',
min_fill_size=max(2, stake) if side == 'BACK' else stake)
order = PlaceInstruction(order_type='LIMIT',
selection_id=int(selection),
side=side,
limit_order=bet)
return self.client.place_orders(market, [order],
customer_ref="MRE-{}-{}".format(
market, selection),
strategy_ref=strategy)
def welcome_message(self):
acc = self.client.get_account_details()
first_name = acc['first_name']
acc = self.client.get_account_funds()
funds = acc.available_to_bet_balance
return "Welcome %s, your account balance is %s" % (first_name, funds)
def get_open_orders(self):
"""
Get current unfilled orders by market
:return: dictionary of list of orders
"""
projection = OrderProjection['EXECUTABLE']
orders = self.client.list_current_orders(order_projection=projection)
orders_by_market = defaultdict(list)
for o in orders.current_orders:
orders_by_market[o.market_id].append(o)
return orders_by_market
def replace_orders(self, market, bet_ids, new_prices):
"""
Replace current orders with new prices
:param market:
:param bet_ids:
:param new_prices:
:return:
"""
instructions = []
for bet_id, np in zip(bet_ids, new_prices):
instruction = ReplaceInstruction(bet_id=bet_id, new_price=np)
instructions.append(instruction)
return self.client.replace_orders(market_id=market,
instructions=instructions)
def get_cleared_orders(self,
from_time=datetime.datetime.today() +
datetime.timedelta(-1)):
orders = self.client.list_cleared_orders(
event_type_ids=[7],
bet_status='SETTLED',
settled_date_range=TimeRange(from_=from_time))
trades_df = pd.DataFrame.from_records(
[x.values() for x in orders['cleared_orders']])
total_commission = 0.
if not trades_df.empty:
trades_df.columns = orders['cleared_orders'][0].keys()
total_commission_req = self.client.list_cleared_orders(
event_type_ids=[7],
bet_status='SETTLED',
group_by='EVENT_TYPE',
settled_date_range=TimeRange(from_=from_time))
total_commission = total_commission_req['cleared_orders'][
0].commission
return trades_df, total_commission
def get_account_balance(self):
result = self.client.get_account_funds()
return {k: result.get(k) for k in result.keys()}
def get_race_status(self, events):
results = self.client.list_race_details(events)
if results:
return pd.DataFrame.from_records([x.values() for x in results],
columns=results[0].keys())
def download_historic_data(self, start, end, countries=('GB', 'IE')):
ssoid = self.client.session_token
headers = {'ssoid': ssoid}
d = {
"sport": "Horse Racing",
"plan": "Basic Plan",
"fromDay": start.day,
"fromMonth": start.month,
"fromYear": start.year,
"toDay": end.day,
"toMonth": end.month,
"toYear": end.year,
"marketTypesCollection": ["WIN"],
"countriesCollection": list(countries),
"fileTypeCollection": ["M"]
}
response = requests.get(
'https://historicdata.betfair.com/api/DownloadListOfFiles',
params=d,
headers=headers)
file_names = json.loads(response.text)
races = []
def inner(f):
race_data = requests.get(
'http://historicdata.betfair.com/api/DownloadFile',
params={'filePath': f},
headers=headers)
race_str = bz2.decompress(race_data.content).decode('utf8')
return BetFairRace.create_from_json(race_str)
pool = ThreadPool()
for file in file_names:
races.append(pool.apply_async(inner, args=tuple([file])))
pool.close()
pool.join()
return [r.get() for r in races]
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
# 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:
f.write(m.market_id + ' ' + m.market_name + ' ' + ' ' + str(e['id']) +
' ' + str(e['name']) + '\n')
f.write('***' + str(e['country_code']) + '...\n')
f.close()
client.logout()
#print 'logout successful'
#
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])
#)
#for m in markets:
# print m.market_name