def test_limit_order(self):
response = limit_order(size=1.1, price=123, persistence_type="LAPSE")
assert response == {
"size": 1.1,
"price": 123,
"persistenceType": "LAPSE"
}
def place_order():
file = open("dict.txt")
x = file.read()
y = literal_eval(x)
file = open("dict_old.txt")
a = file.read()
b = literal_eval(a)
for k in y:
if k not in b:
print(k)
# placing an order
market_id = k.split("/")[0]
selection_id = k.split("/")[1]
limit_order = filters.limit_order(size=2.00,
price=y[k],
persistence_type="LAPSE")
instruction = filters.place_instruction(
order_type="LIMIT",
selection_id=selection_id,
side="BACK",
limit_order=limit_order,
)
place_orders = trading.betting.place_orders(
market_id=market_id,
instructions=[instruction] # list
)
print(place_orders.status)
for order in place_orders.place_instruction_reports:
print(
"Status: %s, BetId: %s, Average Price Matched: %s " %
(order.status, order.bet_id, order.average_price_matched))
def place_order(trading, price, side, size, selection_id, market_id):
# Define a limit order filter
limit_order_filter = filters.limit_order(
size=size,
price=price,
# if not filled the bet, kill it
time_in_force='FILL_OR_KILL',
persistence_type='LAPSE')
instructions_filter = filters.place_instruction(
selection_id=selection_id,
order_type="LIMIT",
side=side.upper(),
limit_order=limit_order_filter)
# Place the order
order = trading.betting.place_orders(market_id=market_id,
instructions=[instructions_filter])
status = order.__dict__['_data']['instructionReports'][0][
'status'] == 'SUCCESS'
sizeMatched = order.__dict__['_data']['instructionReports'][0][
'sizeMatched'] > 0
return status and sizeMatched
def test_limit_order(self):
response = limit_order(size=1.1, price=123, persistence_type='LAPSE')
assert response == {
'size': 1.1,
'price': 123,
'persistenceType': 'LAPSE'
}
def order_submit_to_betfair(command: SubmitOrder,
instrument: BettingInstrument,
customer_ref="1"):
""" Convert a SubmitOrder command into the data required by betfairlightweight """
order = command.order # type: LimitOrder
return {
"market_id":
instrument.market_id,
# Used to de-dupe orders on betfair server side
"customer_ref":
order.client_order_id.value,
"customer_strategy_ref":
customer_ref,
"instructions": [
place_instruction(
order_type="LIMIT",
selection_id=instrument.selection_id,
side=N2B_SIDE[order.side],
handicap={"0.0": "0"}.get(instrument.selection_handicap,
instrument.selection_handicap),
limit_order=limit_order(
size=float(order.quantity),
price=float(
probability_to_price(probability=order.price,
side=order.side)),
persistence_type="PERSIST",
time_in_force=N2B_TIME_IN_FORCE[order.time_in_force],
min_fill_size=0,
),
customer_order_ref=order.client_order_id.value,
)
],
}
def place_instruction(self) -> dict:
return limit_order(
size=self.size,
price=self.price,
persistence_type=self.persistence_type,
time_in_force=self.time_in_force,
min_fill_size=self.min_fill_size,
bet_target_type=self.bet_target_type,
bet_target_size=self.bet_target_size,
)
def place_order(self, size, price, market_id, selection_id, side, ref):
order = limit_order(size=size, price=price, persistence_type='LAPSE')
instruction = place_instruction(order_type='LIMIT',
selection_id=selection_id,
side=side,
limit_order=order,
customer_order_ref=ref)
place_orders = self._client.betting.place_orders(
market_id=market_id,
instructions=[instruction] # list
)
# TODO check order.status
return place_orders
def place_order():
# placing an order
limit_order = filters.limit_order(size=2.00,
price=1.01,
persistence_type='LAPSE')
instruction = filters.place_instruction(order_type='LIMIT',
selection_id=selection_id,
side='LAY',
limit_order=limit_order)
place_orders = trading.betting.place_orders(
market_id=market_id,
instructions=[instruction] # list
)
print(place_orders.status)
for order in place_orders.place_instruction_reports:
print('Status: %s, BetId: %s, Average Price Matched: %s ' %
(order.status, order.bet_id, order.average_price_matched))
def order_submit_to_betfair(command: SubmitOrder,
instrument: BettingInstrument):
"""
Convert a SubmitOrder command into the data required by betfairlightweight
"""
order = command.order # type Order
price = determine_order_price(order)
return {
"market_id":
instrument.market_id,
# Used to de-dupe orders on betfair server side
"customer_ref":
command.id.value.replace("-", ""),
"customer_strategy_ref":
command.strategy_id.value[:15],
"instructions": [
place_instruction(
order_type="LIMIT",
selection_id=instrument.selection_id,
side=N2B_SIDE[order.side],
handicap={"0.0": "0"}.get(instrument.selection_handicap,
instrument.selection_handicap),
limit_order=limit_order(
size=float(order.quantity),
price=float(
probability_to_price(probability=price,
side=order.side)),
persistence_type="PERSIST",
time_in_force=N2B_TIME_IN_FORCE[order.time_in_force],
min_fill_size=0,
),
# Remove the strategy name from customer_order_ref; it has a limited size and we don't control what
# length the strategy might be or what characters users might append
customer_order_ref=make_custom_order_ref(
client_order_id=order.client_order_id,
strategy_id=command.strategy_id,
),
)
],
}
def create_bets(pk):
"""
Place bets with the specified margin.
Can place back and lay side bets.
"""
trading = get_betfair_client()
race = Race.objects.get(pk=pk)
market = race.win_market
# establish margin bracket of betting
secs_left = (race.start_time - timezone.now()).total_seconds()
bracket = secs_left // 60
margin = MARGIN_BRACKETS.get(bracket)
if not margin:
logger.error(f'$$$ Huge minutes for {market}: {bracket}')
return
logger.warning(
f'$$$ Betting on {race} in {bracket} bracket margin {margin}')
# cancel all existing bets
cancel_bets(market)
ix = []
ix_info = {}
for runner in race.runner_set.all():
try:
bf_runner = market.runner_set.get(
cloth_number=runner.runner_number)
except Exception as e:
logger.info(f'$$$ No betfair {runner} {e}')
continue
matched_bets = bf_runner.matched_bets()
if matched_bets:
logger.info(f'$$$ Runner already has bet {matched_bets}')
continue
fo = runner.fixedodd_set.first()
if not fo:
logger.info(f'$$$ Runner already has no tab odds {runner}')
continue
est = fo.win_est
if est < 0.09:
logger.info(f'$$$ Bad odds for {runner} {est}')
continue
# back
# est desire 10% odds highestLay trade
# 20% 18% 4.55 4.60 4.70 => 4.70
# 20% 18% 4.55 4.50 4.60 => 4.60
# 20% 18% 4.55 4.40 4.50 => 4.55
back_desire = 1 / (est * (1 - margin))
back_price = max(back_desire, runner.trade or float('-inf'), runner.lay
or float('-inf'))
ix.append(
place_instruction('LIMIT',
bf_runner.selection_id,
'BACK',
limit_order=limit_order(
persistence_type='LAPSE',
size=AMOUNT,
price=get_odds(back_price))))
logger.info(
f'$$$ Placed bet {runner.runner_number}: BACK {back_price}')
# lay
# est desire 10% odds lowestBack trade
# 20% 22% 4.55 4.70 4.60 => 4.55
# 20% 22% 4.55 4.60 4.50 => 4.50
# 20% 22% 4.55 4.50 4.40 => 4.40
lay_desire = 1 / (est * (1 + margin))
lay_price = min(lay_desire, runner.trade or float('inf'), runner.lay
or float('inf'))
ix.append(
place_instruction('LIMIT',
bf_runner.selection_id,
'LAY',
limit_order=limit_order(
persistence_type='LAPSE',
size=AMOUNT,
price=get_odds(lay_price))))
logger.info(f'$$$ Placed bet {runner.runner_number}: BACK {lay_price}')
ix_info[bf_runner.selection_id] = {
'bf_runner': bf_runner,
'est': est,
'back_price': back_price,
'lay_price': lay_price,
'back': runner.back,
'lay': runner.lay,
'trade': runner.trade,
'margin': margin,
'bracket': bracket,
}
if not ix:
logger.error(f'$$$ No ix for {race}')
return
# place orders
res = trading.betting.place_orders(market.market_id,
instructions=ix,
lightweight=True)
# print(json.dumps(res, indent=4, default=str, sort_keys=True))
if res['status'] != 'SUCCESS':
for bet_info in res['instructionReports']:
logger.error(f'{bet_info["status"]} {bet_info["errorCode"]}')
raise Exception(f'$$$ Market {res["marketId"]}: {res["errorCode"]}')
for ix in res['instructionReports']:
bet_info = ix_info[ix['instruction']['selectionId']]
if ix['instruction']['side'] == 'BACK':
liability = ix['instruction']['limitOrder']['size']
payout = ix['instruction']['limitOrder']['size'] * (
ix['instruction']['limitOrder']['price'] - 1)
else:
liability = ix['instruction']['limitOrder']['size'] * (
ix['instruction']['limitOrder']['price'] - 1)
payout = ix['instruction']['limitOrder']['size']
bet = Bet(market=market,
runner=bet_info['bf_runner'],
bet_id=ix['betId'],
est=bet_info['est'],
trade=bet_info['trade'],
back=bet_info['back'],
lay=bet_info['lay'],
margin=margin,
bracket=bracket,
payout=payout,
liability=liability,
status=ix['orderStatus'],
placed_at=parse_datetime(ix['placedDate']),
size_matched=ix['sizeMatched'],
order_type=ix['instruction']['orderType'],
side=ix['instruction']['side'],
persistence_type=ix['instruction']['limitOrder']
['persistenceType'],
price=ix['instruction']['limitOrder']['price'],
size=ix['instruction']['limitOrder']['size'])
bet.save()
logger.warning(f'$$$ Created {bet}')
logger.warning(f'$$$ Placed {len(ix)} bets for {market}')