def setUp(self):
msft_ticker = BloombergTicker("MSFT US Equity")
aapl_ticker = BloombergTicker("AAPL US Equity")
googl_ticker = BloombergTicker("GOOGL US Equity")
self.tickers = [msft_ticker, aapl_ticker, googl_ticker]
self.data_provider = self._create_data_provider_mock()
self.orders = [
Order(
ticker=msft_ticker,
quantity=1250,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC
),
Order(
ticker=aapl_ticker,
quantity=-200,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC
),
Order(
ticker=googl_ticker,
quantity=1,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC
)
]
self.market_on_close_order = [Order(
ticker=msft_ticker,
quantity=1250,
execution_style=MarketOnCloseOrder(),
time_in_force=TimeInForce.GTC
)]
def setUp(self):
msft_ticker = BloombergTicker("MSFT US Equity")
aapl_ticker = BloombergTicker("AAPL US Equity")
googl_ticker = BloombergTicker("GOOGL US Equity")
self.tickers = [msft_ticker, aapl_ticker, googl_ticker]
self.data_handler = self._create_data_handler_mock()
self.contract_ticker_mapper = DummyBloombergContractTickerMapper()
self.orders = [
Order(contract=self.contract_ticker_mapper.ticker_to_contract(
msft_ticker),
quantity=1000,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC),
Order(contract=self.contract_ticker_mapper.ticker_to_contract(
aapl_ticker),
quantity=-10,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC),
Order(contract=self.contract_ticker_mapper.ticker_to_contract(
googl_ticker),
quantity=1,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC)
]
self.prices_without_slippage = [1.0, 100.0, 1000.0]
def test_volume_orders_filter__adjust_buy_stop_orders(self):
"""
Test if StopOrders are adjusted in a correct way. Suppose, the StopOrder quantity will be much bigger than
the current MarketOrder, because the position for the contract already existed for some time, e.g.
- there exists an open LONG position of size 100
- the position needs to be adjusted to 200
- a new MarketOrder of size 100 is created
- a new StopOrder of size -200 is created
- the volume percentage limit limits the MarketOrder to 15% of avg daily volume (set to volume_value = 100)
- then the StopOrder needs to be adjusted to -115
"""
volume_percentage_limit = 0.15
volume_value = 100.0
data_handler = self._setup_data_handler(volume_value)
volume_orders_verifier = VolumeOrdersFilter(
data_handler, self.contract_ticker_mapper, volume_percentage_limit)
# Initialize a list of orders, which do not exceed the maximum volume limit
contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker)
buy_order = [
Order(contract, 100, MarketOrder(), TimeInForce.GTC),
Order(contract, -200, StopOrder(1.0), TimeInForce.GTC)
]
new_orders = volume_orders_verifier.adjust_orders(buy_order)
expected_buy_order = [
Order(contract, 15, MarketOrder(), TimeInForce.GTC),
Order(contract, -115, StopOrder(1.0), TimeInForce.GTC)
]
self.assertCountEqual(new_orders, expected_buy_order)
def test_initial_risk_position_sizer_without_cap(self):
"""
Max leverage will not be limited by position sizer
"""
fraction_at_risk = 0.23
signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk,
self.last_price)
orders = self.initial_risk_position_sizer.size_signals([signal])
self.assertEqual(len(orders), 2) # market order and stop order
portfolio_value = self.initial_position / self.initial_allocation
target_quantity = int(
np.floor(portfolio_value * self.initial_risk / fraction_at_risk))
additional_contracts = target_quantity - self.initial_position
self.assertEqual(
orders[0],
Order(self.contract, additional_contracts, MarketOrder(),
TimeInForce.OPG))
stop_price = self.last_price * (1 - fraction_at_risk)
stop_quantity = -(self.initial_position + additional_contracts)
self.assertEqual(
orders[1],
Order(self.contract, stop_quantity, StopOrder(stop_price),
TimeInForce.GTC))
def test_volume_orders_filter__adjust_sell_stop_orders(self):
"""
Test if StopOrders are adjusted in a correct way. The MarketOrder corresponding to StopOrder is a sell order.
"""
volume_percentage_limit = 0.15
volume_value = 100.0
data_handler = self._setup_data_handler(volume_value)
volume_orders_verifier = VolumeOrdersFilter(
data_handler, self.contract_ticker_mapper, volume_percentage_limit)
# Initialize a list of orders, which do not exceed the maximum volume limit
contract = self.contract_ticker_mapper.ticker_to_contract(self.ticker)
sell_order = [
Order(contract, -100, MarketOrder(), TimeInForce.GTC),
Order(contract, 200, StopOrder(1.0), TimeInForce.GTC)
]
new_orders = volume_orders_verifier.adjust_orders(sell_order)
expected_sell_order = [
Order(contract, -15, MarketOrder(), TimeInForce.GTC),
Order(contract, 115, StopOrder(1.0), TimeInForce.GTC)
]
self.assertCountEqual(new_orders, expected_sell_order)
def test_initial_risk_position_sizer_with_cap(self):
"""
Max leverage will be limited by position sizer to 1.5
"""
fraction_at_risk = 0.01 # will give leverage of 2, that will be capped to 1.5
signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk,
self.last_price, self.timer.now())
orders = self.initial_risk_position_sizer.size_signals([signal])
self.assertEqual(len(orders), 2) # market order and stop order
portfolio_value = self.initial_position / self.initial_allocation
max_leverage = self.initial_risk_position_sizer.max_target_percentage
target_quantity = int(np.floor(portfolio_value * max_leverage))
additional_contracts = target_quantity - self.initial_position
self.assertEqual(
orders[0],
Order(self.ticker, additional_contracts, MarketOrder(),
TimeInForce.OPG))
stop_price = self.last_price * (1 - fraction_at_risk)
stop_quantity = -(self.initial_position + additional_contracts)
self.assertEqual(
orders[1],
Order(self.ticker, stop_quantity, StopOrder(stop_price),
TimeInForce.GTC))
def openOrder(self, orderId: OrderId, ib_contract: Contract,
ib_order: IBOrder, orderState: OrderState):
super().openOrder(orderId, ib_contract, ib_order, orderState)
if ib_order.orderType.upper() == 'STP':
execution_style = StopOrder(ib_order.auxPrice)
elif ib_order.orderType.upper() == 'MKT':
execution_style = MarketOrder()
else:
error_message = "Order Type is not supported: {}".format(
ib_order.orderType)
self.logger.error(error_message)
raise ValueError(error_message)
if ib_order.action.upper() == 'SELL':
quantity = -ib_order.totalQuantity
elif ib_order.action.upper() == 'BUY':
quantity = ib_order.totalQuantity
else:
error_message = "Order Action is not supported: {}".format(
ib_order.action)
self.logger.error(error_message)
raise ValueError(error_message)
if ib_order.tif.upper() == 'DAY':
time_in_force = TimeInForce.DAY
elif ib_order.tif.upper() == 'GTC':
time_in_force = TimeInForce.GTC
elif ib_order.tif.upper() == 'OPG':
time_in_force = TimeInForce.OPG
else:
error_message = "Time in Force is not supported: {}".format(
ib_order.tif)
self.logger.error(error_message)
raise ValueError(error_message)
try:
ticker = self.contract_ticker_mapper.contract_to_ticker(
IBContract.from_ib_contract(ib_contract))
order = Order(ticker=ticker,
quantity=quantity,
execution_style=execution_style,
time_in_force=time_in_force,
order_state=orderState.status)
order.id = int(orderId)
self.order_list.append(order)
except ValueError as e:
self.logger.error(
f"Open Order for contract {ib_contract} will be skipped due to the following error "
f"during parsing: \n{e}")
def test_volume_orders_filter__no_volume_data(self):
"""Tests if VolumeOrdersVerifier does not change orders, which do not have the volume data."""
# Setup DataHandler and VolumeOrdersVerifier
volume_percentage_limit = 0.15
volume_value = None
data_handler = self._setup_data_handler(volume_value)
volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit)
# Initialize a list of orders, which do not exceed the maximum volume limit
orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC),
Order(self.ticker, 200, MarketOrder(), TimeInForce.GTC),
Order(self.ticker, -300, MarketOrder(), TimeInForce.GTC)]
new_orders = volume_orders_verifier.adjust_orders(orders)
self.assertCountEqual(orders, new_orders)
def test_order_target_percent(self):
quantity = 40
execution_style = StopOrder(4.20)
time_in_force = TimeInForce.GTC
orders = self.order_factory.target_percent_orders({self.contract: 0.5}, execution_style, time_in_force)
self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order_target_value(self):
execution_style = StopOrder(4.20)
time_in_force = TimeInForce.GTC
quantity = 4
orders = self.order_factory.target_value_orders({self.contract: 140.0}, execution_style, time_in_force)
self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order(self):
quantity = 5
execution_style = MarketOrder()
time_in_force = TimeInForce.GTC
orders = self.order_factory.orders({self.contract: quantity}, execution_style, time_in_force)
self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_market_opens_at_much_higher_price_than_it_closed_at_yesterday(
self):
self.buy_stop_loss_order = Order(self.msft_contract,
quantity=1,
execution_style=StopOrder(120.0),
time_in_force=TimeInForce.GTC)
self.exec_hanlder.accept_orders([self.buy_stop_loss_order])
self._set_bar_for_today(open=120.0,
high=130.0,
low=68.0,
close=90.0,
volume=100000000.0)
self.exec_hanlder.on_market_close(...)
assert_lists_equal([], self.exec_hanlder.get_open_orders())
verify(self.spied_monitor, times=3).record_transaction(...)
verify(self.portfolio, times=3).transact_transaction(...)
self.assertEqual(3, len(self.monitor.transactions))
actual_transaction_3 = self.monitor.transactions[2]
self.assertEqual(self.msft_contract, actual_transaction_3.contract)
self.assertEqual(1, actual_transaction_3.quantity)
self.assertEqual(120.0, actual_transaction_3.price)
self.assertEqual(0.0, actual_transaction_3.commission)
def test_market_opens_at_much_higher_price_than_it_closed_at_yesterday(
self):
self.buy_stop_loss_order = Order(self.msft_contract,
quantity=1,
execution_style=StopOrder(120.0),
time_in_force=TimeInForce.GTC)
self.exec_handler.assign_order_ids([self.buy_stop_loss_order])
self._set_bar_for_today(open_price=120.0,
high_price=130.0,
low_price=68.0,
close_price=90.0,
volume=100000000.0)
self._trigger_single_time_event()
self.exec_handler.on_market_close(...)
assert_lists_equal([], self.exec_handler.get_open_orders())
expected_transactions = [
Transaction(self.timer.now(), self.msft_contract, -1,
self.stop_loss_order_1.execution_style.stop_price, 0),
Transaction(self.timer.now(), self.msft_contract, -1,
self.stop_loss_order_2.execution_style.stop_price, 0),
Transaction(self.timer.now(), self.msft_contract, 1, 120, 0),
]
self.monitor.record_transaction.assert_has_calls(
call(t) for t in expected_transactions)
self.portfolio.transact_transaction.assert_has_calls(
call(t) for t in expected_transactions)
self.assertEqual(self.monitor.record_transaction.call_count, 3)
self.assertEqual(self.portfolio.transact_transaction.call_count, 3)
def test_volume_orders_filter__no_resize_orders(self):
"""Tests if VolumeOrdersVerifier does not change orders, which do not exceed the limit."""
# Setup DataHandler and VolumeOrdersVerifier
volume_percentage_limit = 0.15
volume_value = 100.0
data_handler = self._setup_data_handler(volume_value)
volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit)
# Initialize a list of orders, which do not exceed the maximum volume limit
max_quantity = int(volume_percentage_limit * volume_value)
orders = [Order(self.ticker, max_quantity, MarketOrder(), TimeInForce.GTC),
Order(self.ticker, -max_quantity // 2, MarketOrder(), TimeInForce.GTC),
Order(self.ticker, max_quantity // 3, MarketOrder(), TimeInForce.GTC)]
new_orders = volume_orders_verifier.adjust_orders(orders)
self.assertCountEqual(orders, new_orders)
def orders(self, quantities: Mapping[Ticker,
int], execution_style: ExecutionStyle,
time_in_force: TimeInForce) -> List[Order]:
"""
Creates a list of Orders for given numbers of shares for each given asset.
Orders requiring 0 shares will be removed from resulting order list
Parameters
----------
quantities: Mapping[Ticker, int]
mapping of a Ticker to an amount of shares which should be bought/sold.
If number is positive then asset will be bought. Otherwise it will be sold.
execution_style: ExecutionStyle
execution style of an order (e.g. MarketOrder, StopOrder, etc.)
time_in_force: TimeInForce
e.g. 'DAY' (Order valid for one trading session), 'GTC' (good till cancelled)
Returns
--------
List[Order]
list of generated orders
"""
self._log_function_call(vars())
self._check_tickers_type(list(quantities.keys()))
return [
Order(ticker, quantity, execution_style, time_in_force)
for ticker, quantity in quantities.items() if quantity != 0
]
def orders(self, quantities: Mapping[Contract,
int], execution_style: ExecutionStyle,
time_in_force: TimeInForce) -> List[Order]:
"""
Creates a list of Orders for given numbers of shares for each given asset.
Orders requiring 0 shares will be removed from resulting order list
Parameters
----------
quantities
mapping of a Contract to an amount of shares which should be bought/sold.
If number is positive then asset will be bought. Otherwise it will be sold.
execution_style
execution style of an order (e.g. MarketOrder, StopOrder, etc.)
time_in_force
e.g. 'DAY' (Order valid for one trading session), 'GTC' (good till cancelled)
"""
self._log_function_call(vars())
order_list = []
for contract, quantity in quantities.items():
if quantity != 0:
order_list.append(
Order(contract, quantity, execution_style, time_in_force))
return order_list
def _adjust_quantity(self, order: Order, stop_order: Optional[Order], volume_df: QFDataFrame) -> \
Tuple[Order, Order]:
"""Returns order with adjusted quantity if applicable."""
ticker = self._contract_ticker_mapper.contract_to_ticker(order.contract)
def average_past_volume(ticker: Ticker) -> Optional[float]:
volume_series = volume_df[ticker]
volume_series = volume_series.dropna()
volume_series = volume_series[volume_series >= 0]
return volume_series.mean()
past_volume = average_past_volume(ticker)
if is_finite_number(past_volume):
volume_limit: int = math.floor(past_volume * self._volume_percentage_limit)
# Check if the order quantity exceeds the limit
if abs(order.quantity) > volume_limit:
final_quantity = volume_limit * np.sign(order.quantity)
adjustment_difference = final_quantity - order.quantity
self.logger.info("{} VolumeOrdersFilter: Quantity change {} "
"\n\tfinal quantity: {}".format(self._data_handler.timer.now(), order,
final_quantity))
order.quantity = final_quantity
if stop_order:
# Adjust the corresponding stop order
stop_order_final_quantity = stop_order.quantity - adjustment_difference
self.logger.info("{} VolumeOrdersFilter: Quantity change {} "
"\n\tfinal quantity: {}".format(self._data_handler.timer.now(), stop_order,
final_quantity))
stop_order.quantity = stop_order_final_quantity
return order, stop_order
def setUpClass(cls) -> None:
cls.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
cls.example_ticker = BloombergTicker("Example Index")
cls.example_ticker_2 = BloombergTicker("Example2 Index")
cls.orders = [
Order(contract=cls.contract_ticker_mapper.ticker_to_contract(
cls.example_ticker),
quantity=1000,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC),
Order(contract=cls.contract_ticker_mapper.ticker_to_contract(
cls.example_ticker_2),
quantity=1000,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC),
]
cls.backtest_date = str_to_date("2020-01-01")
def setUp(self):
self.scheduling_time_delay = 1
start_date = str_to_date("2018-02-04")
before_close = start_date + MarketCloseEvent.trigger_time(
) - RelativeDelta(minutes=self.scheduling_time_delay)
self.timer = SettableTimer(initial_time=before_close)
contracts_to_tickers_mapper = SimulatedBloombergContractTickerMapper()
msft_contract = Contract("MSFT US Equity",
security_type='STK',
exchange='TEST')
self.msft_ticker = contracts_to_tickers_mapper.contract_to_ticker(
msft_contract)
self.data_handler = Mock(spec=DataHandler)
self.scheduler = Mock(spec=Scheduler)
self.commission_model = FixedCommissionModel(commission=0.0)
self.monitor = Mock(spec=AbstractMonitor)
self.portfolio = Mock(spec=Portfolio)
slippage_model = PriceBasedSlippage(0.0, self.data_handler,
contracts_to_tickers_mapper)
self.exec_handler = SimulatedExecutionHandler(
self.data_handler, self.timer, self.scheduler, self.monitor,
self.commission_model, contracts_to_tickers_mapper, self.portfolio,
slippage_model, RelativeDelta(minutes=self.scheduling_time_delay))
self.order_1 = Order(msft_contract,
quantity=10,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_2 = Order(msft_contract,
quantity=-5,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_3 = Order(msft_contract,
quantity=-7,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_4 = Order(msft_contract,
quantity=4,
execution_style=MarketOnCloseOrder(),
time_in_force=TimeInForce.DAY)
def test_order_value(self):
value = 100.0
quantity = floor(100.0 / self.share_price) # type: int
execution_style = StopOrder(4.20)
time_in_force = TimeInForce.DAY
orders = self.order_factory.value_orders({self.contract: value}, execution_style, time_in_force)
self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def test_order_percent(self):
percentage = 0.5
execution_style = StopOrder(4.20)
time_in_force = TimeInForce.GTC
quantity = floor(percentage * self.current_portfolio_value / self.share_price) # type: int
orders = self.order_factory.percent_orders({self.contract: percentage}, execution_style, time_in_force)
self.assertEqual(orders[0], Order(self.contract, quantity, execution_style, time_in_force))
def openOrder(self, orderId: OrderId, ib_contract: IBContract,
ib_order: IBOrder, orderState: OrderState):
contract = Contract(ib_contract.symbol, ib_contract.secType,
ib_contract.exchange)
if ib_order.orderType.upper() == 'STP':
execution_style = StopOrder(ib_order.auxPrice)
elif ib_order.orderType.upper() == 'MKT':
execution_style = MarketOrder()
else:
error_message = "Order Type is not supported: {}".format(
ib_order.orderType)
self.logger.error(error_message)
raise ValueError(error_message)
if ib_order.action.upper() == 'SELL':
quantity = -ib_order.totalQuantity
elif ib_order.action.upper() == 'BUY':
quantity = ib_order.totalQuantity
else:
error_message = "Order Action is not supported: {}".format(
ib_order.action)
self.logger.error(error_message)
raise ValueError(error_message)
if ib_order.tif.upper() == 'DAY':
time_in_force = TimeInForce.DAY
elif ib_order.tif.upper() == 'GTC':
time_in_force = TimeInForce.GTC
elif ib_order.tif.upper() == 'OPG':
time_in_force = TimeInForce.OPG
else:
error_message = "Time in Force is not supported: {}".format(
ib_order.tif)
self.logger.error(error_message)
raise ValueError(error_message)
order = Order(contract=contract,
quantity=quantity,
execution_style=execution_style,
time_in_force=time_in_force,
order_state=orderState.status)
order.id = int(orderId)
self.order_list.append(order)
def test_simple_position_sizer(self):
fraction_at_risk = 0.02
signal = Signal(self.ticker, Exposure.LONG, fraction_at_risk)
orders = self.simple_position_sizer.size_signals([signal])
quantity = np.floor(self.initial_position *
(1 / self.initial_allocation - 1))
self.assertEqual(len(orders), 2) # market order and stop order
self.assertEqual(
orders[0],
Order(self.contract, quantity, MarketOrder(), TimeInForce.OPG))
stop_price = self.last_price * (1 - fraction_at_risk)
stop_quantity = -(self.initial_position + quantity)
self.assertEqual(
orders[1],
Order(self.contract, stop_quantity, StopOrder(stop_price),
TimeInForce.GTC))
def test_out_signal(self):
fraction_at_risk = 0.02
signal = Signal(self.ticker, Exposure.OUT, fraction_at_risk)
orders = self.simple_position_sizer.size_signals([signal])
self.assertEqual(len(orders), 1) # market order only
self.assertEqual(
orders[0],
Order(self.contract, -200, MarketOrder(), TimeInForce.OPG))
def setUp(self):
self.start_date = str_to_date("2018-02-04")
self.msft_contract = Contract(self.MSFT_TICKER_STR,
security_type='SEK',
exchange='TEST')
self.msft_ticker = BloombergTicker(self.MSFT_TICKER_STR)
self.contracts_to_tickers_mapper = DummyBloombergContractTickerMapper()
timer = SettableTimer(initial_time=self.start_date)
self.data_handler = mock(strict=True)
self.scheduler = mock()
self.commission_model = FixedCommissionModel(commission=0.0)
self.monitor = _MonitorMock()
self.spied_monitor = spy(self.monitor)
self.portfolio = mock()
slippage_model = PriceBasedSlippage(0.0)
self.exec_hanlder = SimulatedExecutionHandler(
self.data_handler, timer, self.scheduler, self.spied_monitor,
self.commission_model, self.contracts_to_tickers_mapper,
self.portfolio, slippage_model)
self._set_current_msft_price(100.0)
self.stop_loss_order_1 = Order(self.msft_contract,
quantity=-1,
execution_style=StopOrder(95.0),
time_in_force=TimeInForce.GTC)
self.stop_loss_order_2 = Order(self.msft_contract,
quantity=-1,
execution_style=StopOrder(90.0),
time_in_force=TimeInForce.GTC)
self.stop_loss_order_3 = Order(self.msft_contract,
quantity=-1,
execution_style=StopOrder(50.0),
time_in_force=TimeInForce.DAY)
self.exec_hanlder.accept_orders([
self.stop_loss_order_1, self.stop_loss_order_2,
self.stop_loss_order_3
])
def setUp(self):
self.scheduling_time_delay = 1
start_date = str_to_date("2018-02-04")
before_close = start_date + MarketCloseEvent.trigger_time(
) - RelativeDelta(minutes=self.scheduling_time_delay)
self.timer = SettableTimer(initial_time=before_close)
self.msft_ticker = BloombergTicker("MSFT US Equity")
self.data_handler = Mock(spec=DataHandler)
self.data_handler.frequency = Frequency.DAILY
self.data_handler.data_provider = Mock(spec=DataProvider)
self.scheduler = Mock(spec=Scheduler)
self.commission_model = FixedCommissionModel(commission=0.0)
self.monitor = Mock(spec=AbstractMonitor)
self.portfolio = Mock(spec=Portfolio)
slippage_model = PriceBasedSlippage(0.0, self.data_handler)
self.exec_handler = SimulatedExecutionHandler(
self.data_handler, self.timer, self.scheduler, self.monitor,
self.commission_model, self.portfolio, slippage_model,
RelativeDelta(minutes=self.scheduling_time_delay))
self.order_1 = Order(self.msft_ticker,
quantity=10,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_2 = Order(self.msft_ticker,
quantity=-5,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_3 = Order(self.msft_ticker,
quantity=-7,
execution_style=MarketOrder(),
time_in_force=TimeInForce.OPG)
self.order_4 = Order(self.msft_ticker,
quantity=4,
execution_style=MarketOnCloseOrder(),
time_in_force=TimeInForce.DAY)
def test_order_target_percent_tolerance6(self):
# there are 10 shares price per share is 10 so position value is 100
ex_style = MarketOrder()
tif = TimeInForce.DAY
tolerance_percentage = 2 / 50
target_value = 0.5
orders = self.order_factory.target_percent_orders({self.contract: target_value}, ex_style, tif,
tolerance_percentage)
quantity = 40
self.assertEqual(orders[0], Order(self.contract, quantity, ex_style, tif))
def orders(
self,
quantities: Mapping[Contract, int],
execution_style: ExecutionStyle,
time_in_force: TimeInForce = TimeInForce.DAY) -> Sequence[Order]:
order_list = []
for contract, quantity in quantities.items():
if quantity != 0:
order_list.append(
Order(contract, quantity, execution_style, time_in_force))
return order_list
def test_order_target(self):
quantity = -5
execution_style = StopOrder(4.20)
time_in_force = TimeInForce.DAY
orders = self.order_factory.target_orders({self.ticker: 5},
execution_style,
time_in_force)
self.assertEqual(
orders[0],
Order(self.ticker, quantity, execution_style, time_in_force))
def test_volume_orders_filter__resize_orders(self):
"""Tests VolumeOrdersVerifier with orders exceeding the limit."""
# Setup DataHandler and VolumeOrdersVerifier
volume_percentage_limit = 0.15
volume_value = 100.0
data_handler = self._setup_data_handler(volume_value)
volume_orders_verifier = VolumeOrdersFilter(data_handler, volume_percentage_limit)
# Initialize a list of orders, which exceed the maximum volume limit
buy_orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC)]
sell_orders = [Order(self.ticker, 100, MarketOrder(), TimeInForce.GTC)]
new_buy_orders = volume_orders_verifier.adjust_orders(buy_orders)
new_sell_orders = volume_orders_verifier.adjust_orders(sell_orders)
self.assertEqual(len(new_buy_orders), len(buy_orders))
self.assertEqual(len(new_sell_orders), len(sell_orders))
for order in new_buy_orders + new_sell_orders:
self.assertLessEqual(abs(order.quantity), abs(volume_value * volume_percentage_limit))
