def __init__(self, ts: TradingSession, model_tickers_dict: Dict[AlphaModel, Sequence[Ticker]], use_stop_losses=True,
max_open_positions: Optional[int] = None):
all_future_tickers = [ticker for tickers_for_model in model_tickers_dict.values()
for ticker in tickers_for_model if isinstance(ticker, FutureTicker)]
self._futures_rolling_orders_generator = self._get_futures_rolling_orders_generator(all_future_tickers,
ts.timer, ts.data_handler,
ts.broker, ts.order_factory,
ts.contract_ticker_mapper)
self._broker = ts.broker
self._order_factory = ts.order_factory
self._data_handler = ts.data_handler
self._contract_ticker_mapper = ts.contract_ticker_mapper
self._position_sizer = ts.position_sizer
self._orders_filters = ts.orders_filters
self._timer = ts.timer
self._model_tickers_dict = model_tickers_dict
self._use_stop_losses = use_stop_losses
self._max_open_positions = max_open_positions
ts.notifiers.scheduler.subscribe(BeforeMarketOpenEvent, listener=self)
self.logger = qf_logger.getChild(self.__class__.__name__)
self._log_configuration()
def __init__(self,
data_provider: DataProvider,
max_volume_share_limit: Optional[float] = None):
self.max_volume_share_limit = max_volume_share_limit
self._data_provider = data_provider
self._logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, data_handler: DataHandler, initial_cash: float, timer: Timer,
contract_ticker_mapper: ContractTickerMapper):
"""
On creation, the Portfolio object contains no positions and all values are "reset" to the initial
cash, with no PnL.
"""
self.initial_cash = initial_cash
self.data_handler = data_handler
self.timer = timer
self.contract_ticker_mapper = contract_ticker_mapper
"""cash value includes futures P&L + stock value + securities options value + bond value + fund value."""
self.net_liquidation = initial_cash
"""equals the sum of the absolute value of all positions except cash """
self.gross_value_of_positions = 0
# dates and portfolio values are keep separately because it is inefficient to append to the QFSeries
# use get_portfolio_timeseries() to get them as a series.
self.dates = [] # type: List[datetime]
self.portfolio_values = [] # type: List[float]
self.current_cash = initial_cash
self._leverage = [] # type: List[float]
self.open_positions_dict = {} # type: Dict[Contract, BacktestPosition]
self.closed_positions = [] # type: List[BacktestPosition]
self.transactions = [] # type: List[Transaction]
self.trades = [] # type: List[Trade]
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, contract_ticker_mapper: ContractTickerMapper,
start_date, end_date, position_sizer: PositionSizer,
data_handler: DataHandler, timer: SettableTimer,
notifiers: Notifiers, portfolio: Portfolio,
events_manager: EventManager, monitor: BacktestMonitor,
broker: BacktestBroker, order_factory: OrderFactory):
"""
Set up the backtest variables according to what has been passed in.
"""
super().__init__()
self.logger = qf_logger.getChild(self.__class__.__name__)
self.contract_ticker_mapper = contract_ticker_mapper
self.start_date = start_date
self.end_date = end_date
self.notifiers = notifiers
self.event_manager = events_manager
self.data_handler = data_handler
self.portfolio = portfolio
self.position_sizer = position_sizer
self.monitor = monitor
self.timer = timer
self.order_factory = order_factory
self.broker = broker
def __init__(self, host: str, session: requests.Session, account_url: str,
trigger_url: str):
self.host = host
self.session = session
self.account_url = account_url
self.trigger_url = trigger_url
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, alpha_model_configs: Sequence[FastAlphaModelTesterConfig],
tickers: Sequence[Ticker],
contract_ticker_mapper: ContractTickerMapper, start_date: datetime, end_date: datetime,
data_handler: FastDataHandler, timer: SettableTimer, n_jobs: int = 1):
self.logger = qf_logger.getChild(self.__class__.__name__)
self._start_date = start_date
self._end_date = end_date
self._contract_ticker_mapper = contract_ticker_mapper
self._alpha_model_configs = alpha_model_configs
assert len(set(config.model_type for config in alpha_model_configs)) == 1, \
"All passed FastAlphaModelTesterConfig should have the same alpha model type"
self._model_type = alpha_model_configs[0].model_type
self._data_handler = data_handler
self._timer = timer
self._tickers_to_contracts = self._get_valid_tickers_to_contracts(tickers)
self._tickers = list(self._tickers_to_contracts.keys())
self._n_jobs = n_jobs
if type(self._data_handler) is not FastDataHandler:
self.logger.warning("You are using a deprecated type of DataHandler. In FastAlphaModelsTester "
"use of FastDataHandler is suggested.")
def __init__(self,
data=None,
index=None,
columns=None,
dtype=None,
copy=False):
self.logger = qf_logger.getChild(self.__class__.__name__)
# Data Frame containing the table data
self.data = QFDataFrame(data, index, columns, dtype, copy)
# Dictionary containing a mapping from column names onto ColumnStyles
self._columns_styles = {
column_name: self.ColumnStyle(column_name)
for column_name in self.data.columns.tolist()
}
# Series containing the styles for each of the rows
self._rows_styles = QFSeries(
data=[self.RowStyle(loc) for loc in self.data.index],
index=self.data.index)
# Data Frame containing styles for all cells in the table, based upon columns_styles and rows_styles
self._styles = QFDataFrame(data={
column_name: [
self.CellStyle(row_style, column_style)
for row_style in self.rows_styles
]
for column_name, column_style in self.columns_styles.items()
},
index=self.data.index,
columns=self.data.columns)
self.table_styles = self.Style()
def __init__(self, scheduler: Scheduler, event_manager: EventManager,
real_timer: RealTimer,
empty_queue_event_notifier: EmptyQueueEventNotifier):
super().__init__(event_manager, empty_queue_event_notifier)
self.scheduler = scheduler
self.real_timer = real_timer
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, analysed_tms: QFSeries, regressors_df: QFDataFrame, frequency: Frequency,
factors_identifier: FactorsIdentifier, is_fit_intercept: bool = True):
"""
Parameters
----------
analysed_tms
must have a set name in order to be displayed properly later on
regressors_df
must have a set name for each column in order to be displayed properly later on
frequency
frequency of every series (the same for all)
factors_identifier
class used for identifying significant factors for the model (picks them up from regressors_df)
is_fit_intercept
default True; True if the calculated model should include the intercept coefficient
"""
self.logger = qf_logger.getChild(self.__class__.__name__)
self.analysed_tms = analysed_tms.to_simple_returns()
self.regressors_df = regressors_df.to_simple_returns()
self.frequency = frequency
self.factors_identifier = factors_identifier
self.is_fit_intercept = is_fit_intercept
self.used_regressors_ = None # data frame of regressors used in the model
self.used_fund_returns_ = None # analysed timeseries without dates unused in the regression
self.coefficients_vector_ = None # vector of coefficients for each regressor used in the model
self.intercept_ = None # the independent term in a linear model
def __init__(self, settings: Settings):
self.settings = settings
self.host = settings.bloomberg.host
self.port = settings.bloomberg.port
self.logger = qf_logger.getChild(self.__class__.__name__)
if is_blpapi_installed:
session_options = blpapi.SessionOptions()
session_options.setServerHost(self.host)
session_options.setServerPort(self.port)
session_options.setAutoRestartOnDisconnection(True)
self.session = blpapi.Session(session_options)
self._historical_data_provider = HistoricalDataProvider(
self.session)
self._reference_data_provider = ReferenceDataProvider(self.session)
self._tabular_data_provider = TabularDataProvider(self.session)
self._futures_data_provider = FuturesDataProvider(self.session)
else:
self.session = None
self._historical_data_provider = None
self._reference_data_provider = None
self._tabular_data_provider = None
self._futures_data_provider = None
self.logger.warning(
"Couldn't import the Bloomberg API. Check if the necessary dependencies are installed."
)
self.connected = False
def __init__(self, backtest_result: BacktestResult, settings: Settings,
pdf_exporter: PDFExporter, excel_exporter: ExcelExporter):
self.backtest_result = backtest_result
self.logger = qf_logger.getChild(self.__class__.__name__)
self._settings = settings
self._pdf_exporter = pdf_exporter
self._excel_exporter = excel_exporter
# Set up an empty chart that can be updated
self._figure, self._ax = plt.subplots()
self._figure.set_size_inches(12, 5)
self._line, = self._ax.plot([], [])
self._ax.set_autoscaley_on(True)
end_date = backtest_result.end_date
if end_date is None:
end_date = datetime.now()
self._ax.set_xlim(backtest_result.start_date, end_date)
self._ax.grid()
self._ax.set_title("Progress of the backtest - {}".format(
backtest_result.backtest_name))
self._figure.autofmt_xdate(rotation=20)
self._file_name_template = datetime.now().strftime(
"%Y_%m_%d-%H%M {}".format(backtest_result.backtest_name))
self._report_dir = "backtesting"
self._csv_file = self._init_csv_file(self._file_name_template)
self._csv_writer = csv.writer(self._csv_file)
def __init__(self, data_handler: DataHandler, timer: Timer,
scheduler: Scheduler, monitor: AbstractMonitor,
commission_model: CommissionModel,
contracts_to_tickers_mapper: ContractTickerMapper,
portfolio: Portfolio, slippage_model: Slippage) -> None:
scheduler.subscribe(MarketOpenEvent, self)
scheduler.subscribe(MarketCloseEvent, self)
self.logger = qf_logger.getChild(self.__class__.__name__)
self.data_handler = data_handler
self.commission_model = commission_model
self.contracts_to_tickers_mapper = contracts_to_tickers_mapper
self.portfolio = portfolio
order_id_generator = count(start=1)
self._market_orders_executor = MarketOrdersExecutor(
contracts_to_tickers_mapper, data_handler, monitor, portfolio,
timer, order_id_generator, commission_model, slippage_model)
self._stop_orders_executor = StopOrdersExecutor(
contracts_to_tickers_mapper, data_handler, monitor, portfolio,
timer, order_id_generator, commission_model, slippage_model)
self._market_on_close_orders_executor = MarketOnCloseOrdersExecutor(
contracts_to_tickers_mapper, data_handler, monitor, portfolio,
timer, order_id_generator, commission_model, slippage_model)
def __init__(self,
max_number_of_regressors: int = 10,
epsilon: float = 0.05,
l1_ratio: float = 1,
number_of_alphas: int = 75,
is_intercept: bool = True,
graphic_debug: bool = False):
"""
Parameters
----------
max_number_of_regressors
maximal number of regressors that can be included in the model
epsilon
if abs(coefficient) is smaller than epsilon it is considered to be zero, thus won't be included
in the model
l1_ratio
value between [0,1] the higher the simpler and more sensitive model is to collinear factors
number_of_alphas
number of different lambda values tested
is_intercept
True if intercept should be included in the model, False otherwise
graphic_debug
default False; If True, then some additional debug info will be plotted (used when tuning
the ElasticNetFactorsIdentifier's parameters)
"""
self.logger = qf_logger.getChild(self.__class__.__name__)
self.max_number_of_regressors = max_number_of_regressors
self.epsilon = epsilon
self.l1_ratio = l1_ratio
self.number_of_alphas = number_of_alphas
self.is_intercept = is_intercept
self.graphic_debug = graphic_debug
self.coeffs_chart = None
self.mse_chart = None
def __init__(self, broker: Broker, data_provider: DataProvider, order_factory: OrderFactory,
signals_register: SignalsRegister):
self._broker = broker
self._data_provider = data_provider
self._order_factory = order_factory
self._signals_register = signals_register
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self,
ts: TradingSession,
model_tickers_dict: Dict[AlphaModel, Sequence[Ticker]],
use_stop_losses=True):
"""
Parameters
----------
ts
Trading session
model_tickers_dict
Dict mapping models to list of tickers that the model trades. (The tickers for which the
model gives recommendations)
use_stop_losses
flag indicating if the stop losses should be used or not. If False, all stop orders are ignored
"""
self._broker = ts.broker
self._order_factory = ts.order_factory
self._data_handler = ts.data_handler
self._contract_ticker_mapper = ts.contract_ticker_mapper
self._position_sizer = ts.position_sizer
self._timer = ts.timer
self._model_tickers_dict = model_tickers_dict
self._use_stop_losses = use_stop_losses
self.signals_df = QFDataFrame(
) # rows indexed by date and columns by "Ticker@AlphaModel" string
ts.notifiers.scheduler.subscribe(BeforeMarketOpenEvent, listener=self)
self.logger = qf_logger.getChild(self.__class__.__name__)
self._log_configuration()
def get_weights(cls,
minimised_func: Callable[[Sequence[float]], float],
num_of_assets: int,
upper_constraints: Union[float, Sequence[float]],
max_iter: int = 10000) -> np.ndarray:
one_over_n_weights = np.array([1 / num_of_assets] * num_of_assets)
bounds = cls._get_bounds(num_of_assets, upper_constraints)
def weights_sum_to_one_fun(weights):
result = weights.sum() - 1.0
return result
weights_sum_up_to_one_constr = {
'type': 'eq',
'fun': weights_sum_to_one_fun
}
options = {'disp': False, 'maxiter': max_iter}
optimization_result = scipy.optimize.minimize(
fun=minimised_func,
method='SLSQP',
x0=one_over_n_weights,
bounds=bounds,
constraints=weights_sum_up_to_one_constr,
options=options)
logger = qf_logger.getChild(cls.__name__)
if optimization_result.success:
logger.info(optimization_result.message)
else:
logger.warning("Unsuccessful optimization: " +
optimization_result.message)
return optimization_result.x
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 __init__(self, ts: TradingSession, model_tickers_dict: Dict[AlphaModel, Sequence[Ticker]], use_stop_losses=True,
max_open_positions: Optional[int] = None, time_in_force: Optional[TimeInForce] = TimeInForce.OPG):
super().__init__(ts)
all_future_tickers = [ticker for tickers_for_model in model_tickers_dict.values()
for ticker in tickers_for_model if isinstance(ticker, FutureTicker)]
self._futures_rolling_orders_generator = self._get_futures_rolling_orders_generator(all_future_tickers,
ts.timer, ts.data_provider,
ts.broker, ts.order_factory)
self._broker = ts.broker
self._order_factory = ts.order_factory
self._position_sizer = ts.position_sizer
self._orders_filters = ts.orders_filters
self._frequency = ts.frequency
assert ts.frequency is not None, "Trading Session does not have the frequency parameter set. You need to set " \
"it before using the Alpha Model Strategy."
self._model_tickers_dict = model_tickers_dict
self._use_stop_losses = use_stop_losses
self._max_open_positions = max_open_positions
self._time_in_force = time_in_force
self.logger = qf_logger.getChild(self.__class__.__name__)
self._log_configuration()
def __init__(self,
backtest_result: BacktestResult,
settings: Settings,
pdf_exporter: PDFExporter,
excel_exporter: ExcelExporter,
monitor_settings=None,
benchmark_tms: QFSeries = None):
self.backtest_result = backtest_result
self.logger = qf_logger.getChild(self.__class__.__name__)
self._settings = settings
self._pdf_exporter = pdf_exporter
self._excel_exporter = excel_exporter
self._signals_register = backtest_result.signals_register
# set full display details if no setting is provided
self._monitor_settings = BacktestMonitorSettings(
) if monitor_settings is None else monitor_settings
self.benchmark_tms = benchmark_tms
sub_dir_name = datetime.now().strftime("%Y_%m_%d-%H%M {}".format(
backtest_result.backtest_name))
self._report_dir = path.join("backtesting", sub_dir_name)
self._init_live_progress_chart(backtest_result)
self._csv_file, self._csv_writer = self._init_transactions_log_csv_file(
)
self._eod_update_ctr = 0
def __init__(self,
cov_matrix: QFDataFrame,
upper_constraint: Union[float, Sequence[float]] = None):
self.cov_matrix = cov_matrix
self.upper_constraint = upper_constraint
self.max_iter = 10000 # maximal number of iterations during finding the solution
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, future_tickers: Sequence[FutureTicker], timer: Timer,
broker: Broker, order_factory: OrderFactory):
self._future_tickers = future_tickers
self._timer = timer
self._broker = broker
self._order_factory = order_factory
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, broker: Broker, data_handler: DataHandler,
order_factory: OrderFactory,
contract_ticker_mapper: ContractTickerMapper):
self._broker = broker
self._data_handler = data_handler
self._order_factory = order_factory
self._contract_ticker_mapper = contract_ticker_mapper
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, backtest_result: BacktestResult, settings: Settings,
pdf_exporter: PDFExporter, excel_exporter: ExcelExporter):
super().__init__(backtest_result, settings, pdf_exporter,
excel_exporter)
self._nr_of_days = 20
self._ctr = 0
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, ticker: str, security_type: SecurityType,
point_value: int):
self.ticker = ticker
self.security_type = security_type
self.point_value = point_value
self._name = ticker
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, settings: Settings, data_provider: DataProvider):
self.settings = settings
self._data_provider = data_provider
self.positions_history = None
self.portfolio_nav_history = None
self._sector_exposure_tickers = None
self._factor_exposure_tickers = None
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, settings: Settings):
self.logger = qf_logger.getChild(self.__class__.__name__)
try:
self.key = settings.quandl_key
quandl.ApiConfig.api_key = self.key
except AttributeError:
self.logger.warning("No quandl_key parameter found in Settings. If you want to use QuandlDataProvider, add "
"quandl_key in the settings json file.")
def __init__(self,
data_provider: DataProvider,
contract_ticker_mapper: ContractTickerMapper,
max_volume_share_limit: Optional[float] = None):
self.max_volume_share_limit = max_volume_share_limit
self._contract_ticker_mapper = contract_ticker_mapper
self._data_provider = data_provider
self._logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, cov_matrix: QFDataFrame, mean_returns: QFSeries,
upper_constraint: Union[float, Sequence[float]] = None,
risk_free_rate: float = 0.0, max_iter: int = 10000):
self.cov_matrix = cov_matrix
self.mean_returns = mean_returns
self.upper_constraint = upper_constraint
self.risk_free_rate = risk_free_rate
self.max_iter = max_iter
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self, ts: BacktestTradingSession, ticker: Ticker):
super().__init__(ts)
self.broker = ts.broker
self.order_factory = ts.order_factory
self.data_handler = ts.data_handler
self.position_sizer = ts.position_sizer
self.timer = ts.timer
self.ticker = ticker
self.logger = qf_logger.getChild(self.__class__.__name__)
def __init__(self,
settings_path: Optional[str],
secret_path: Optional[str] = None,
init_properties: bool = True):
self.settings_path = settings_path
self.secret_path = secret_path
self.init_properties = init_properties
self.logger = qf_logger.getChild(self.__class__.__name__)
if init_properties:
self._init_settings()
