Key features:

• Historical, point-in-time screening and ranking of securities using price and fundamental data
• Define rules and perform computations that are too complex for point-and-click screening tools
• Designed for large datasets that other code platforms struggle to handle
• Can be paired with Zipline for backtesting, Alphalens for factor analysis, or used as a standalone tool

from zipline.pipeline import sharadar

# trailing-twelve month fundamentals
fundamentals = sharadar.Fundamentals.slice("ART")

# create a universe of the top 50% of stocks by market cap
# that also pay dividends
liquid_stocks = fundamentals.MARKETCAP.latest.percentile_between(50, 100)
pay_dividends = fundamentals.DIVYIELD.latest > 0
universe = liquid_stocks & pay_dividends

# Select the cheapest 100 stocks by enterprise multiple from among
# the universe of liquid, dividend-paying stocks  
enterprise_multiple = fundamentals.EVEBITDA.latest
stocks_to_buy = enterprise_multiple.bottom(100, mask=universe)

Key features:

• View the relative performance of baskets of stocks bucketed by alpha factor
• Ideal for long-short or factor model strategies
• Pairs well with the Pipeline API
• Quickly assess whether an alpha factor is predictive
• Use as an initial research step to determine if further investigation is warranted

Key features:

• Based on Pandas, the centerpiece of the Python data science stack
• Fast, vectorized, multi-strategy backtests and parameter scans
• Daily or intraday strategies
• Equities, futures, and FX
• Live trading (automated or manual)
• Open source, designed by and for QuantRocket
• Learn more about Moonshot in the Intro Video

import pandas as pd
from moonshot import Moonshot

class MovingAverageStrategy(Moonshot):

    CODE = "demo-50ma"
    DB = "demo-stk-1d"

    def prices_to_signals(self, prices: pd.DataFrame):
        # Buy when the close is above the 50-period moving average.
        closes = prices.loc["Close"]
        mavgs = closes.rolling(50).mean()
        signals = closes > mavgs.shift()
        return signals.astype(int)
    

Key features:

• Walk-forward optimization: Rolling and expanding walk-forward optimization, widely considered the best technique for validating machine learning models in finance.
• Incremental/out-of-core learning: Train models and run backtests even when your data is too large to fit in memory.
• Multiple machine learning/deep learning packages: Including scikit-learn, Keras + TensorFlow, and XGBoost.

import pandas as pd
from moonshot import MoonshotML

class DemoMLStrategy(MoonshotML):

    CODE = "demo-ml"
    DB = "demo-stk-1d"

    def prices_to_features(self, prices: pd.DataFrame):
        closes = prices.loc["Close"]
        features = {}
        # use past returns...
        features["returns_1d"]= closes.pct_change()
        # ...to predict next day returns
        targets = closes.pct_change().shift(-1)
        return features, targets

    def predictions_to_signals(self, predictions: pd.DataFrame, prices: pd.DataFrame):
        # buy when the model predicts a positive return
        signals = predictions > 0
        return signals.astype(int)
    

A hint of what's possible:

• Schedule daily downloads of third party data
• Create an options trading script that uses QuantRocket's Python API to query data and place orders using the blotter
• Create and schedule multi-step maintenance tasks such as creating futures calendar spreads based on changing rollover rules
• Run third-party backtesters such as backtrader

import backtrader as bt

class DualMovingAverageStrategy(bt.SignalStrategy):

    params = (
        ('smavg_window', 100),
        ('lmavg_window', 300),
    )

    def __init__(self):

        # Compute long and short moving averages
        smavg = bt.ind.SMA(period=self.p.smavg_window)
        lmavg = bt.ind.SMA(period=self.p.lmavg_window)

        # Go long when short moving average is above long moving average
        self.signal_add(bt.SIGNAL_LONG, bt.ind.CrossOver(smavg, lmavg))