ORATS and options

Here's the complete code to integrate Lauren's cleaned ORATS options data as custom data for QuantConnect. This will allow you to ingest your preprocessed CSV (where each record is a single contract/side, with greeks and meta-data), and access it in your algorithms:

from AlgorithmImports import *

class OratsCustomData(PythonData):
    def get_source(self, config, date, isLiveMode):
        # Load from a local CSV file
        return SubscriptionDataSource("data/orats_cleaned.csv", SubscriptionTransportMedium.LOCAL_FILE)

    def reader(self, config, line, date, isLiveMode):
        if not line.strip():
            return None

        # Expected CSV columns:
        # underlying, trade_date, expiry, strike, stkPx, volume, openinterest,
        # close_orats, orats_theo, smoothSmvVol, residualRateData, delta, gamma,
        # theta, vega, rho, phi, driftlessTheta, extVol, right
        columns = line.split(',')
        if len(columns) < 20:
            return None

        data = OratsCustomData()
        data.symbol = config.symbol

        try:
            data.underlying = columns[0].strip()

            trade_date = datetime.strptime(columns[1].strip(), "%Y-%m-%d")
            data.time = trade_date
            data.end_time = trade_date + timedelta(days=1)

            data.expiry = datetime.strptime(columns[2].strip(), "%Y-%m-%d")
            data.strike = float(columns[3])
            data.stk_px = float(columns[4])
            data.volume = float(columns[5])
            data.openinterest = float(columns[6])
            data.close_orats = float(columns[7])
            data.orats_theo = float(columns[8])
            data.smooth_smv_vol = float(columns[9])
            data.residual_rate_data = float(columns[10])
            data.delta = float(columns[11])
            data.gamma = float(columns[12])
            data.theta = float(columns[13])
            data.vega = float(columns[14])
            data.rho = float(columns[15])
            data.phi = float(columns[16])
            data.driftless_theta = float(columns[17])
            data.ext_vol = float(columns[18])
            data.right = columns[19].strip()

            data.value = data.orats_theo
        except:
            return None

        return data

class OratsAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        orats_symbol = self.add_data(OratsCustomData, "ORATS", Resolution.DAILY).symbol
        self._orats_symbol = orats_symbol

    def on_data(self, data: Slice):
        if data.contains_key(self._orats_symbol):
            for orats_point in data[self._orats_symbol]:
                self.debug(f"Time: {orats_point.time}, Underlying: {orats_point.underlying}, Theoretical: {orats_point.orats_theo}")

How to use:

• Save your cleaned ORATS CSV (from explode_orats_format) as data/orats_cleaned.csv in your project.
• This class will read one row per contract per date, including all greeks and meta info.
• In your algorithm, you access each option's greeks and meta fields as attributes of the custom data object (orats_point.delta, .expiry, .strike, etc).

Let me know if you want additional logic: filtering by expiry/strike, or stacking the minute version for intraday strategies!

Sources: CSV Format Example - QuantConnect.com, Object Store - QuantConnect.com, docs writing algorithms datasets algoseek us equity options, Requesting Data - QuantConnect.com, docs writing algorithms importing data streaming data key concepts

import pandas as pd

from io import StringIO

file_path = qb.object_store.get_file_path("SPY.parquet")

# Read the Parquet file content from the Object Store, which is the ORATS csv

# Convert string content to file-like object and load to dataframe

df = pd.read_parquet(file_path)

print(df.columns)

def merge_qc_orats(qc_df: pd.DataFrame, orats_df: pd.DataFrame) -> pd.DataFrame:

    qc_df = qc_df.copy()

    orats_df = orats_df.copy()

    qc_df["expiry"] = pd.to_datetime(qc_df["expiry"])

    qc_df["trade_date"] = pd.to_datetime(qc_df["trade_date"])

    orats_df["expiry"] = pd.to_datetime(orats_df["expiry"])

    orats_df["trade_date"] = pd.to_datetime(orats_df["trade_date"])

    merged = pd.merge(

        qc_df,

        orats_df,

        on=["trade_date", "expiry", "strike", "right"],

        suffixes=("_qc", "_orats"),

        how="inner"

    )

    return merged