Options

pip install "polaris-data[dataframe]"

from datetime import timedelta

import pandas as pd
from polaris_data import PolarisClient

source = "aevo"
market = "BTC"

with PolarisClient() as client:
    catalog = client.catalog(source=source, market=market)
    coverage = catalog["markets"][0]
    coverage_start = pd.Timestamp(coverage["start"])
    coverage_end = pd.Timestamp(coverage["end"])
    public_cutoff = coverage["access"].get("public_cutoff_date")
    if public_cutoff:
        public_day = pd.Timestamp(public_cutoff, tz="UTC")
        start = max(coverage_start, public_day)
        end = min(coverage_end, start + timedelta(minutes=2))
    else:
        end = coverage_end
        start = max(coverage_start, end - timedelta(minutes=2))

    events = list(
        client.option_tickers(
            source=source,
            market=market,
            from_=start.to_pydatetime(),
            to=end.to_pydatetime(),
            allow_gaps=True,
        )
    )

records = []
for event in events:
    records.append(
        {
            "timestamp": event.get("collector_timestamp", event.get("timestamp")),
            "sequence": event.get("collector_sequence", 0),
            "instrument": event["instrument"],
            **event.get("data", {}),
        }
    )

if not records:
    print("No option ticker updates in the selected interval.")
else:
    updates = pd.DataFrame.from_records(records).sort_values(
        ["instrument", "timestamp", "sequence"]
    )
    ticker_fields = [
        "bid_price",
        "ask_price",
        "mark_price",
        "mark_iv",
        "open_interest",
    ]
    for field in ticker_fields:
        if field not in updates:
            updates[field] = pd.NA

    updates[ticker_fields] = updates.groupby("instrument")[ticker_fields].ffill()
    chain = updates.groupby("instrument", as_index=False).tail(1).copy()

    for field in ticker_fields:
        chain[field] = pd.to_numeric(chain[field], errors="coerce")

    midpoint = (chain["bid_price"] + chain["ask_price"]) / 2
    chain["spread_bps"] = (
        (chain["ask_price"] - chain["bid_price"]) / midpoint * 10_000
    )

    ranked = chain.sort_values(
        ["open_interest", "mark_iv"],
        ascending=[False, False],
        na_position="last",
    )
    print(
        ranked[
            [
                "instrument",
                "bid_price",
                "ask_price",
                "spread_bps",
                "mark_iv",
                "open_interest",
            ]
        ].head(20)
    )

instrument = ranked.iloc[0]["instrument"]

with PolarisClient() as client:
    with client.stream(
        source=source,
        markets=[market],
        instrument=instrument,
    ) as stream:
        for event in stream:
            print(event)