def process_market_book(self, market, market_book): # get lowest price runner prices = [(r.selection_id, r.last_price_traded) for r in market_book.runners if r.status == "ACTIVE"] prices.sort(key=lambda tup: tup[1]) selection_id = prices[0][0] if prices[0][1] > 3: return for runner in market_book.runners: if runner.selection_id == selection_id: # lay at current best lay price lay = get_price(runner.ex.available_to_lay, 0) trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) order = trade.create_order( side="LAY", order_type=LimitOrder(lay, self.context["stake"]), ) self.place_order(market, order)
def process_market_book(self, market, market_book): for runner in market_book.runners: if runner.last_price_traded < 2: lay = get_price(runner.ex.available_to_lay, 0) trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) order = trade.create_order( side="LAY", order_type=LimitOrder(lay, 2.00), ) self.place_order(market, order)
def process_market_book(self, market, market_book): # process marketBook object for runner in market_book.runners: if (runner.status == "ACTIVE" and runner.last_price_traded and runner.selection_id == 11982403): trade = Trade( market_id=market_book.market_id, selection_id=runner.selection_id, handicap=runner.handicap, strategy=self, ) order = trade.create_order(side="LAY", order_type=LimitOrder(price=1.01, size=2.00)) self.place_order(market, order)
def process_market_book(self, market, market_book): for runner in market_book.runners: runner_context = self.get_runner_context( market.market_id, runner.selection_id ) if runner_context.trade_count == 0: trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) order = trade.create_order( side="LAY", order_type=MarketOnCloseOrder(100.00), ) self.place_order(market, order)
def process_market_book(self, market, market_book): with market.transaction() as t: for runner in market_book.runners: if runner.status == "ACTIVE": runner_context = self.get_runner_context( market.market_id, runner.selection_id) if runner_context.trade_count == 0: trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) order = trade.create_order( side="BACK", order_type=LimitOrder(1000, 2.00), ) t.place_order(order)
def process_market_book(self, market, market_book): with market.transaction(client=self.context["client"]) as t: for runner in market_book.runners: if runner.status == "ACTIVE": back = get_price(runner.ex.available_to_back, 0) runner_context = self.get_runner_context( market.market_id, runner.selection_id) if runner_context.trade_count == 0: trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) order = trade.create_order( side="BACK", order_type=LimitOrder(back, 2.00), ) t.place_order(order)
def process_market_book(self, market, market_book): seconds_since_start = (market_book.publish_time_epoch - market.context["start_time"]) / 1e3 # get price dict from market context if "price" not in market.context: market.context["price"] = defaultdict(list) price_dict = market.context["price"] for runner in market_book.runners: # store latest prices/sizes back_price = get_price(runner.ex.available_to_back, 0) back_size = get_size(runner.ex.available_to_back, 0) if back_price: price_dict[runner.selection_id].append( (market_book.publish_time_epoch, back_price, back_size)) # check trigger if trigger(price_dict[runner.selection_id]): runner_context = self.get_runner_context( market.market_id, runner.selection_id, runner.handicap) if runner_context.live_trade_count == 0: # back at current best back price back = get_price(runner.ex.available_to_back, 0) if back is None: continue # create trade trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) # create order order = trade.create_order( side="BACK", order_type=LimitOrder(back, self.context["stake"]), notes=OrderedDict( seconds_since_start=round(seconds_since_start, 2), back_size=back_size, ), ) # place order for execution market.place_order(order)
def process_market_book(self, market, market_book): # get lowest price runner prices = [(r.selection_id, r.last_price_traded) for r in market_book.runners if r.status == "ACTIVE" and r.last_price_traded] if not prices: return prices.sort(key=lambda tup: tup[1]) selection_id = prices[0][0] if prices[0][1] > 3: return # calculate market underround for later analysis underround = _calculate_underround(market_book.runners) for runner in market_book.runners: if runner.selection_id == selection_id: runner_context = self.get_runner_context( market.market_id, runner.selection_id, runner.handicap) if runner_context.live_trade_count == 0: # lay at current best lay price lay = get_price(runner.ex.available_to_lay, 0) # create trade trade = Trade( market_book.market_id, runner.selection_id, runner.handicap, self, ) # create order order = trade.create_order( side="LAY", order_type=LimitOrder(lay, self.context["stake"]), notes=OrderedDict(underround=round(underround, 4)), ) # place order for execution market.place_order(order)
def process_market_book(self, market, market_book): # get context selections = self.context["selections"] for selection in selections: if market_book.market_id == selection["market_id"]: for runner in market_book.runners: runner_context = self.get_runner_context( market.market_id, runner.selection_id, runner.handicap) if runner_context.trade_count > 0: continue if (runner.status == "ACTIVE" and runner.selection_id == selection["selection_id"]): trade = Trade( market_id=market_book.market_id, selection_id=runner.selection_id, handicap=runner.handicap, strategy=self, ) order = trade.create_order( side=selection["side"], order_type=LimitOrder(price=1.01, size=selection["liability"]), ) market.place_order(order)
class TradeTest(unittest.TestCase): def setUp(self) -> None: logging.disable(logging.CRITICAL) mock_client = mock.Mock(paper_trade=False) self.mock_strategy = mock.Mock(client=mock_client) self.mock_fill_kill = mock.Mock() self.mock_offset = mock.Mock() self.mock_green = mock.Mock() self.notes = collections.OrderedDict({"trigger": 123}) self.trade = Trade( "1.234", 567, 1.0, self.mock_strategy, self.notes, self.mock_fill_kill, self.mock_offset, self.mock_green, 12, 34, ) def test_init(self): self.assertEqual(self.trade.market_id, "1.234") self.assertEqual(self.trade.selection_id, 567) self.assertEqual(self.trade.handicap, 1.0) self.assertEqual(self.trade.strategy, self.mock_strategy) self.assertEqual(self.trade.notes, self.notes) self.assertEqual(self.trade.fill_kill, self.mock_fill_kill) self.assertEqual(self.trade.offset, self.mock_offset) self.assertEqual(self.trade.green, self.mock_green) self.assertEqual(self.trade.status_log, []) self.assertEqual(self.trade.orders, []) self.assertEqual(self.trade.offset_orders, []) self.assertIsNotNone(self.trade.date_time_created) self.assertIsNone(self.trade.date_time_complete) self.assertIsNone(self.trade.market_notes) self.assertEqual(self.trade.place_reset_seconds, 12) self.assertEqual(self.trade.reset_seconds, 34) @mock.patch("flumine.order.trade.get_market_notes") def test_update_market_notes(self, mock_get_market_notes): mock_market = mock.Mock() self.trade.update_market_notes(mock_market) self.assertEqual(self.trade.market_notes, mock_get_market_notes()) def test__update_status(self): self.trade._update_status(TradeStatus.COMPLETE) self.assertEqual(self.trade.status_log, [TradeStatus.COMPLETE]) self.assertEqual(self.trade.status, TradeStatus.COMPLETE) @mock.patch("flumine.order.trade.Trade._update_status") def test_complete_trade(self, mock__update_status): self.trade.complete_trade() mock__update_status.assert_called_with(TradeStatus.COMPLETE) runner_context = self.mock_strategy.get_runner_context( self.trade.market_id, self.trade.selection_id, self.trade.handicap ) runner_context.reset.assert_called_with() self.assertIsNotNone(self.trade.date_time_complete) def test_complete(self): self.assertTrue(self.trade.complete) mock_order = mock.Mock(complete=False) self.trade.orders.append(mock_order) self.assertFalse(self.trade.complete) def test_trade_complete_offset(self): self.trade.offset_orders = [1] self.assertFalse(self.trade.complete) def test_trade_complete_replace_order(self): self.assertTrue(self.trade.complete) mock_order = mock.Mock(complete=True) self.trade.status = TradeStatus.COMPLETE self.trade.orders.append(mock_order) self.assertFalse(self.trade.complete) def test_create_order(self): mock_order_type = mock.Mock() mock_order_type.EXCHANGE = "SYM" mock_order = mock.Mock() mock_order.EXCHANGE = "SYM" self.trade.create_order("BACK", mock_order_type, handicap=1, order=mock_order) self.assertEqual(self.trade.orders, [mock_order()]) def test_create_order_error(self): mock_order_type = mock.Mock() mock_order_type.EXCHANGE = "SYM" mock_order = mock.Mock() mock_order.EXCHANGE = "MYS" with self.assertRaises(OrderError): self.trade.create_order( "BACK", mock_order_type, handicap=1, order=mock_order ) def test_create_order_replacement(self): mock_order = mock.Mock() replacement_order = self.trade.create_order_replacement(mock_order, 12) self.assertEqual(self.trade.orders, [replacement_order]) def test_create_order_from_current_limit(self): mock_current_order = mock.Mock() mock_current_order.order_type = "LIMIT" order = self.trade.create_order_from_current(mock_current_order, "12345") self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(self.trade.orders, [order]) def test_create_order_from_current_limit_on_close(self): mock_current_order = mock.Mock() mock_current_order.order_type = "LIMIT_ON_CLOSE" order = self.trade.create_order_from_current(mock_current_order, "12345") self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(self.trade.orders, [order]) def test_create_order_from_current_market_on_close(self): mock_current_order = mock.Mock() mock_current_order.order_type = "MARKET_ON_CLOSE" order = self.trade.create_order_from_current(mock_current_order, "12345") self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(self.trade.orders, [order]) def test_create_order_from_current_unknown(self): mock_current_order = mock.Mock() mock_current_order.order_type = "BE" with self.assertRaises(NotImplementedError): self.trade.create_order_from_current(mock_current_order, "12345") def test_client(self): self.assertEqual(self.trade.client, self.mock_strategy.client) def test_notes_str(self): self.trade.notes = collections.OrderedDict({"1": 1, 2: "2", 3: 3, 4: "four"}) # self.assertEqual(self.trade.notes_str, "1,2,3,four") self.trade.notes = collections.OrderedDict() self.assertEqual(self.trade.notes_str, "") def test_info(self): self.assertEqual( self.trade.info, { "id": self.trade.id, "orders": [], "status": TradeStatus.LIVE, "strategy": self.mock_strategy, "notes": "123", "market_notes": None, }, ) @mock.patch("flumine.order.trade.Trade._update_status") def test_enter_exit(self, mock__update_status): with self.trade: mock__update_status.assert_called_with(TradeStatus.PENDING) mock__update_status.assert_called_with(TradeStatus.LIVE) @mock.patch("flumine.order.trade.Trade._update_status") def test_enter_error(self, mock__update_status): with self.assertRaises(ValueError): with self.trade: raise ValueError() mock__update_status.assert_called_with(TradeStatus.PENDING)
class TradeTest(unittest.TestCase): def setUp(self) -> None: logging.disable(logging.CRITICAL) mock_client = mock.Mock(paper_trade=False) self.mock_strategy = mock.Mock(client=mock_client) self.notes = collections.OrderedDict({"trigger": 123}) self.trade = Trade( "1.234", 567, 1.0, self.mock_strategy, self.notes, 12, 34, ) def test_init(self): self.assertEqual(self.trade.market_id, "1.234") self.assertEqual(self.trade.selection_id, 567) self.assertEqual(self.trade.handicap, 1.0) self.assertEqual(self.trade.strategy, self.mock_strategy) self.assertEqual(self.trade.notes, self.notes) self.assertEqual(self.trade.status_log, []) self.assertEqual(self.trade.orders, []) self.assertEqual(self.trade.offset_orders, []) self.assertIsNotNone(self.trade.date_time_created) self.assertIsNone(self.trade.date_time_complete) self.assertIsNone(self.trade.market_notes) self.assertEqual(self.trade.place_reset_seconds, 12) self.assertEqual(self.trade.reset_seconds, 34) @mock.patch("flumine.order.trade.Trade.complete_trade") @mock.patch( "flumine.order.trade.Trade.complete", new_callable=mock.PropertyMock, return_value=True, ) def test__update_status(self, mock_complete, mock_complete_trade): self.trade._update_status(TradeStatus.COMPLETE) self.assertEqual(self.trade.status_log, [TradeStatus.COMPLETE]) self.assertEqual(self.trade.status, TradeStatus.COMPLETE) mock_complete_trade.assert_called() @mock.patch("flumine.order.trade.Trade._update_status") def test_complete_trade(self, mock__update_status): self.trade.complete_trade() mock__update_status.assert_called_with(TradeStatus.COMPLETE) runner_context = self.mock_strategy.get_runner_context( self.trade.market_id, self.trade.selection_id, self.trade.handicap ) runner_context.reset.assert_called_with(self.trade.id) self.assertIsNotNone(self.trade.date_time_complete) def test_complete(self): self.assertTrue(self.trade.complete) mock_order = mock.Mock(complete=False) self.trade.orders.append(mock_order) self.assertFalse(self.trade.complete) def test_trade_complete_offset(self): self.trade.offset_orders = [mock.Mock(complete=False)] self.assertFalse(self.trade.complete) self.trade.offset_orders = [mock.Mock(complete=True)] self.assertTrue(self.trade.complete) def test_trade_complete_replace_order(self): self.assertTrue(self.trade.complete) mock_order = mock.Mock(complete=True) self.trade.status = TradeStatus.COMPLETE self.trade.orders.append(mock_order) self.assertFalse(self.trade.complete) def test_create_order(self): mock_order_type = mock.Mock(EXCHANGE="SYM") mock_order = mock.Mock(EXCHANGE="SYM") self.trade.create_order( "BACK", mock_order_type, order=mock_order, sep="-", context={1: 2} ) mock_order.assert_called_with( trade=self.trade, side="BACK", order_type=mock_order_type, handicap=self.trade.handicap, sep="-", context={1: 2}, notes=None, ) self.assertEqual(self.trade.orders, [mock_order()]) def test_create_order_error(self): mock_order_type = mock.Mock(EXCHANGE="SYM") mock_order = mock.Mock(EXCHANGE="MYS") with self.assertRaises(OrderError): self.trade.create_order("BACK", mock_order_type, order=mock_order) def test_create_order_replacement(self): mock_order = mock.Mock(sep="-") replacement_order = self.trade.create_order_replacement(mock_order, 12, 2.00) self.assertEqual(self.trade.orders, [replacement_order]) self.assertEqual(replacement_order.trade, self.trade) self.assertEqual(replacement_order.side, mock_order.side) self.assertEqual(replacement_order.order_type.price, 12) self.assertEqual(replacement_order.order_type.size, 2.00) self.assertEqual( replacement_order.order_type.persistence_type, mock_order.order_type.persistence_type, ) self.assertEqual(replacement_order.handicap, mock_order.handicap) self.assertEqual(replacement_order.sep, mock_order.sep) self.assertEqual(replacement_order.context, mock_order.context) self.assertEqual(replacement_order.notes, mock_order.notes) self.assertEqual(replacement_order.client, mock_order.client) def test_create_order_from_current_limit(self): mock_client = mock.Mock() mock_current_order = mock.Mock( order_type="LIMIT", placed_date=12, matched_date=None, cancelled_date=34 ) order = self.trade.create_order_from_current( mock_client, mock_current_order, "12345" ) self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(order.client, mock_client) self.assertEqual(self.trade.orders, [order]) self.assertEqual(order.date_time_created, 12) self.assertEqual(order.date_time_execution_complete, 34) def test_create_order_from_current_limit_on_close(self): mock_client = mock.Mock() mock_current_order = mock.Mock(order_type="LIMIT_ON_CLOSE") order = self.trade.create_order_from_current( mock_client, mock_current_order, "12345" ) self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(order.client, mock_client) self.assertEqual(self.trade.orders, [order]) def test_create_order_from_current_market_on_close(self): mock_client = mock.Mock() mock_current_order = mock.Mock(order_type="MARKET_ON_CLOSE") order = self.trade.create_order_from_current( mock_client, mock_current_order, "12345" ) self.assertEqual(order.bet_id, mock_current_order.bet_id) self.assertEqual(order.id, "12345") self.assertEqual(order.client, mock_client) self.assertEqual(self.trade.orders, [order]) def test_create_order_from_current_unknown(self): mock_client = mock.Mock() mock_current_order = mock.Mock(order_type="BE") with self.assertRaises(NotImplementedError): self.trade.create_order_from_current( mock_client, mock_current_order, "12345" ) def test_notes_str(self): self.trade.notes = collections.OrderedDict({"1": 1, 2: "2", 3: 3, 4: "four"}) self.assertEqual(self.trade.notes_str, "1,2,3,four") self.trade.notes = collections.OrderedDict() self.assertEqual(self.trade.notes_str, "") def test_info(self): self.trade.status_log = [TradeStatus.PENDING, TradeStatus.COMPLETE] self.assertEqual( self.trade.info, { "id": str(self.trade.id), "orders": [], "offset_orders": [], "place_reset_seconds": 12, "reset_seconds": 34, "strategy": str(self.mock_strategy), "notes": "123", "market_notes": None, "status": "Live", "status_log": "Pending, Complete", }, ) @mock.patch("flumine.order.trade.Trade._update_status") def test_enter_exit(self, mock__update_status): with self.trade: mock__update_status.assert_called_with(TradeStatus.PENDING) mock__update_status.assert_called_with(TradeStatus.LIVE) @mock.patch("flumine.order.trade.Trade._update_status") def test_enter_error(self, mock__update_status): with self.assertRaises(ValueError): with self.trade: raise ValueError() mock__update_status.assert_called_with(TradeStatus.PENDING)