def test_apply_order_filled_event_to_buy_limit_order(self): # Arrange order = self.order_factory.limit( AUDUSD_SIM.symbol, OrderSide.BUY, Quantity(100000), Price("1.00000"), ) submitted = TestStubs.event_order_submitted(order) accepted = TestStubs.event_order_accepted(order) working = TestStubs.event_order_working(order) filled = OrderFilled( self.account_id, order.cl_ord_id, OrderId("1"), ExecutionId("E-1"), PositionId("P-1"), StrategyId.null(), order.symbol, order.side, order.quantity, order.quantity, Quantity(), Price("1.00001"), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.MAKER, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) order.apply(submitted) order.apply(accepted) order.apply(working) # Act order.apply(filled) # Assert self.assertEqual(OrderState.FILLED, order.state) self.assertEqual(Quantity(100000), order.filled_qty) self.assertEqual(Price("1.00000"), order.price) self.assertEqual(Decimal("1.00001"), order.avg_price) self.assertEqual(Decimal("0.00001"), order.slippage) self.assertTrue(order.is_completed) self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_can_apply_order_modified_event_to_stop_order(self): # Arrange order = self.order_factory.stop( AUDUSD_FXCM, OrderSide.BUY, Quantity(100000), Price("1.00000")) submitted = TestStubs.event_order_submitted(order) accepted = TestStubs.event_order_accepted(order) working = TestStubs.event_order_working(order) modified = OrderModified( self.account_id, order.cl_ord_id, OrderId("1"), Quantity(120000), Price("1.00001"), UNIX_EPOCH, uuid4(), UNIX_EPOCH) order.apply(submitted) order.apply(accepted) order.apply(working) # Act order.apply(modified) # Assert self.assertEqual(OrderState.WORKING, order.state()) self.assertEqual(OrderId("1"), order.id) self.assertEqual(Quantity(120000), order.quantity) self.assertEqual(Price("1.00001"), order.price) self.assertTrue(order.is_working()) self.assertFalse(order.is_completed()) self.assertEqual(5, order.event_count())
def test_can_initialize_atomic_order_market_with_take_profit_and_label( self): # Arrange # Act atomic_order = self.order_factory.atomic_market( AUDUSD_FXCM, OrderSide.BUY, Quantity(100000), Price(0.99990, 5), Price(1.00010, 5), Label('U1')) # Assert self.assertEqual(AUDUSD_FXCM, atomic_order.stop_loss.symbol) self.assertTrue(atomic_order.has_take_profit) self.assertEqual(AUDUSD_FXCM, atomic_order.take_profit.symbol) self.assertEqual(OrderId('O-19700101-000000-001-001-1'), atomic_order.entry.id) self.assertEqual(OrderId('O-19700101-000000-001-001-2'), atomic_order.stop_loss.id) self.assertEqual(OrderId('O-19700101-000000-001-001-3'), atomic_order.take_profit.id) self.assertEqual(OrderSide.SELL, atomic_order.stop_loss.side) self.assertEqual(OrderSide.SELL, atomic_order.take_profit.side) self.assertEqual(Quantity(100000), atomic_order.stop_loss.quantity) self.assertEqual(Quantity(100000), atomic_order.take_profit.quantity) self.assertEqual(Price(0.99990, 5), atomic_order.stop_loss.price) self.assertEqual(Price(1.00010, 5), atomic_order.take_profit.price) self.assertEqual(Label('U1_E'), atomic_order.entry.label) self.assertEqual(Label('U1_SL'), atomic_order.stop_loss.label) self.assertEqual(Label('U1_TP'), atomic_order.take_profit.label) self.assertEqual(TimeInForce.GTC, atomic_order.stop_loss.time_in_force) self.assertEqual(TimeInForce.GTC, atomic_order.take_profit.time_in_force) self.assertEqual(None, atomic_order.entry.expire_time) self.assertEqual(None, atomic_order.stop_loss.expire_time) self.assertEqual(None, atomic_order.take_profit.expire_time) self.assertEqual(AtomicOrderId('AO-19700101-000000-001-001-1'), atomic_order.id) self.assertEqual(UNIX_EPOCH, atomic_order.timestamp)
def test_cancel_order_raises_not_implemented_error(self): # Arrange # Act command = CancelOrder( self.venue, self.trader_id, self.account_id, ClientOrderId("O-123456789"), OrderId("001"), self.uuid_factory.generate(), self.clock.utc_now(), ) # Assert self.assertRaises(NotImplementedError, self.client.cancel_order, command)
def test_priced_order_with_GTD_time_in_force_and_expire_time_none_raises_exception( self): # Arrange # Act self.assertRaises(ValueError, Order, OrderId('O-123456'), AUDUSD_FXCM, OrderSide.BUY, OrderType.LIMIT, Quantity(100000), GUID(uuid.uuid4()), UNIX_EPOCH, price=Price(1.00000, 5), time_in_force=TimeInForce.GTD, expire_time=None)
def test_can_apply_order_partially_filled_event_to_buy_limit_order(self): # Arrange order = self.order_factory.limit( AUDUSD_FXCM, OrderSide.BUY, Quantity(100000), Price("1.00000")) submitted = TestStubs.event_order_submitted(order) accepted = TestStubs.event_order_accepted(order) working = TestStubs.event_order_working(order) partially = OrderFilled( self.account_id, order.cl_ord_id, OrderId("1"), ExecutionId("E-1"), PositionId("P-1"), StrategyId("S", "NULL"), order.symbol, order.side, Quantity(50000), Quantity(50000), Price("0.999999"), Money(0, USD), LiquiditySide.MAKER, USD, USD, UNIX_EPOCH, uuid4(), UNIX_EPOCH) order.apply(submitted) order.apply(accepted) order.apply(working) # Act order.apply(partially) # Assert self.assertEqual(OrderState.PARTIALLY_FILLED, order.state()) self.assertEqual(Quantity(50000), order.filled_qty) self.assertEqual(Price("1.00000"), order.price) self.assertEqual(Price("0.999999"), order.avg_price) self.assertEqual(Decimal("-0.000001"), order.slippage) self.assertFalse(order.is_completed()) self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_order_cancelled(self): # Arrange uuid = uuid4() event = OrderCancelled( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=OrderId("123456"), cancelled_time=UNIX_EPOCH, event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"order_id=123456, event_id={uuid})", str(event)) self.assertEqual(f"OrderCancelled(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"order_id=123456, event_id={uuid})", repr(event))
def test_serialize_and_deserialize_order_expired_events(self): # Arrange event = OrderExpired( self.account_id, ClientOrderId("O-123456"), OrderId("1"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event)
def event_order_filled( order, instrument, position_id=None, strategy_id=None, fill_price=None, fill_qty=None, liquidity_side=LiquiditySide.TAKER, ) -> OrderFilled: if position_id is None: position_id = PositionId(order.cl_ord_id.value.replace("P", "T")) if strategy_id is None: strategy_id = StrategyId.null() if fill_price is None: fill_price = Price("1.00000") if fill_qty is None: fill_qty = order.quantity commission = instrument.calculate_commission( quantity=order.quantity, avg_price=fill_price, liquidity_side=liquidity_side, ) return OrderFilled( account_id=TestStubs.account_id(), cl_ord_id=order.cl_ord_id, order_id=OrderId("1"), execution_id=ExecutionId(order.cl_ord_id.value.replace("O", "E")), position_id=position_id, strategy_id=strategy_id, symbol=order.symbol, order_side=order.side, fill_qty=fill_qty, cum_qty=Quantity(order.filled_qty + fill_qty), leaves_qty=Quantity( max(0, order.quantity - order.filled_qty - fill_qty)), fill_price=order.price if fill_price is None else fill_price, currency=instrument.quote_currency, is_inverse=instrument.is_inverse, commission=commission, liquidity_side=liquidity_side, execution_time=UNIX_EPOCH, event_id=uuid4(), event_timestamp=UNIX_EPOCH, )
def test_apply_order_partially_filled_event_to_buy_limit_order(self): # Arrange order = self.order_factory.limit( AUDUSD_SIM.id, OrderSide.BUY, Quantity(100000), Price("1.00000"), ) order.apply(TestStubs.event_order_submitted(order)) order.apply(TestStubs.event_order_accepted(order)) partially = OrderFilled( self.account_id, order.cl_ord_id, OrderId("1"), ExecutionId("E-1"), PositionId("P-1"), StrategyId.null(), order.instrument_id, order.side, Quantity(50000), Quantity(50000), Quantity(50000), Price("0.999999"), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.MAKER, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act order.apply(partially) # Assert self.assertEqual(OrderState.PARTIALLY_FILLED, order.state) self.assertEqual(Quantity(50000), order.filled_qty) self.assertEqual(Price("1.00000"), order.price) self.assertEqual(Decimal("0.999999"), order.avg_price) self.assertEqual(Decimal("-0.000001"), order.slippage) self.assertTrue(order.is_working) self.assertFalse(order.is_completed) self.assertEqual(UNIX_EPOCH, order.filled_timestamp)
def test_cancel_stop_order_when_order_does_not_exist_generates_cancel_reject(self): # Arrange command = CancelOrder( venue=SIM, trader_id=self.trader_id, account_id=self.account_id, cl_ord_id=ClientOrderId("O-123456"), order_id=OrderId("001"), command_id=self.uuid_factory.generate(), command_timestamp=UNIX_EPOCH, ) # Act self.exchange.handle_cancel_order(command) # Assert self.assertEqual(2, self.exec_engine.event_count)
def test_order_expired(self): # Arrange uuid = uuid4() event = OrderExpired( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=OrderId("123456"), expired_time=UNIX_EPOCH, event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == str( event) assert f"OrderExpired(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id=123456, event_id={uuid})" == repr( event)
def event_order_working(order, working_price=None) -> OrderWorking: if working_price is None: working_price = Price("1.00000") return OrderWorking( TestStubs.account_id(), order.cl_ord_id, OrderId("1"), order.symbol, order.side, order.type, order.quantity, order.price if working_price is None else working_price, order.time_in_force, order.expire_time, UNIX_EPOCH, uuid4(), UNIX_EPOCH, )
def test_order_amended(self): # Arrange uuid = uuid4() event = OrderAmended( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=OrderId("123456"), quantity=Quantity(500000), price=Price('1.95000'), amended_time=UNIX_EPOCH, event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act self.assertEqual(f"OrderAmended(account_id=SIM-000, cl_order_id=O-2020872378423, " f"order_id=123456, qty=500,000, price=1.95000, event_id={uuid})", str(event)) self.assertEqual(f"OrderAmended(account_id=SIM-000, cl_order_id=O-2020872378423, " f"order_id=123456, qty=500,000, price=1.95000, event_id={uuid})", repr(event))
def test_serialize_and_deserialize_order_cancel_reject_events(self): # Arrange event = OrderCancelReject( self.account_id, ClientOrderId("O-123456"), OrderId("1"), UNIX_EPOCH, "RESPONSE", "ORDER_DOES_NOT_EXIST", uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event)
def test_serialize_and_deserialize_order_modified_events(self): # Arrange event = OrderModified( self.account_id, ClientOrderId("O-123456"), OrderId("1"), Quantity(100000), Price("0.80010"), UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event)
def event_order_filled( order, position_id=None, strategy_id=None, fill_price=None, filled_qty=None, leaves_qty=None, base_currency=USD, quote_currency=JPY, commission=0, ) -> OrderFilled: if position_id is None: position_id = PositionId(order.cl_ord_id.value.replace("P", "T")) if strategy_id is None: strategy_id = StrategyId("S", "NULL") if fill_price is None: fill_price = Price("1.00000") if filled_qty is None: filled_qty = order.quantity if leaves_qty is None: leaves_qty = Quantity() return OrderFilled( TestStubs.account_id(), order.cl_ord_id, OrderId("1"), ExecutionId(order.cl_ord_id.value.replace("O", "E")), position_id, strategy_id, order.symbol, order.side, filled_qty, leaves_qty, order.price if fill_price is None else fill_price, Money(commission, base_currency), LiquiditySide.TAKER, base_currency, # Stub event quote_currency, # Stub event UNIX_EPOCH, uuid4(), UNIX_EPOCH, )
def test_order_accepted(self, order_id=None): if order_id is None: order_id = OrderId("123456") # Arrange uuid = uuid4() event = OrderAccepted( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=order_id, accepted_time=UNIX_EPOCH, event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act assert f"OrderAccepted(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id={123456}, event_id={uuid})", str( event) # noqa assert f"OrderAccepted(account_id=SIM-000, cl_ord_id=O-2020872378423, order_id={123456}, event_id={uuid})", repr( event) # noqa
def test_serialize_and_deserialize_cancel_order_commands(self): # Arrange command = CancelOrder( self.venue, self.trader_id, self.account_id, ClientOrderId("O-123456"), OrderId("001"), uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(command) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(command, deserialized) print(b64encode(serialized)) print(command)
def test_order_cancel_reject(self): # Arrange uuid = uuid4() event = OrderCancelReject( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=OrderId("123456"), rejected_time=UNIX_EPOCH, response_to="O-2020872378423", reason="ORDER_DOES_NOT_EXIST", event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act self.assertEqual(f"OrderCancelReject(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"response_to=O-2020872378423, reason='ORDER_DOES_NOT_EXIST', " f"event_id={uuid})", str(event)) self.assertEqual(f"OrderCancelReject(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"response_to=O-2020872378423, reason='ORDER_DOES_NOT_EXIST', " f"event_id={uuid})", repr(event))
def test_apply_order_working_event(self): # Arrange order = self.order_factory.stop_market( AUDUSD_SIM.symbol, OrderSide.BUY, Quantity(100000), Price("1.00000"), ) order.apply(TestStubs.event_order_submitted(order)) order.apply(TestStubs.event_order_accepted(order)) # Act order.apply(TestStubs.event_order_working(order)) # Assert # print(order) self.assertEqual(OrderState.WORKING, order.state) self.assertEqual(OrderId("1"), order.id) self.assertFalse(order.is_completed) self.assertTrue(order.is_working) self.assertEqual(None, order.filled_timestamp)
def test_order_filled(self): # Arrange uuid = uuid4() event = OrderFilled( account_id=AccountId("SIM", "000"), cl_ord_id=ClientOrderId("O-2020872378423"), order_id=OrderId("123456"), execution_id=ExecutionId("1"), position_id=PositionId("2"), strategy_id=StrategyId("SCALPER", "001"), instrument_id=InstrumentId(Symbol("BTC/USDT"), Venue("BINANCE")), order_side=OrderSide.BUY, fill_qty=Quantity("0.561000"), cum_qty=Quantity("0.561000"), leaves_qty=Quantity(0), fill_price=Price("15600.12445"), currency=USDT, is_inverse=False, commission=Money("12.20000000", USDT), liquidity_side=LiquiditySide.MAKER, execution_time=UNIX_EPOCH, event_id=uuid, event_timestamp=UNIX_EPOCH, ) # Act assert ( f"OrderFilled(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"order_id=123456, position_id=2, strategy_id=SCALPER-001, " f"instrument_id=BTC/USDT.BINANCE, side=BUY-MAKER, fill_qty=0.561000, " f"fill_price=15600.12445 USDT, cum_qty=0.561000, leaves_qty=0, " f"commission=12.20000000 USDT, event_id={uuid})" == str(event)) assert ( f"OrderFilled(account_id=SIM-000, cl_ord_id=O-2020872378423, " f"order_id=123456, position_id=2, strategy_id=SCALPER-001, " f"instrument_id=BTC/USDT.BINANCE, side=BUY-MAKER, fill_qty=0.561000, " f"fill_price=15600.12445 USDT, cum_qty=0.561000, leaves_qty=0, " f"commission=12.20000000 USDT, event_id={uuid})" == repr(event))
def test_serialize_and_deserialize_order_working_events(self): # Arrange event = OrderWorking( self.account_id, ClientOrderId("O-123456"), OrderId("B-123456"), AUDUSD_SIM.symbol, OrderSide.SELL, OrderType.STOP_MARKET, Quantity(100000), Price("1.50000"), TimeInForce.DAY, None, UNIX_EPOCH, uuid4(), UNIX_EPOCH, ) # Act serialized = self.serializer.serialize(event) deserialized = self.serializer.deserialize(serialized) # Assert self.assertEqual(deserialized, event)
def test_order_exists_when_no_order_returns_false(self): # Arrange # Act # Assert self.assertFalse(self.database.order_exists(OrderId('O-123456')))
def test_position_indexed_for_order_when_no_indexing_returns_false(self): # Arrange # Act # Assert self.assertFalse( self.database.position_indexed_for_order(OrderId('O-123456')))
def test_position_filled_with_buy_order_then_sell_order_returns_expected_attributes(self): # Arrange order = self.order_factory.market( AUDUSD_SIM.symbol, OrderSide.BUY, Quantity(150000), ) fill1 = TestStubs.event_order_filled( order, instrument=AUDUSD_SIM, position_id=PositionId("P-123456"), strategy_id=StrategyId("S", "001"), fill_price=Price("1.00001"), ) position = Position(fill1) fill2 = OrderFilled( self.account_id, order.cl_ord_id, OrderId("2"), ExecutionId("E2"), PositionId("T123456"), StrategyId("S", "001"), order.symbol, OrderSide.SELL, order.quantity, order.quantity, Quantity(), Price("1.00011"), AUDUSD_SIM.quote_currency, AUDUSD_SIM.is_inverse, Money(0, USD), LiquiditySide.TAKER, UNIX_EPOCH + timedelta(minutes=1), uuid4(), UNIX_EPOCH, ) last = Price("1.00050") # Act position.apply(fill2) # Assert self.assertEqual(Quantity(), position.quantity) self.assertEqual(PositionSide.FLAT, position.side) self.assertEqual(UNIX_EPOCH, position.opened_time) self.assertEqual(timedelta(minutes=1), position.open_duration) self.assertEqual(Decimal("1.00001"), position.avg_open) self.assertEqual(2, position.event_count) self.assertEqual(datetime(1970, 1, 1, 0, 1, tzinfo=pytz.utc), position.closed_time) self.assertEqual(Decimal("1.00011"), position.avg_close) self.assertFalse(position.is_long) self.assertFalse(position.is_short) self.assertFalse(position.is_open) self.assertTrue(position.is_closed) self.assertEqual(Decimal("0.00010"), position.realized_points) self.assertEqual(Decimal('0.00009999900000999990000099999000'), position.realized_return) self.assertEqual(Money(12.00, USD), position.realized_pnl) self.assertEqual(Money(0, USD), position.unrealized_pnl(last)) self.assertEqual(Money(12.00, USD), position.total_pnl(last)) self.assertEqual([Money(3.00, USD)], position.commissions()) self.assertEqual(Money(3.00, USD), position.commission) self.assertEqual("Position(id=P-123456, FLAT AUD/USD.SIM)", repr(position))
def test_cld_ord_id_when_not_implemented_raises_exception(self): self.assertRaises(NotImplementedError, self.facade.cl_ord_id, OrderId("1"))
def test_position_filled_with_buy_order_then_sell_order_returns_expected_attributes(self): # Arrange order = self.order_factory.market( AUDUSD_FXCM, OrderSide.BUY, Quantity(100000)) fill1 = TestStubs.event_order_filled( order, position_id=PositionId("P-123456"), strategy_id=StrategyId("S", "001"), fill_price=Price("1.00001"), ) position = Position(fill1) fill2 = OrderFilled( self.account_id, order.cl_ord_id, OrderId("2"), ExecutionId("E2"), PositionId("T123456"), StrategyId("S", "001"), order.symbol, OrderSide.SELL, order.quantity, Quantity(), Price("1.00001"), Money(0, USD), LiquiditySide.TAKER, AUD, USD, UNIX_EPOCH + timedelta(minutes=1), uuid4(), UNIX_EPOCH, ) last = QuoteTick( AUDUSD_FXCM, Price("1.00050"), Price("1.00048"), Quantity(1), Quantity(1), UNIX_EPOCH, ) # Act position.apply(fill2) # Assert self.assertEqual(Quantity(), position.quantity) self.assertEqual(PositionSide.FLAT, position.side) self.assertEqual(UNIX_EPOCH, position.opened_time) self.assertEqual(timedelta(minutes=1), position.open_duration) self.assertEqual(1.00001, position.avg_open_price) self.assertEqual(2, position.event_count()) self.assertEqual(datetime(1970, 1, 1, 0, 1, tzinfo=pytz.utc), position.closed_time) self.assertEqual(1.00001, position.avg_close_price) self.assertFalse(position.is_long()) self.assertFalse(position.is_short()) self.assertTrue(position.is_closed()) self.assertEqual(0.0, position.realized_points) self.assertEqual(0.0, position.realized_return) self.assertEqual(Money(0, USD), position.realized_pnl) self.assertEqual(Money(0, USD), position.unrealized_pnl(last)) self.assertEqual(Money(0, USD), position.total_pnl(last))
def test_position_for_order_when_not_found_returns_none(self): # Arrange # Act # Assert self.assertIsNone( self.database.get_position_for_order(OrderId('O-123456')))
def position_which_is_closed(position_id, close_price=None) -> Position: if close_price is None: close_price = Price("1.0001") order_factory = OrderFactory( strategy_id=StrategyId("S", "001"), id_tag_trader=IdTag("001"), id_tag_strategy=IdTag("001"), ) order = order_factory.market( TestStubs.symbol_audusd_fxcm(), OrderSide.SELL, Quantity(100000), ) filled1 = OrderFilled( TestStubs.account_id(), order.cl_ord_id, OrderId("1"), ExecutionId(order.cl_ord_id.value.replace('O', 'E')), position_id, StrategyId("S", "1"), order.symbol, order.side, order.quantity, Quantity(), close_price, Money(0, USD), LiquiditySide.TAKER, USD, # Stub event USD, # Stub event UNIX_EPOCH + timedelta(minutes=5), uuid4(), UNIX_EPOCH + timedelta(minutes=5), ) filled2 = OrderFilled( TestStubs.account_id(), order.cl_ord_id, OrderId("2"), ExecutionId(order.cl_ord_id.value.replace('O', 'E')), position_id, StrategyId("S", "1"), order.symbol, OrderSide.BUY, order.quantity, Quantity(), close_price, Money(0, USD), LiquiditySide.TAKER, USD, # Stub event USD, # Stub event UNIX_EPOCH + timedelta(minutes=5), uuid4(), UNIX_EPOCH + timedelta(minutes=5), ) position = Position(filled1) position.apply(filled2) return position