def main():
this_dir_path = os.path.dirname(os.path.abspath(__file__))
trades, nr_of_assets_traded, start_date, end_date = cached_value(
get_data, os.path.join(this_dir_path, 'trade_analysis.cache'))
settings = container.resolve(Settings) # type: Settings
pdf_exporter = container.resolve(PDFExporter) # type: PDFExporter
contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
initial_risk = 0.05
nr_of_assets_traded = len(
set(
contract_ticker_mapper.contract_to_ticker(t.contract, False)
for t in trades))
trade_analysis_sheet = TradeAnalysisSheet(settings,
pdf_exporter,
nr_of_assets_traded,
trades,
start_date,
end_date,
initial_risk,
title="Sample trade analysis")
trade_analysis_sheet.build_document()
trade_analysis_sheet.save()
print("Finished")
def __init__(self, data_provider: GeneralPriceProvider, settings: Settings,
pdf_exporter: PDFExporter, excel_exporter: ExcelExporter):
self._logger = qf_logger.getChild(self.__class__.__name__)
self._backtest_name = "Backtest Results"
self._initial_cash = 10000000
self._initial_risk = None
self._benchmark_tms = None
self._monitor_settings = None
self._contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self._commission_model_type = FixedCommissionModel
self._commission_model_kwargs = {"commission": 0.0}
self._slippage_model_type = PriceBasedSlippage
self._slippage_model_kwargs = {
"slippage_rate": 0.0,
"max_volume_share_limit": None
}
self._position_sizer_type = SimplePositionSizer
self._position_sizer_kwargs = dict()
self._orders_filter_types_params = [
] # type: List[Tuple[Type[OrdersFilter], Dict]]
self._signals_register = None
self._data_provider = data_provider
self._settings = settings
self._pdf_exporter = pdf_exporter
self._excel_exporter = excel_exporter
self._frequency = None
self._scheduling_time_delay = RelativeDelta(minutes=1)
BeforeMarketOpenEvent.set_trigger_time({
"hour": 8,
"minute": 0,
"second": 0,
"microsecond": 0
})
MarketOpenEvent.set_trigger_time({
"hour": 13,
"minute": 30,
"second": 0,
"microsecond": 0
})
MarketCloseEvent.set_trigger_time({
"hour": 20,
"minute": 0,
"second": 0,
"microsecond": 0
})
AfterMarketCloseEvent.set_trigger_time({
"hour": 23,
"minute": 00,
"second": 0,
"microsecond": 0
})
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 setUpClass(cls) -> None:
""" Setup a preset data provider and a scenario, in which the sized orders will exceed the volume limits. """
MarketCloseEvent.set_trigger_time({
"hour": 20,
"minute": 0,
"second": 0,
"microsecond": 0
})
cls.ticker = BloombergTicker("Example Index")
cls.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
def setUpClass(cls) -> None:
cls.end_date = str_to_date('2015-10-08')
cls.start_date = cls.end_date - RelativeDelta(years=2)
cls.timer = SettableTimer(cls.end_date)
cls.frequency = Frequency.DAILY
cls.TICKER_1 = BloombergFutureTicker("Cotton", "CT{} Comdty", 1, 3)
cls.TICKER_2 = BloombergFutureTicker("Corn", 'C {} Comdty', 1, 5)
cls.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
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.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self.orders = [
Order(
contract=self.contract_ticker_mapper.ticker_to_contract(msft_ticker),
quantity=1250,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC
),
Order(
contract=self.contract_ticker_mapper.ticker_to_contract(aapl_ticker),
quantity=-200,
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.market_on_close_order = [Order(
contract=self.contract_ticker_mapper.ticker_to_contract(msft_ticker),
quantity=1250,
execution_style=MarketOnCloseOrder(),
time_in_force=TimeInForce.GTC
)]
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 setUpClass(cls):
cls.contract = Contract('AAPL US Equity', 'STK', 'NASDAQ')
cls.ticker = BloombergTicker('AAPL US Equity')
cls.current_portfolio_value = 1000.0
cls.share_price = 10.0
position = Mock(spec=Position)
position.quantity.return_value = 10
position.contract.return_value = cls.contract
broker = Mock(spec=Broker)
broker.get_portfolio_value.return_value = cls.current_portfolio_value
broker.get_positions.return_value = [position]
data_handler = Mock(spec=DataHandler)
data_handler.get_last_available_price.return_value = QFSeries([cls.share_price], index=[cls.ticker])
cls.order_factory = OrderFactory(broker, data_handler, SimulatedBloombergContractTickerMapper())
def setUp(self) -> None:
self.ticker = BloombergTicker("Example Ticker")
self.future_ticker = MagicMock(spec=BloombergFutureTicker)
self.future_ticker.configure_mock(name="Example", family_id="Example{} Comdty", days_before_exp_date=1,
point_value=1)
self.alpha_model = MagicMock()
# Mock trading session
self.ts = MagicMock()
self.ts.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self.ts.timer = SettableTimer(str_to_date("2000-01-04 08:00:00.0", DateFormat.FULL_ISO))
self.positions_in_portfolio = [] # type: List[Contract]
"""Contracts for which a position in the portfolio currently exists. This list is used to return backtest
positions list by the broker."""
self.ts.broker.get_positions.side_effect = lambda: self.positions_in_portfolio
def setUp(self) -> None:
position = BrokerPosition(self.contract, self.initial_position, 25)
self.timer = Mock(spec=Timer)
self.timer.now.return_value = str_to_date("2017-01-01")
self.broker = Mock(spec=Broker)
self.broker.get_open_orders.return_value = []
self.broker.get_positions.return_value = [position]
data_handler = Mock(spec=DataHandler, timer=self.timer)
data_handler.get_last_available_price.side_effect = lambda _: self.last_price
order_factory = self._mock_order_factory(self.initial_position,
self.initial_allocation)
contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self.simple_position_sizer = SimplePositionSizer(
self.broker, data_handler, order_factory, contract_ticker_mapper,
BacktestSignalsRegister())
self.initial_risk_position_sizer = InitialRiskPositionSizer(
self.broker, data_handler, order_factory, contract_ticker_mapper,
BacktestSignalsRegister(), self.initial_risk,
self.max_target_percentage)
def setUp(self) -> None:
self.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self.current_date = str_to_date("2017-01-01")
self.timer = SettableTimer(self.current_date)
def __init__(self, data_provider: DataProvider, start_date, end_date, initial_cash,
frequency: Frequency = Frequency.MIN_1):
"""
Set up the backtest variables according to what has been passed in.
"""
super().__init__()
self.logger = qf_logger.getChild(self.__class__.__name__)
self.logger.info(
"\n".join([
"Testing the Backtester:",
"Start date: {:s}".format(date_to_str(start_date)),
"End date: {:s}".format(date_to_str(end_date)),
"Initial cash: {:.2f}".format(initial_cash),
"Frequency of the simulated execution handler: {}".format(frequency)
])
)
timer = SettableTimer(start_date)
notifiers = Notifiers(timer)
if frequency <= Frequency.DAILY:
data_handler = DailyDataHandler(data_provider, timer)
else:
data_handler = IntradayDataHandler(data_provider, timer)
contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
portfolio = Portfolio(data_handler, initial_cash, timer, contract_ticker_mapper)
signals_register = BacktestSignalsRegister()
backtest_result = BacktestResult(portfolio=portfolio, backtest_name="Testing the Backtester",
start_date=start_date, end_date=end_date, signals_register=signals_register)
monitor = Mock(spec=BacktestMonitor)
commission_model = FixedCommissionModel(0.0)
slippage_model = PriceBasedSlippage(0.0, data_provider, contract_ticker_mapper)
execution_handler = SimulatedExecutionHandler(
data_handler, timer, notifiers.scheduler, monitor, commission_model,
contract_ticker_mapper, portfolio, slippage_model)
broker = BacktestBroker(portfolio, execution_handler)
order_factory = OrderFactory(broker, data_handler, contract_ticker_mapper)
event_manager = self._create_event_manager(timer, notifiers)
time_flow_controller = BacktestTimeFlowController(
notifiers.scheduler, event_manager, timer, notifiers.empty_queue_event_notifier, end_date
)
position_sizer = SimplePositionSizer(broker, data_handler, order_factory, contract_ticker_mapper,
signals_register)
self.logger.info(
"\n".join([
"Configuration of components:",
"Position sizer: {:s}".format(position_sizer.__class__.__name__),
"Timer: {:s}".format(timer.__class__.__name__),
"Data Provider: {:s}".format(data_provider.__class__.__name__),
"Backtest Result: {:s}".format(backtest_result.__class__.__name__),
"Monitor: {:s}".format(monitor.__class__.__name__),
"Execution Handler: {:s}".format(execution_handler.__class__.__name__),
"Commission Model: {:s}".format(commission_model.__class__.__name__),
"Broker: {:s}".format(broker.__class__.__name__),
"Contract-Ticker Mapper: {:s}".format(contract_ticker_mapper.__class__.__name__)
])
)
self.broker = broker
self.notifiers = notifiers
self.initial_cash = initial_cash
self.start_date = start_date
self.end_date = end_date
self.event_manager = event_manager
self.contract_ticker_mapper = contract_ticker_mapper
self.data_handler = data_handler
self.portfolio = portfolio
self.execution_handler = execution_handler
self.position_sizer = position_sizer
self.orders_filters = []
self.monitor = monitor
self.timer = timer
self.order_factory = order_factory
self.time_flow_controller = time_flow_controller
class TestSlippage(TestCase):
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.contract_ticker_mapper = SimulatedBloombergContractTickerMapper()
self.orders = [
Order(
contract=self.contract_ticker_mapper.ticker_to_contract(msft_ticker),
quantity=1250,
execution_style=MarketOrder(),
time_in_force=TimeInForce.GTC
),
Order(
contract=self.contract_ticker_mapper.ticker_to_contract(aapl_ticker),
quantity=-200,
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.market_on_close_order = [Order(
contract=self.contract_ticker_mapper.ticker_to_contract(msft_ticker),
quantity=1250,
execution_style=MarketOnCloseOrder(),
time_in_force=TimeInForce.GTC
)]
def _create_data_provider_mock(self):
def get_price(tickers, fields, start_date, end_date, _):
prices_bar = [5.0, 10.0, 1.0, 4.0, 50] # Open, High, Low, Close, Volume
dates_index = pd.date_range(start_date, end_date, freq='B')
tickers, got_single_ticker = convert_to_list(tickers, Ticker)
fields, got_single_field = convert_to_list(fields, PriceField)
got_single_date = len(dates_index) == 1
prices_df = pd.DataFrame(
index=pd.Index(dates_index, name=TICKERS),
columns=pd.Index(PriceField.ohlcv(), name=FIELDS),
data=[prices_bar] * len(dates_index)
)
data_array = tickers_dict_to_data_array({
ticker: prices_df for ticker in self.tickers
}, self.tickers, PriceField.ohlcv())
return normalize_data_array(data_array.loc[start_date:end_date, tickers, fields], tickers, fields,
got_single_date, got_single_ticker, got_single_field)
data_provider = MagicMock()
data_provider.get_price.side_effect = get_price
return data_provider
def test_price_based_slippage__no_volume_limits(self):
"""Volume should remain the same. Prices should be increased by the slippage rate."""
slippage_rate = 0.1
slippage_model = PriceBasedSlippage(slippage_rate, self.data_provider, self.contract_ticker_mapper)
prices_without_slippage = [20.0, 30.0, 40.0]
# Each price should be changed by +0.1 / -0.1 depending on whether it is a BUY or SELL
expected_fill_prices = [22.0, 27.0, 44.0]
# Volumes should remain equal to the initial quantities
expected_fill_volumes = [order.quantity for order in self.orders] # [1250, -200, 1]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_price_based_slippage__with_volume(self):
"""Volume should be changed in case of exceeding limits. Slippage rate is set to 0.0, so the prices should
remain unchanged."""
slippage_rate = 0.0
max_volume_share_limit = 0.1
slippage_model = PriceBasedSlippage(slippage_rate, self.data_provider, self.contract_ticker_mapper,
max_volume_share_limit)
prices_without_slippage = [20.0, 30.0, 40.0]
expected_fill_prices = prices_without_slippage
# Mean historical volume is set to 50.0 for each of the tickers. As the max_volume_share_limit = 0.1, the limit
# is set to +/-5.0
expected_fill_volumes = [5.0, -5.0, 1]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_price_based_slippage__nan_prices(self):
slippage_rate = 0.1
slippage_model = PriceBasedSlippage(slippage_rate, self.data_provider, self.contract_ticker_mapper)
prices_without_slippage = [float('nan'), np.nan, float('nan')]
expected_fill_prices = [float('nan'), float('nan'), float('nan')]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
def test_fixed_slippage__no_volume(self):
"""Volume should remain unchanged. Prices should be increased by the slippage rate."""
slippage_per_share = 0.05
slippage_model = FixedSlippage(slippage_per_share=slippage_per_share, data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
prices_without_slippage = [20.0, 30.0, 40.0]
# [BUY, SELL, BUY] => [+, -, +]
expected_fill_prices = [20.0 + slippage_per_share, 30.0 - slippage_per_share, 40.0 + slippage_per_share]
# Volumes should remain equal to the initial quantities
expected_fill_volumes = [order.quantity for order in self.orders] # [1250, -200, 1]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_fixed_slippage__with_volume(self):
"""Prices should remain unchanged."""
slippage_per_share = 0.0
max_volume_share_limit = 0.1
slippage_model = FixedSlippage(slippage_per_share=slippage_per_share, data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper,
max_volume_share_limit=max_volume_share_limit)
prices_without_slippage = [20.0, 30.0, 40.0]
expected_fill_prices = prices_without_slippage
# Mean historical volume is set to 50.0 for each of the tickers.
expected_fill_volumes = [5.0, -5.0, 1]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_fixed_slippage__nan_prices(self):
slippage_per_share = 0.1
slippage_model = FixedSlippage(slippage_per_share, self.data_provider, self.contract_ticker_mapper)
prices_without_slippage = [float('nan'), np.nan, float('nan')]
expected_fill_prices = [float('nan'), float('nan'), float('nan')]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
def test_square_root_market_slippage__no_volume(self):
"""The volatility used by the slippage model is mocked to be equal to 0.1. The volume is equal to 50.0"""
price_impact = 0.1
close_prices_volatility = 0.1
prices_without_slippage = [20.0, 30.0, 40.0]
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
slippage_model._compute_volatility = Mock()
slippage_model._compute_volatility.return_value = close_prices_volatility
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date('2020-01-01'),
self.orders,
prices_without_slippage)
expected_fill_prices = [20.0 + 20.0 * price_impact * close_prices_volatility * math.sqrt(1250 / 50.0),
30.0 - 30.0 * price_impact * close_prices_volatility * math.sqrt(200 / 50.0),
40.0 + 40.0 * price_impact * close_prices_volatility * math.sqrt(1 / 50.0)]
# Volumes should remain equal to the initial quantities
expected_fill_volumes = [order.quantity for order in self.orders] # [1250, -200, 1]
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_square_root_market_slippage__no_volume_no_volatility(self):
"""As all the mocked close prices are equal, the volatility should be equal to 0.0. Thus, the prices do not
change after applying slippage."""
price_impact = 0.1
prices_without_slippage = [20.0, 30.0, 40.0]
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date('2020-01-01'),
self.orders,
prices_without_slippage)
expected_fill_prices = prices_without_slippage
# Volumes should remain equal to the initial quantities
expected_fill_volumes = [order.quantity for order in self.orders] # [1250, -200, 1]
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_square_root_market_slippage__with_volume(self):
"""The volatility used by the slippage model is mocked to be equal to 0.1. The volume is equal to 50.0"""
price_impact = 0.1
max_volume_share_limit = 0.1
close_prices_volatility = 0.1
prices_without_slippage = [20.0, 30.0, 40.0]
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper,
max_volume_share_limit=max_volume_share_limit)
slippage_model._compute_volatility = Mock()
slippage_model._compute_volatility.return_value = close_prices_volatility
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date('2020-01-01'),
self.orders,
prices_without_slippage)
expected_fill_prices = [20.0 + 20.0 * price_impact * close_prices_volatility * math.sqrt(5.0 / 50.0),
30.0 - 30.0 * price_impact * close_prices_volatility * math.sqrt(5.0 / 50.0),
40.0 + 40.0 * price_impact * close_prices_volatility * math.sqrt(1 / 50.0)]
expected_fill_volumes = [5.0, -5.0, 1.0]
assert_lists_equal(expected_fill_prices, actual_fill_prices)
assert_lists_equal(expected_fill_volumes, actual_fill_volumes)
def test_square_root_market_slippage__nan_volatility(self):
price_impact = 0.1
close_prices_volatility = float('nan')
prices_without_slippage = [float('nan'), np.nan, 40]
expected_fill_prices = [float('nan'), float('nan'), float('nan')]
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
slippage_model._compute_volatility = Mock()
slippage_model._compute_volatility.return_value = close_prices_volatility
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
def test_square_root_market_slippage__nan_prices_without_slippage(self):
price_impact = 0.1
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
prices_without_slippage = [float('nan'), np.nan, float('nan')]
expected_fill_prices = [float('nan'), float('nan'), float('nan')]
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
def test_square_root_market_slippage__nan_average_daily_volume(self):
price_impact = 0.1
avg_daily_volume = float('nan')
prices_without_slippage = [20, 30, 40]
expected_fill_prices = [float('nan'), float('nan'), float('nan')]
slippage_model = SquareRootMarketImpactSlippage(price_impact=price_impact,
data_provider=self.data_provider,
contract_ticker_mapper=self.contract_ticker_mapper)
slippage_model._compute_average_volume = Mock()
slippage_model._compute_average_volume.return_value = avg_daily_volume
actual_fill_prices, actual_fill_volumes = slippage_model.process_orders(str_to_date("2020-01-01"),
self.orders,
prices_without_slippage)
assert_lists_equal(expected_fill_prices, actual_fill_prices)
def setUp(self):
MarketOpenEvent.set_trigger_time({
"hour": 13,
"minute": 30,
"second": 0,
"microsecond": 0
})
MarketCloseEvent.set_trigger_time({
"hour": 20,
"minute": 0,
"second": 0,
"microsecond": 0
})
self.start_date = str_to_date("2018-02-04")
self.number_of_minutes = 5
before_close = self.start_date + MarketCloseEvent.trigger_time(
) - RelativeDelta(minutes=self.number_of_minutes)
self.msft_contract = Contract(self.MSFT_TICKER_STR,
security_type='STK',
exchange='TEST')
self.msft_ticker = BloombergTicker(self.MSFT_TICKER_STR)
contracts_to_tickers_mapper = SimulatedBloombergContractTickerMapper()
self.timer = SettableTimer(initial_time=before_close)
self.data_handler = Mock(spec=DataHandler)
scheduler = Mock(spec=Scheduler)
ScheduleOrderExecutionEvent.clear()
# Set the periodic bar events to intraday trading
IntradayBarEvent.frequency = Frequency.MIN_1
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, scheduler, self.monitor,
commission_model, contracts_to_tickers_mapper, self.portfolio,
slippage_model, RelativeDelta(minutes=self.number_of_minutes))
self._set_last_available_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_handler.assign_order_ids([
self.stop_loss_order_1, self.stop_loss_order_2,
self.stop_loss_order_3
])