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()