fastquant Documentation

To use the get_twitter_sentiment() function in fastquant, you must obtain Twitter API credentials from the Twitter Developer Portal.

Follow these steps:

1. Log in to your Twitter account and visit developer.twitter.com/en/apps.
2. Click Create an App.
3. Provide an App name, a brief Application Description, and a Website URL (a placeholder like placeholder.com is acceptable).
4. Complete the Tell us how this app will be used section with a brief explanation.
5. Click Create.
6. Once the app is created, click on Details for your app.
7. Navigate to the Keys and Tokens tab.
8. Locate and save your API key and API secret key.
9. Under Access tokens, click Generate (or Regenerate) to obtain your Access token and Access token secret.

Important: Secure these four keys immediately, as regenerating tokens will invalidate existing ones.

To implement a custom trading strategy, inherit from fastquant.strategies.base.BaseStrategy. You must define:

• params: A tuple of strategy parameters.
• __init__: To initialize indicators (using backtrader indicators) and strategy variables.
• buy_signal(): Returns True when a long entry condition is met.
• sell_signal(): Returns True when a short/exit condition is met.
• exit_long_signal(): (Optional) Returns True when a long position should be closed.

import backtrader as bt
from fastquant.strategies.base import BaseStrategy

class RSIStrategy(BaseStrategy):
    params = (("rsi_period", 14), ("rsi_upper", 70), ("rsi_lower", 30))

    def __init__(self):
        super().__init__()
        self.rsi_period = self.params.rsi_period
        self.rsi_upper = self.params.rsi_upper
        self.rsi_lower = self.params.rsi_lower
        self.rsi = bt.indicators.RelativeStrengthIndex(period=self.rsi_period, upperband=self.rsi_upper, lowerband=self.rsi_lower)

    def buy_signal(self):
        return self.rsi[0] < self.rsi_lower

    def sell_signal(self):
        return self.rsi[0] > self.rsi_upper

    def exit_long_signal(self):
        return self.rsi[0] >= 50

To create a custom trading strategy, create a new class that inherits from BaseStrategy.

Key steps in the implementation:

1. Define params: A tuple of parameters used to configure the strategy (e.g., indicator periods or column names).
2. Initialize indicators in __init__: Use built-in indicators (like MACD or CrossOver) or CustomIndicator to wrap columns in your dataframe.
3. Define buy_signal(self): Return True when all buy conditions are met.
4. Define sell_signal(self): Return True when the sell condition is met.

Note: Inside the signal methods, self.dataclose[0] refers to the current closing price.

from fastquant import CustomStrategy, BaseStrategy
from fastquant.indicators import MACD, CrossOver 
from fastquant.indicators.custom import CustomIndicator

class MAMAStrategy(BaseStrategy):
    params = (
        ("alma_column", "alma"),
        ("macd_fast_period", 12),
        ("macd_slow_period", 16),
        ("macd_signal_period", 9)
    )

    def __init__(self):
        super().__init__()
        # Setup indicators
        self.macd_ind = MACD(
            period_me1=self.params.macd_fast_period, 
            period_me2=self.params.macd_slow_period, 
            period_signal=self.params.macd_signal_period
        )
        self.macd_signal_crossover = CrossOver(self.macd_ind, self.macd_ind.signal)
        
        # Wrap a custom column from the dataframe
        self.alma = CustomIndicator(self.data, custom_column=self.params.alma_column)
        self.alma.plotinfo.subplot = False
        self.alma.plotinfo.plotname = "ALMA"

    def buy_signal(self):
        # Example: Close is above ALMA AND MACD crosses signal line upward
        alma_buy = self.dataclose[0] > self.alma[0]
        macd_buy = self.macd_signal_crossover[0] > 0
        return alma_buy and macd_buy

    def sell_signal(self):
        # Example: Close falls below ALMA
        return self.alma[0] > self.dataclose[0]