def main():
data_provider = container.resolve(GeneralPriceProvider)
benchmark_tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'),
PriceField.Close, start_date,
end_date)
strategy_tms = data_provider.get_price(QuandlTicker('MSFT', 'WIKI'),
PriceField.Close, start_date,
end_date)
regression_chart = RegressionChart(benchmark_tms=benchmark_tms,
strategy_tms=strategy_tms)
regression_chart.plot()
plt.show(block=True)
def main():
data_provider = container.resolve(QuandlDataProvider) # type: QuandlDataProvider
start_date = str_to_date('2016-01-01')
end_date = str_to_date('2017-11-02')
print('Single ticker:')
ticker = QuandlTicker('IBM', 'WIKI')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Single ticker: lower case')
ticker = QuandlTicker('ibm', 'wiki')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Single ticker:')
ticker = QuandlTicker('IBM', 'WIKI/PRICES', QuandlDBType.Table)
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Single ticker, Price')
ticker = QuandlTicker('IBM', 'WIKI/PRICES', QuandlDBType.Table)
data = data_provider.get_price(tickers=ticker, fields=PriceField.Close, start_date=start_date, end_date=end_date)
print(data)
print('Continues Futures - CHRIS')
ticker = QuandlTicker('ASX_TN2', 'CHRIS')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Futures - ICE')
ticker = QuandlTicker('OZ2019', 'ICE')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Futures - CME')
ticker = QuandlTicker('EMF2018', 'CME')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Futures - EUREX')
ticker = QuandlTicker('FCXEZ2018', 'EUREX')
data = data_provider.get_history(tickers=ticker, start_date=start_date, end_date=end_date)
print(data)
print('Continues Futures - CHRIS')
ticker = QuandlTicker('ASX_TN2', 'CHRIS')
data = data_provider.get_price(tickers=ticker, fields=PriceField.Close, start_date=start_date, end_date=end_date)
print(data)
def main():
initial_risk = 0.03
start_date = str_to_date('2010-01-01')
end_date = str_to_date('2011-12-31')
# Use the preset daily data provider
data_provider = daily_data_provider
# ----- build trading session ----- #
session_builder = container.resolve(
BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_backtest_name('Moving Average Alpha Model Backtest')
session_builder.set_position_sizer(InitialRiskPositionSizer,
initial_risk=initial_risk)
session_builder.set_commission_model(IBCommissionModel)
session_builder.set_data_provider(data_provider)
session_builder.set_frequency(Frequency.DAILY)
ts = session_builder.build(start_date, end_date)
# ----- build models ----- #
model = MovingAverageAlphaModel(fast_time_period=5,
slow_time_period=20,
risk_estimation_factor=1.25,
data_provider=ts.data_handler)
model_tickers = [
DummyTicker('AAA'),
DummyTicker('BBB'),
DummyTicker('CCC'),
DummyTicker('DDD'),
DummyTicker('EEE'),
DummyTicker('FFF')
]
model_tickers_dict = {model: model_tickers}
# ----- preload price data ----- #
ts.use_data_preloading(model_tickers)
# Verify the checksum of preloaded data with the precomputed value
ts.verify_preloaded_data("778bbaac65cb0a5a848167999b88cf29a1cd8467")
# ----- start trading ----- #
strategy = AlphaModelStrategy(ts, model_tickers_dict, use_stop_losses=True)
# Set the signal generation and orders placement to be performed at the OnBeforeMarketOpen event
OnBeforeMarketOpenSignalGeneration(strategy)
ts.start_trading()
def main():
data_provider = container.resolve(GeneralPriceProvider)
prices_tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'),
PriceField.Close, start_date,
end_date)
chart = create_return_quantiles(prices_tms, live_start_date)
chart.plot()
chart = create_return_quantiles(prices_tms)
chart.plot()
chart = create_return_quantiles(prices_tms, end_date)
chart.plot()
plt.show(block=True)
def main():
# settings
backtest_name = 'Simple MA Strategy Demo'
start_date = str_to_date("2010-01-01")
end_date = str_to_date("2015-03-01")
ticker = DummyTicker("AAA")
# configuration
session_builder = container.resolve(BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_frequency(Frequency.DAILY)
session_builder.set_backtest_name(backtest_name)
session_builder.set_data_provider(daily_data_provider)
ts = session_builder.build(start_date, end_date)
OnBeforeMarketOpenSignalGeneration(SimpleMAStrategy(ts, ticker))
ts.start_trading()
def main():
data_provider = container.resolve(GeneralPriceProvider)
spy_tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'),
PriceField.Close, start_date, end_date)
first_part = spy_tms.loc[spy_tms.index < live_start_date]
first_part.name = 'first part of series'
last_part = spy_tms.loc[spy_tms.index > live_start_date]
last_part.name = 'last part of series'
returns_similarity_chart = create_returns_similarity(
first_part,
last_part,
mean_normalization=False,
std_normalization=False,
)
returns_similarity_chart.plot()
plt.show(block=True)
def get_data():
data_provider = container.resolve(
QuandlDataProvider) # type: QuandlDataProvider
start_date = str_to_date('2010-01-01')
end_date = str_to_date('2017-12-31')
live_date = str_to_date('2015-01-01')
strategy = data_provider.get_price(tickers=QuandlTicker('AAPL', 'WIKI'),
fields=PriceField.Close,
start_date=start_date,
end_date=end_date)
benchmark = data_provider.get_price(tickers=QuandlTicker('IBM', 'WIKI'),
fields=PriceField.Close,
start_date=start_date,
end_date=end_date)
strategy.name = "Strategy"
benchmark.name = "Benchmark"
return strategy, benchmark, live_date
def main():
data_provider = container.resolve(GeneralPriceProvider)
prices_tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'),
PriceField.Close, start_date,
end_date)
line_chart = LineChart()
data_element = DataElementDecorator(prices_tms)
line_chart.add_decorator(data_element)
sample_date = str_to_date('2008-06-01')
# if you want to test FigureCoordinates, you may want to pass additional argument: clip_on=False
text_decorator = TextDecorator("Sample text",
x=DataCoordinate(sample_date),
y=AxesCoordinate(0.9))
line_chart.add_decorator(text_decorator)
line_chart.plot()
plt.show(block=True)
def main():
data_provider = container.resolve(GeneralPriceProvider)
prices_tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'),
PriceField.Close, start_date,
end_date)
line_chart = LineChart()
data_element = DataElementDecorator(prices_tms)
line_chart.add_decorator(data_element)
legend = LegendDecorator(legend_placement=Location.BEST, key='legend')
legend.add_entry(data_element, 'SPY')
line_chart.add_decorator(legend)
cone_decorator = ConeDecorator(live_start_date=live_start_date,
series=prices_tms,
key='cone')
line_chart.add_decorator(cone_decorator)
line_chart.plot()
plt.show(block=True)
def main():
data_provider = container.resolve(GeneralPriceProvider) # type: GeneralPriceProvider
msi = MarketStressIndicator(tickers, weights, data_provider)
stress_indicator_tms = msi.get_indicator(years_rolling, start_date, end_date, step)
# stress_indicator_tms = cached_value(_get_indicator, indicator_cache_path) # type: QFSeries
fig_size = (10, 5)
title = "Stress Indicator US {}Y rolling".format(years_rolling)
chart = create_line_chart([stress_indicator_tms], ['Stress Indicator'], title)
chart.plot(figsize=fig_size)
no_none_indicator_tms = stress_indicator_tms.dropna()
histogram = HistogramChart(no_none_indicator_tms, best_fit=False, bins=100)
histogram.plot(figsize=fig_size)
# Get SPX Index
spx = BloombergTicker('SPX Index')
spx_index_tms = data_provider.get_price(spx, PriceField.Close, no_none_indicator_tms.first_valid_index(), end_date)
spx_returns = spx_index_tms.to_simple_returns()
# Calculate managed series
managed_series = SimpleReturnsSeries()
for date, ret in spx_returns.iteritems():
risk_value = no_none_indicator_tms.asof(date - timedelta(days=2))
leverage = 1
if risk_value > 0.35:
leverage = 0.66
if risk_value > 1.5:
leverage = 0.33
managed_ret = ret * leverage
managed_series[date] = managed_ret
# Plot managed and pure SPX series
chart = create_line_chart(
[spx_returns.to_prices(), managed_series.to_prices()],
['SPX Index', "SPX with Stress Indicator"])
chart.plot(figsize=fig_size)
plt.show(block=True)
def main():
model_type = MovingAverageAlphaModel
initial_risk = 0.03
commission_model = IBCommissionModel()
start_date = str_to_date('2016-01-01')
end_date = str_to_date('2017-12-31')
# ----- build trading session ----- #
session_builder = container.resolve(
BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_backtest_name('Moving Average Alpha Model Backtest')
session_builder.set_position_sizer(InitialRiskPositionSizer, initial_risk)
session_builder.set_contract_ticker_mapper(
DummyQuandlContractTickerMapper())
session_builder.set_commission_model(commission_model)
session_builder.set_monitor_type(BacktestMonitor)
ts = session_builder.build(start_date, end_date)
# ----- build models ----- #
model_factory = AlphaModelFactory(ts.data_handler)
model = model_factory.make_parametrized_model(model_type)
model_tickers = [
QuandlTicker('AAPL', 'WIKI'),
QuandlTicker('AMZN', 'WIKI')
]
model_tickers_dict = {model: model_tickers}
# ----- preload price data ----- #
all_tickers_used = get_all_tickers_used(model_tickers_dict)
ts.use_data_preloading(all_tickers_used)
# ----- start trading ----- #
AlphaModelStrategy(ts, model_tickers_dict, use_stop_losses=True)
ts.start_trading()
# ----- use results ----- #
backtest_tms = ts.portfolio.get_portfolio_timeseries().to_log_returns()
print("mean daily log return: {}".format(backtest_tms.mean()))
print("std of daily log returns: {}".format(backtest_tms.std()))
def get_trade_rets_values(init_risk: float, alpha_model_type: Type[AlphaModel]) -> List[float]:
start_date = str_to_date('2013-01-01')
end_date = str_to_date('2016-12-31')
session_builder = container.resolve(BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_position_sizer(InitialRiskPositionSizer, init_risk)
session_builder.set_monitor_type(BacktestMonitor)
session_builder.set_backtest_name("Initial Risk Testing - {}".format(init_risk))
ts = session_builder.build(start_date, end_date)
model_factory = AlphaModelFactory(ts.data_handler)
model = model_factory.make_parametrized_model(alpha_model_type)
model_tickers_dict = {model: [BloombergTicker('SVXY US Equity')]}
AlphaModelStrategy(ts, model_tickers_dict, use_stop_losses=True)
ts.use_data_preloading(get_all_tickers_used(model_tickers_dict))
ts.start_trading()
trades = ts.portfolio.get_trades()
returns_of_trades = [(t.exit_price / t.entry_price - 1) * np.sign(t.quantity) for t in trades]
return returns_of_trades
def map_future_ticker_to_contract():
mapping = {
BloombergFutureTicker('Copper', 'HG{} Comdty', 1, 1, 250):
IBContract("HG", SecurityType.FUTURE, "NYMEX", "25000", "USD"),
BloombergTicker("PAH20 Comdty", SecurityType.FUTURE, 100):
IBContract("PA", SecurityType.FUTURE, "NYMEX", "100", "",
str_to_date("2020-03-27"))
}
data_provider = container.resolve(BloombergDataProvider)
contract_ticker_mapper = IBContractTickerMapper(mapping, data_provider)
current_time = str_to_date("2020-12-01")
for future_ticker in mapping.keys():
if isinstance(future_ticker, BloombergFutureTicker):
future_ticker.initialize_data_provider(SettableTimer(current_time),
data_provider)
print("\nMapping PAH20 Comdty ticker to IB contract")
ticker = BloombergTicker("PAH20 Comdty", SecurityType.FUTURE, 100)
contract = contract_ticker_mapper.ticker_to_contract(ticker)
print(f"Ticker mapped onto the following contract: {contract}")
print("\nMapping IBContract onto ticker")
contract = IBContract("PA", SecurityType.FUTURE, "NYMEX", "100", "",
str_to_date("2020-03-27"))
ticker = contract_ticker_mapper.contract_to_ticker(contract)
print(f"Contract mapped onto the following ticker: {ticker}")
print(
"\nMapping HGH20 Comdty ticker - Copper, March 2020 futures contracts")
ticker = BloombergTicker("HGH20 Comdty", SecurityType.FUTURE, 250)
contract = contract_ticker_mapper.ticker_to_contract(ticker)
print(f"Ticker mapped onto the following contract: {contract}")
print("\nMapping IBContract onto ticker")
contract = IBContract("HG", SecurityType.FUTURE, "NYMEX", "25000", "USD",
str_to_date("2021-01-27"))
ticker = contract_ticker_mapper.contract_to_ticker(contract)
print(f"Contract mapped onto the following ticker: {ticker}")
def main():
start_date = str_to_date("2010-01-01")
end_date = str_to_date("2011-01-01")
session_builder = container.resolve(BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_backtest_name('Simple_MA')
session_builder.set_initial_cash(1000000)
ts = session_builder.build(start_date, end_date)
ts.use_data_preloading(SimpleMAStrategy.ticker, RelativeDelta(days=40))
SimpleMAStrategy(ts)
ts.start_trading()
actual_end_value = ts.portfolio.get_portfolio_timeseries()[-1]
expected_value = 898294.64
print("Expected End Value = {}".format(expected_value))
print("Actual End Value = {}".format(actual_end_value))
print("DIFF = {}".format(expected_value - actual_end_value))
test = TestCase()
test.assertAlmostEqual(expected_value, actual_end_value, places=2)
def main():
initial_risk = 0.03
start_date = str_to_date('2016-01-01')
end_date = str_to_date('2017-12-31')
# ----- build trading session ----- #
session_builder = container.resolve(
BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_backtest_name('Moving Average Alpha Model Backtest')
session_builder.set_position_sizer(InitialRiskPositionSizer,
initial_risk=initial_risk)
session_builder.set_commission_model(IBCommissionModel)
session_builder.set_frequency(Frequency.DAILY)
ts = session_builder.build(start_date, end_date)
# ----- build models ----- #
model = MovingAverageAlphaModel(fast_time_period=5,
slow_time_period=20,
risk_estimation_factor=1.25,
data_provider=ts.data_handler)
model_tickers = [
QuandlTicker('AAPL', 'WIKI'),
QuandlTicker('AMZN', 'WIKI')
]
model_tickers_dict = {model: model_tickers}
# ----- preload price data ----- #
ts.use_data_preloading(model_tickers)
# ----- start trading ----- #
OnBeforeMarketOpenSignalGeneration(
AlphaModelStrategy(ts, model_tickers_dict, use_stop_losses=True))
ts.start_trading()
# ----- use results ----- #
backtest_tms = ts.portfolio.portfolio_eod_series().to_log_returns()
print("mean daily log return: {}".format(backtest_tms.mean()))
print("std of daily log returns: {}".format(backtest_tms.std()))
def main():
# settings
backtest_name = 'Intraday MA Strategy Demo'
start_date = str_to_date("2019-07-01")
end_date = str_to_date("2019-10-01")
ticker = DummyTicker("AAA")
setup_logging(logging.INFO, console_logging=True)
OnNewBarEvent.set_frequency(Frequency.MIN_15)
OnNewBarEvent.set_start_and_end_time({"hour": 10, "minute": 0, "second": 0, "microsecond": 0},
{"hour": 13, "minute": 0, "second": 0, "microsecond": 0})
# configuration
session_builder = container.resolve(BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_frequency(Frequency.MIN_1)
session_builder.set_backtest_name(backtest_name)
session_builder.set_data_provider(intraday_data_provider)
ts = session_builder.build(start_date, end_date)
OnNewBarSignalGeneration(IntradayMAStrategy(ts, ticker))
ts.start_trading()
def run_strategy(data_provider: DataProvider) -> Tuple[float, str]:
""" Returns the strategy end result and checksum of the preloaded data. """
start_date = str_to_date("2010-01-01")
end_date = str_to_date("2011-01-01")
session_builder = container.resolve(
BacktestTradingSessionBuilder) # type: BacktestTradingSessionBuilder
session_builder.set_backtest_name('Simple_MA')
session_builder.set_initial_cash(1000000)
session_builder.set_frequency(Frequency.DAILY)
session_builder.set_data_provider(data_provider)
session_builder.set_monitor_settings(BacktestMonitorSettings.no_stats())
ts = session_builder.build(start_date, end_date)
ts.use_data_preloading(SimpleMAStrategy.ticker, RelativeDelta(days=40))
SimpleMAStrategy(ts)
ts.start_trading()
data_checksum = ts.get_preloaded_data_checksum()
actual_end_value = ts.portfolio.portfolio_eod_series()[-1]
return actual_end_value, data_checksum
def main():
data_provider = container.resolve(GeneralPriceProvider)
_calculate_single_values(data_provider)
_calculate_timeseries(data_provider)
# limitations under the License.
import matplotlib.pyplot as plt
from demo_scripts.demo_configuration.demo_ioc import container
from qf_lib.common.enums.matplotlib_location import Location
from qf_lib.common.enums.price_field import PriceField
from qf_lib.common.tickers.tickers import QuandlTicker
from qf_lib.common.utils.dateutils.string_to_date import str_to_date
from qf_lib.data_providers.general_price_provider import GeneralPriceProvider
from qf_lib.plotting.charts.line_chart import LineChart
from qf_lib.plotting.decorators.axes_label_decorator import AxesLabelDecorator
from qf_lib.plotting.decorators.data_element_decorator import DataElementDecorator
from qf_lib.plotting.decorators.legend_decorator import LegendDecorator
data_provider = container.resolve(GeneralPriceProvider)
start_date = str_to_date('1996-01-01')
end_date = str_to_date('2014-01-01')
def main():
tms = data_provider.get_price(QuandlTicker('AAPL', 'WIKI'), PriceField.Close, start_date, end_date)
tms2 = data_provider.get_price(QuandlTicker('MSFT', 'WIKI'), PriceField.Close, start_date, end_date)
line_chart = LineChart()
data_element = DataElementDecorator(tms)
line_chart.add_decorator(data_element)
data_element2 = DataElementDecorator(tms2, use_secondary_axes=True)
line_chart.add_decorator(data_element2)
