QSTrader

https://www.quantstart.com/qstrader/
Admin
QSTrader is an open source backtesting simulation framework written in Python for long/short...
Tokens:9,454
Snippets:105
Trust Score:9.8
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install QSTrader using pip

Source: https://www.quantstart.com/qstrader/installation

Use this command to install QSTrader after setting up your Python environment. Ensure you have pip installed and updated.

```bash
pip install qstrader

```

--------------------------------

### Verify QSTrader Installation

Source: https://www.quantstart.com/qstrader/installation

After installation, open a Python console and import qstrader to confirm it was installed successfully. No error message indicates a successful import.

```python
>>> import qstrader

```

--------------------------------

### Example Weighted Assets Dictionary

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Shows the expected output format for the `weights` dictionary generated by the `_generate_signals` method, where top assets are weighted equally.

```python
{'EQ:XLC': 0.3333333, 'EQ:XLB': 0.3333333, 'EQ:XLK': 0.3333333}
```

--------------------------------

### Construct Dynamic Asset Universe

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Creates a dynamic universe of assets using SPDR US sector ETFs. It defines the start date for each asset, including a specific start date for 'EQ:XLC' in 2018.

```python
# Construct the symbols and assets necessary for the backtest
    # This utilises the SPDR US sector ETFs, all beginning with XL
    strategy_symbols = ['XL%s' % sector for sector in "BCEFIKPUVY"]
    assets = ['EQ:%s' % symbol for symbol in strategy_symbols]

    # As this is a dynamic universe of assets (XLC is added later)
    # we need to tell QSTrader when XLC can be included. This is
    # achieved using an asset dates dictionary
    asset_dates = {asset: start_dt for asset in assets}
    asset_dates['EQ:XLC'] = pd.Timestamp('2018-06-18 00:00:00', tz=pytz.UTC)
    strategy_universe = DynamicUniverse(asset_dates)
```

--------------------------------

### Create Benchmark Backtest with Fixed Allocation

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Construct a benchmark Alpha Model with a 100% static allocation to the SPY ETF and a 'buy_and_hold' rebalance schedule. This setup ensures a single initial trade to go long SPY, with no subsequent trades.

```python
# sixty_forty.py

    # Construct a benchmark Alpha Model that provides
    # 100% static allocation to the SPY ETF, with no rebalance
    benchmark_alpha_model = FixedSignalsAlphaModel({'EQ:SPY': 1.0})
    benchmark_backtest = BacktestTradingSession(
        start_dt,
        end_dt,
        benchmark_universe,
        benchmark_alpha_model,
        rebalance='buy_and_hold',
        long_only=True,
        cash_buffer_percentage=0.01,
        data_handler=data_handler
    )
    benchmark_backtest.run()


```

--------------------------------

### Example Top Momentum Assets List

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Illustrates the potential output format for a list of top momentum assets, derived from the `_highest_momentum_asset` method.

```python
['EQ:XLC', 'EQ:XLB', 'EQ:XLK']
```

--------------------------------

### Define Backtest Dates with Timezone

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Specifies the start and end dates for the backtest, requiring timezone information. Note the specific start time (14:30:00 UTC) needed for older versions of QSTrader.

```python
if __name__ == "__main__":
    start_dt = pd.Timestamp('2003-09-30 14:30:00', tz=pytz.UTC)
    end_dt = pd.Timestamp('2019-12-31 23:59:00', tz=pytz.UTC)
```

--------------------------------

### Backtest Date Configuration

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Configures the start, burn-in, and end datetimes for a backtest session. Uses pandas Timestamps with UTC timezone.

```python
# Duration of the backtest
start_dt = pd.Timestamp('1998-12-22 14:30:00', tz=pytz.UTC)
burn_in_dt = pd.Timestamp('1999-12-22 14:30:00', tz=pytz.UTC)
end_dt = pd.Timestamp('2020-12-31 23:59:00', tz=pytz.UTC)
```

--------------------------------

### Define Backtest Timeframe

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Sets the start, burn-in, and end dates for the backtest. The burn-in period is when weights are generated, accounting for momentum signal lookback periods. Dates require timezone specification using pytz.

```python
if __name__ == "__main__":
    # Duration of the backtest
    start_dt = pd.Timestamp('1998-12-22 14:30:00', tz=pytz.UTC)
    burn_in_dt = pd.Timestamp('1999-12-22 14:30:00', tz=pytz.UTC)
    end_dt = pd.Timestamp('2020-12-31 23:59:00', tz=pytz.UTC)
```

--------------------------------

### Execute QSTrader Backtest Script

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Run the QSTrader backtest by executing the Python script from the command line. Ensure your Python virtual environment is activated before running.

```bash
python sixty_forty.py

```

--------------------------------

### Run a 60/40 Portfolio Backtest with QSTrader

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Configures and executes a backtest for a 60/40 strategy compared against a SPY benchmark. Requires environment variable QSTRADER_CSV_DATA_DIR to be set for data loading.

```python
import os

import pandas as pd
import pytz

from qstrader.alpha_model.fixed_signals import FixedSignalsAlphaModel
from qstrader.asset.equity import Equity
from qstrader.asset.universe.static import StaticUniverse
from qstrader.data.backtest_data_handler import BacktestDataHandler
from qstrader.data.daily_bar_csv import CSVDailyBarDataSource
from qstrader.statistics.tearsheet import TearsheetStatistics
from qstrader.trading.backtest import BacktestTradingSession


if __name__ == "__main__":
    start_dt = pd.Timestamp('2003-09-30 14:30:00', tz=pytz.UTC)
    end_dt = pd.Timestamp('2019-12-31 23:59:00', tz=pytz.UTC)

    # Construct the symbols and assets necessary for the backtest
    strategy_symbols = ['SPY', 'AGG']
    strategy_assets = ['EQ:%s' % symbol for symbol in strategy_symbols]
    strategy_universe = StaticUniverse(strategy_assets)

    # To avoid loading all CSV files in the directory, set the
    # data source to load only those provided symbols
    csv_dir = os.environ.get('QSTRADER_CSV_DATA_DIR', '.')
    data_source = CSVDailyBarDataSource(csv_dir, Equity, csv_symbols=strategy_symbols)
    data_handler = BacktestDataHandler(strategy_universe, data_sources=[data_source])

    # Construct an Alpha Model that simply provides
    # static allocations to a universe of assets
    # In this case 60% SPY ETF, 40% AGG ETF,
    # rebalanced at the end of each month
    strategy_alpha_model = FixedSignalsAlphaModel({'EQ:SPY': 0.6, 'EQ:AGG': 0.4})
    strategy_backtest = BacktestTradingSession(
        start_dt,
        end_dt,
        strategy_universe,
        strategy_alpha_model,
        rebalance='end_of_month',
        long_only=True,
        cash_buffer_percentage=0.01,
        data_handler=data_handler
    )
    strategy_backtest.run()

    # Construct benchmark assets (buy & hold SPY)
    benchmark_assets = ['EQ:SPY']
    benchmark_universe = StaticUniverse(benchmark_assets)

    # Construct a benchmark Alpha Model that provides
    # 100% static allocation to the SPY ETF, with no rebalance
    benchmark_alpha_model = FixedSignalsAlphaModel({'EQ:SPY': 1.0})
    benchmark_backtest = BacktestTradingSession(
        start_dt,
        end_dt,
        benchmark_universe,
        benchmark_alpha_model,
        rebalance='buy_and_hold',
        long_only=True,
        cash_buffer_percentage=0.01,
        data_handler=data_handler
    )
    benchmark_backtest.run()

    # Performance Output
    tearsheet = TearsheetStatistics(
        strategy_equity=strategy_backtest.get_equity_curve(),
        benchmark_equity=benchmark_backtest.get_equity_curve(),
        title='60/40 US Equities/Bonds'
    )
    tearsheet.plot_results()
```

--------------------------------

### Initialize TopNMomentumAlphaModel

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Initializes the TopNMomentumAlphaModel with signals, lookback period, top N assets, universe, and data handler.

```python
def __init__(
        self,
        signals,
        mom_lookback,
        mom_top_n,
        universe,
        data_handler
    ):
    """
    Initialise the TopNMomentumAlphaModel

    Parameters
    ----------
    signals : `SignalsCollection`
        The entity for interfacing with various pre-calculated
        signals. In this instance we want to use 'momentum'.
    mom_lookback : `integer`
        The number of business days to calculate momentum
        lookback over.
    mom_top_n : `integer`
        The number of assets to include in the portfolio,
        ranking from highest momentum descending.
    universe : `Universe`
        The collection of assets utilised for signal generation.
    data_handler : `DataHandler`
        The interface to the CSV data.

    Returns
    -------
    None
    """
    self.signals = signals
    self.mom_lookback = mom_lookback
    self.mom_top_n = mom_top_n
    self.universe = universe
    self.data_handler = data_handler
```

--------------------------------

### Construct Benchmark Backtest in Python

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Sets up a benchmark backtest using a static universe and CSV daily bar data, allocating 100% to the SPY ETF with a buy-and-hold strategy.

```python
# Construct benchmark assets (buy & hold SPY)
benchmark_symbols = ['SPY']
benchmark_assets = ['EQ:SPY']
benchmark_universe = StaticUniverse(benchmark_assets)
benchmark_data_source = CSVDailyBarDataSource(csv_dir, Equity, csv_symbols=benchmark_symbols)
benchmark_data_handler = BacktestDataHandler(benchmark_universe, data_sources=[benchmark_data_source])

# Construct a benchmark Alpha Model that provides
# 100% static allocation to the SPY ETF, with no rebalance
benchmark_alpha_model = FixedSignalsAlphaModel({'EQ:SPY': 1.0})
benchmark_backtest = BacktestTradingSession(
    burn_in_dt,
    end_dt,
    benchmark_universe,
    benchmark_alpha_model,
    rebalance='buy_and_hold',
    long_only=True,
    cash_buffer_percentage=0.01,
    data_handler=benchmark_data_handler
)
benchmark_backtest.run()
```

--------------------------------

### Instantiate and Run Momentum Alpha Model Backtest

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Initializes the TopNMomentumAlphaModel and BacktestTradingSession, then executes the backtest. Key parameters include rebalance frequency, long-only setting, and cash buffer percentage. Use this to simulate trading strategies.

```python
# momentum_taa.py

    # Generate the alpha model instance for the top-N momentum alpha model
    strategy_alpha_model = TopNMomentumAlphaModel(
        signals,
        mom_lookback,
        mom_top_n,
        strategy_universe,
        strategy_data_handler
    )

    # Construct the strategy backtest and run it
    strategy_backtest = BacktestTradingSession(
        start_dt,
        end_dt,
        strategy_universe,
        strategy_alpha_model,
        signals=signals,
        rebalance='end_of_month',
        long_only=True,
        cash_buffer_percentage=0.01,
        burn_in_dt=burn_in_dt,
        data_handler=strategy_data_handler
    )
    strategy_backtest.run()

```

--------------------------------

### Configure Pricing Data Handler

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Sets up the data source to load only specified symbols from CSV files and initializes the BacktestDataHandler with the dynamic asset universe.

```python
# To avoid loading all CSV files in the directory, set the
    # data source to load only those provided symbols
    csv_dir = os.environ.get('QSTRADER_CSV_DATA_DIR', '.')
    strategy_data_source = CSVDailyBarDataSource(csv_dir, Equity, csv_symbols=strategy_symbols)
    strategy_data_handler = BacktestDataHandler(strategy_universe, data_sources=[strategy_data_source])
```

--------------------------------

### Initialize and Run Backtest Trading Session

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Initializes and runs a backtest using a fixed signals alpha model for a sixty-forty allocation strategy. Key parameters include rebalancing frequency, long-only mode, and a cash buffer percentage.

```python
# Construct an Alpha Model that simply provides
# static allocations to a universe of assets
# In this case 60% SPY ETF, 40% AGG ETF,
# rebalanced at the end of each month
strategy_alpha_model = FixedSignalsAlphaModel({'EQ:SPY': 0.6, 'EQ:AGG': 0.4})
strategy_backtest = BacktestTradingSession(
    start_dt,
    end_dt,
    strategy_universe,
    strategy_alpha_model,
    rebalance='end_of_month',
    long_only=True,
    cash_buffer_percentage=0.01,
    data_handler=data_handler
)
strategy_backtest.run()
```

--------------------------------

### Import QSTrader modules for momentum strategy

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Initial imports required for setting up the QSTrader environment and strategy components.

```python
import os

from qstrader import settings
from qstrader.alpha_model.momentum_signal import MomentumSignal
from qstrader.alpha_model.signals_collection import SignalsCollection
from qstrader.alpha_model.static_weights import StaticWeightsAlphaModel
from qstrader.asset.equity import Equity
from qstrader.asset.universe.dynamic import DynamicUniverse
from qstrader.broker.broker import Broker
from qstrader.broker.fee_model.zero_fee_model import ZeroFeeModel
from qstrader.data.daily_bar_csv import DailyBarCSVDataSource
from qstrader.data.backtest_data_handler import BacktestDataHandler
from qstrader.portfolio.portfolio import Portfolio
from qstrader.portfolio.rebalance.buy_and_hold import BuyAndHoldRebalance
from qstrader.position_sizer.equal_weight import EqualWeightPositionSizer
from qstrader.price_handler.adjusted_daily_bar import AdjustedDailyBarPriceHandler
from qstrader.simulation.backtest import Backtest
from qstrader.statistics.tearsheet import TearsheetStatistics
```

--------------------------------

### Configure Strategy Universe and Data Handler

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Sets up a dynamic universe of US sector ETFs and configures the data handler to load only the specified symbols from CSV files. Includes logic for dynamically adding assets like XLC.

```python
mom_lookback = 126  # Six months worth of business days
mom_top_n = 3  # Number of assets to include at any one time

# Construct the symbols and assets necessary for the backtest
# This utilises the SPDR US sector ETFs, all beginning with XL
strategy_symbols = ['XL%s' % sector for sector in "BCEFIKPUVY"]
assets = ['EQ:%s' % symbol for symbol in strategy_symbols]

# As this is a dynamic universe of assets (XLC is added later)
# we need to tell QSTrader when XLC can be included. This is
# achieved using an asset dates dictionary
asset_dates = {asset: start_dt for asset in assets}
asset_dates['EQ:XLC'] = pd.Timestamp('2018-06-18 00:00:00', tz=pytz.UTC)
strategy_universe = DynamicUniverse(asset_dates)

# To avoid loading all CSV files in the directory, set the
# data source to load only those provided symbols
csv_dir = os.environ.get('QSTRADER_CSV_DATA_DIR', '.')
strategy_data_source = CSVDailyBarDataSource(csv_dir, Equity, csv_symbols=strategy_symbols)
strategy_data_handler = BacktestDataHandler(strategy_universe, data_sources=[strategy_data_source])
```

--------------------------------

### Import Necessary Modules for QSTrader Backtest

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Imports required modules from QSTrader and other libraries for setting up a backtest. Includes data handling, asset definition, alpha models, and trading session management.

```python
# sixty_forty.py

import os

import pandas as pd
import pytz

from qstrader.alpha_model.fixed_signals import FixedSignalsAlphaModel
from qstrader.asset.equity import Equity
from qstrader.asset.universe.static import StaticUniverse
from qstrader.data.backtest_data_handler import BacktestDataHandler
from qstrader.data.daily_bar_csv import CSVDailyBarDataSource
from qstrader.statistics.tearsheet import TearsheetStatistics
from qstrader.trading.backtest import BacktestTradingSession

```

--------------------------------

### Execute Backtest Script

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Command to run the QSTrader backtest script from the terminal. Ensure your Python environment is activated.

```bash
python momentum_taa.py
```

--------------------------------

### TopNMomentumAlphaModel Initialization

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Initializes the alpha model with signal collection, lookback period, top N assets, universe, and data handler.

```APIDOC
## __init__

### Description
Initialise the TopNMomentumAlphaModel.

### Parameters
- **signals** (SignalsCollection) - Required - The entity for interfacing with various pre-calculated signals.
- **mom_lookback** (integer) - Required - The number of business days to calculate momentum lookback over.
- **mom_top_n** (integer) - Required - The number of assets to include in the portfolio, ranking from highest momentum descending.
- **universe** (Universe) - Required - The collection of assets utilised for signal generation.
- **data_handler** (DataHandler) - Required - The interface to the CSV data.
```

--------------------------------

### Construct Asset Universe for Backtest

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Creates a static universe of assets for the backtest. Assets must be prefixed with their instrument type code (e.g., 'EQ:' for equities).

```python
# Construct the symbols and assets necessary for the backtest
strategy_symbols = ['SPY', 'AGG']
strategy_assets = ['EQ:%s' % symbol for symbol in strategy_symbols]
strategy_universe = StaticUniverse(strategy_assets)
```

--------------------------------

### Generate and Plot Backtest Tearsheet in Python

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Creates a performance tearsheet using strategy and benchmark equity curves, then plots the results using Matplotlib.

```python
# Performance Output
tearsheet = TearsheetStatistics(
    strategy_equity=strategy_backtest.get_equity_curve(),
    benchmark_equity=benchmark_backtest.get_equity_curve(),
    title='US Sector Momentum - Top 3 Sectors'
)
tearsheet.plot_results()
```

--------------------------------

### Configure CSV Data Source for Backtest

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Sets up a CSV data source to load historical bar data for specified symbols. It uses environment variables for the CSV directory and defaults to the current directory if not set.

```python
# To avoid loading all CSV files in the directory, set the
# data source to load only those provided symbols
csv_dir = os.environ.get('QSTRADER_CSV_DATA_DIR', '.')
data_source = CSVDailyBarDataSource(csv_dir, Equity, csv_symbols=strategy_symbols)
data_handler = BacktestDataHandler(strategy_universe, data_sources=[data_source])
```

--------------------------------

### Create Top-N Momentum Alpha Model

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Instantiates the TopNMomentumAlphaModel using the generated signals, lookback period, top N value, universe, and data handler.

```python
# Generate the alpha model instance for the top-N momentum alpha model
strategy_alpha_model = TopNMomentumAlphaModel(
    signals, mom_lookback, mom_top_n, strategy_universe, strategy_data_handler
)
```

--------------------------------

### Generate Momentum Signals

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Generates holding-period return based momentum signals for the top N assets. Requires a universe, data handler, and specified lookback periods.

```python
# Generate the signals (in this case holding-period return based
# momentum) used in the top-N momentum alpha model
momentum = MomentumSignal(start_dt, strategy_universe, lookbacks=[mom_lookback])
signals = SignalsCollection({'momentum': momentum}, strategy_data_handler)
```

--------------------------------

### Run Strategy Backtest

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Constructs and runs the backtest for the US Sector Momentum strategy. Configures parameters such as rebalancing frequency, long-only, cash buffer, and burn-in period.

```python
# Construct the strategy backtest and run it
strategy_backtest = BacktestTradingSession(
    start_dt,
    end_dt,
    strategy_universe,
    strategy_alpha_model,
    signals=signals,
    rebalance='end_of_month',
    long_only=True,
    cash_buffer_percentage=0.01,
    burn_in_dt=burn_in_dt,
    data_handler=strategy_data_handler
)
strategy_backtest.run()
```

--------------------------------

### Generate and Plot Backtest Results with Tearsheet

Source: https://www.quantstart.com/qstrader/tutorial-60-40-portfolio

Instantiate TearsheetStatistics with strategy and benchmark equity curves, along with a title, to visualize and output performance statistics. The plot_results method then generates the visual representation using Matplotlib.

```python
# sixty_forty.py

    # Performance Output
    tearsheet = TearsheetStatistics(
        strategy_equity=strategy_backtest.get_equity_curve(),
        benchmark_equity=benchmark_backtest.get_equity_curve(),
        title='60/40 US Equities/Bonds'
    )
    tearsheet.plot_results()


```

--------------------------------

### Generate Momentum Signals

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Creates a MomentumSignal instance for the specified universe and lookback period, then wraps it in a SignalsCollection for use in the alpha model.

```python
# Generate the signals (in this case holding-period return based
    # momentum) used in the top-N momentum alpha model
    momentum = MomentumSignal(start_dt, strategy_universe, lookbacks=[mom_lookback])
    signals = SignalsCollection({'momentum': momentum}, strategy_data_handler)
```

--------------------------------

### TopNMomentumAlphaModel Class Definition

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Defines the TopNMomentumAlphaModel for selecting assets with the highest momentum. Requires pre-computed signals, lookback periods, and universe data.

```python
class TopNMomentumAlphaModel(AlphaModel):

    def __init__(
        self, signals, mom_lookback, mom_top_n, universe, data_handler
    ):
        self.signals = signals
        self.mom_lookback = mom_lookback
        self.mom_top_n = mom_top_n
        self.universe = universe
        self.data_handler = data_handler

        def _highest_momentum_asset(
            self, dt
        ):
            assets = self.signals['momentum'].assets

            # Calculate the holding-period return momenta for each asset,
            # for the particular provided momentum lookback period
            all_momenta = {
                asset: self.signals['momentum'](
                    asset, self.mom_lookback
                ) for asset in assets
            }

            # Obtain a list of the top performing assets by momentum
            # restricted by the provided number of desired assets to
            # trade per month
            return [
                asset[0] for asset in sorted(
                    all_momenta.items(),
                    key=operator.itemgetter(1),
                    reverse=True
                )
            ][:self.mom_top_n]

        def _generate_signals(
            self, dt, weights
        ):
            top_assets = self._highest_momentum_asset(dt)
            for asset in top_assets:
                weights[asset] = 1.0 / self.mom_top_n
            return weights

        def __call__(
            self, dt
        ):
            assets = self.universe.get_assets(dt)
            weights = {asset: 0.0 for asset in assets}

            # Only generate weights if the current time exceeds the
            # momentum lookback period
            if self.signals.warmup >= self.mom_lookback:
                weights = self._generate_signals(dt, weights)
            return weights
```

--------------------------------

### Set Momentum Model Parameters

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Defines the lookback period (in business days) for the HPR momentum signal and the number of top assets to include in the equally weighted portfolio each month.

```python
# Model parameters
    mom_lookback = 126  # Six months worth of business days
    mom_top_n = 3  # Number of assets to include at any one time
```

--------------------------------

### Momentum TAA Module Imports

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Initial imports required for the momentum TAA strategy, including data handlers, alpha models, and signal processing classes.

```python
import operator
import os

import pandas as pd
import pytz

from qstrader.alpha_model.alpha_model import AlphaModel
from qstrader.alpha_model.fixed_signals import FixedSignalsAlphaModel
from qstrader.asset.equity import Equity
from qstrader.asset.universe.dynamic import DynamicUniverse
from qstrader.asset.universe.static import StaticUniverse
from qstrader.signals.momentum import MomentumSignal
from qstrader.signals.signals_collection import SignalsCollection
from qstrader.data.backtest_data_handler import BacktestDataHandler
from qstrader.data.daily_bar_csv import CSVDailyBarDataSource
from qstrader.statistics.tearsheet import TearsheetStatistics
from qstrader.trading.backtest import BacktestTradingSession
```

--------------------------------

### Calculate Top N Momentum Signal Weights

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Calculates signal weights for the Top N momentum alpha model. Generates weights only if the current time exceeds the momentum lookback period. Assumes sufficient data is available.

```python
def __call__(
        self,
        dt
    ):
    """
    Calculates the signal weights for the top N
    momentum alpha model, assuming that there is
    sufficient data to begin calculating momentum
    on the desired assets.

    Parameters
    ----------
    dt : `pd.Timestamp`
        The datetime for which the signal weights
        should be calculated.

    Returns
    -------
    `dict{str: float}`
        The newly created signal weights dictionary.
    """
    assets = self.universe.get_assets(dt)
    weights = {asset: 0.0 for asset in assets}

    # Only generate weights if the current time exceeds the
    # momentum lookback period
    if self.signals.warmup >= self.mom_lookback:
        weights = self._generate_signals(dt, weights)
    return weights
```

--------------------------------

### Generate Momentum Signals

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Generates signal weights for the top N momentum assets. Assigns 1/N of the signal weight to each of these assets. This method is called by the __call__ method.

```python
def _generate_signals(
        self,
        dt,
        weights
    ):
    """
    Calculate the highest performing momentum for each
    asset then assign 1 / N of the signal weight to each
    of these assets.

    Parameters
    ----------
    dt : `pd.Timestamp`
        The datetime for which the signal weights
        should be calculated.
    weights : `dict{str: float}`
        The current signal weights dictionary.

    Returns
    -------
    `dict{str: float}`
        The newly created signal weights dictionary.
    """
    top_assets = self._highest_momentum_asset(dt)
    for asset in top_assets:
        weights[asset] = 1.0 / self.mom_top_n
    return weights
```

--------------------------------

### Calculate Signal Weights

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Calculates the signal weights for the top N momentum alpha model for a given timestamp.

```APIDOC
## __call__

### Description
Calculates the signal weights for the top N momentum alpha model, assuming that there is sufficient data to begin calculating momentum on the desired assets.

### Parameters
- **dt** (pd.Timestamp) - Required - The datetime for which the signal weights should be calculated.

### Response
- **weights** (dict{str: float}) - The newly created signal weights dictionary.
```

--------------------------------

### Calculate Highest Momentum Asset

Source: https://www.quantstart.com/qstrader/tutorial-momentum-tactical-asset-allocation-strategy

Calculates the ordered list of highest performing momentum assets restricted to the 'Top N' for a specific datetime. Requires the signals object to have a 'momentum' attribute.

```python
def _highest_momentum_asset(
        self,
        dt
    ):
    """
    Calculates the ordered list of highest performing momentum
    assets restricted to the 'Top N', for a particular datetime.

    Parameters
    ----------
    dt : `pd.Timestamp`
        The datetime for which the highest momentum assets
        should be calculated.

    Returns
    -------
    `list[str]`
        Ordered list of highest performing momentum assets
        restricted to the 'Top N'.
    """
    assets = self.signals['momentum'].assets

    # Calculate the holding-period return momenta for each asset,
    # for the particular provided momentum lookback period
    all_momenta = {
        asset: self.signals['momentum'](
            asset, self.mom_lookback
        ) for asset in assets
    }

    # Obtain a list of the top performing assets by momentum
    # restricted by the provided number of desired assets to
    # trade per month
    return [
        asset[0] for asset in sorted(
            all_momenta.items(),
            key=operator.itemgetter(1),
            reverse=True
        )
    ][:self.mom_top_n]
```
Tokens:
Raw