Source code for quantdata.dysanos.market

"""
Standardized market, interpolated by smooth SANOS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
"""

from __future__ import annotations

from collections.abc import Callable
from datetime import date
from numbers import Real

import numpy as np
from cdxcore.err import verify_inp
from cdxcore.pretty import PrettyObject
from cdxcore.uniquehash import named_unique_filename48_8, unique_hash8
from cdxcore.verbose import Context

from quantdata.dysanos import SubDir, _locations_dysanos
from quantdata.sanos.arbfree import ArbFreePricer, MkArbFree
from quantdata.widb.day import ExpiryFilter, RawDayFilter
from quantdata.widb.options_filter import OptionsFilter, filter_options_day

_cache = _locations_dysanos.training("market")
MARKET_SCHEMA_VERSION = 4
_MIN_SMOOTHNESS = 0.01


def _validated_smoothness(smoothness: object) -> float:
    verify_inp(
        isinstance(smoothness, Real)
        and not isinstance(smoothness, bool)
        and np.isfinite(smoothness)
        and smoothness > _MIN_SMOOTHNESS,
        lambda: (
            f"'smoothness' must be finite and strictly greater than {_MIN_SMOOTHNESS}, "
            f"found {smoothness!r}"
        ),
    )
    return float(smoothness)


def _uid_market(
    ticker: str,
    d: date,
    smoothness: float,
    raw_day_filter: RawDayFilter,
    expiry_filter: ExpiryFilter,
    options_filter: OptionsFilter,
    mk_arb_free: MkArbFree,
) -> str:
    smoothness = _validated_smoothness(smoothness)
    filter_label = f"{raw_day_filter}, {expiry_filter}, {options_filter}, {mk_arb_free}"
    filter_uid = named_unique_filename48_8(
        filter_label,
        raw_day_filter,
        expiry_filter,
        options_filter,
        mk_arb_free,
    )
    smoothness_label = f"sm_{smoothness:.2f}"
    smoothness_uid = named_unique_filename48_8(smoothness_label, smoothness)
    return f"{filter_uid}/{smoothness_uid}/{ticker}/{d}"


[docs] @_cache(fmt=SubDir.PYTREE_HDF5).cache( "0.15", dependencies=[MkArbFree, OptionsFilter, RawDayFilter, ExpiryFilter, filter_options_day], uid=_uid_market, ) def smooth_interpolated_market( ticker: str, d: date, *, smoothness: float = 0.25, options_filter: OptionsFilter = OptionsFilter(), raw_day_filter: RawDayFilter = RawDayFilter(), expiry_filter: ExpiryFilter = ExpiryFilter(), mk_arb_free: MkArbFree = MkArbFree(), message_context: Callable[[], str] | str | None = None, verbose: Context | None = Context.all, ) -> dict[str, object]: """Fit and serialize a smooth arbitrage-free market for one trading day.""" smoothness = _validated_smoothness(smoothness) verify_inp( options_filter.normalize, lambda: "'options_filter.normalize' must be True to produce normalized market data", ) verbose = Context.quiet if verbose is None else verbose def message(with_cols: bool = True) -> str: my_context = f"{ticker} {d}" if message_context is None: msg = my_context else: msg = str(message_context() if callable(message_context) else message_context) if msg != "": msg += " " + my_context else: msg = my_context msg = msg[0].upper() + msg[1:] return msg + ": " if with_cols else msg # load data, apply filters etc # --------- data = filter_options_day( ticker, d, mk_arb_free=mk_arb_free, options_filter=options_filter, raw_day_filter=raw_day_filter, expiry_filter=expiry_filter, verbose=verbose, raise_if_bad_day=False, ) if data is None or len(data) == 0: return {} spot_ref = float(data["spot_ref"].unique().item()) spot_ret = float(data["spot_ret"].unique().item()) required_market_columns = { "df", "expiry", "expiry_id", "fwd", "is_am", "is_american", "mask_arb_free", "mkt_call_ask", "mkt_call_bid", "mkt_call_log_open_interest", "mkt_call_log_volume", "mkt_put_ask", "mkt_put_bid", "mkt_put_log_open_interest", "mkt_put_log_volume", } verify_inp( set(data.columns) >= required_market_columns, lambda: ( "Filtered option data is missing columns required by the smooth market contract: " f"{sorted(required_market_columns - set(data.columns))}" ), ) strikes = data["pure_strike"].to_numpy() ixs = np.argsort(strikes) strikes = strikes[ixs] tte_y = data["tte_y"].to_numpy()[ixs] bid = data["pure_bid_price"].to_numpy()[ixs] ask = data["pure_ask_price"].to_numpy()[ixs] # Preserve real call and put books in forward units. The WIDB data at this # point has prices and forwards divided by spot, so dividing by df*fwd is # exactly the dimensionless cash-price transformation C/(DF*F). discounted_forward = data["df"].to_numpy()[ixs] * data["fwd"].to_numpy()[ixs] verify_inp( np.all(np.isfinite(discounted_forward)) and np.all(discounted_forward > 0.0), lambda: "Expected every discounted forward to be finite and positive", ) direct = { "expiry": data["expiry"].to_numpy()[ixs], "expiry_id": data["expiry_id"].to_numpy()[ixs], "is_am": data["is_am"].to_numpy()[ixs], "is_american": data["is_american"].to_numpy()[ixs], "model_mask": data["mask_arb_free"].to_numpy(dtype=bool)[ixs], "call_bid": data["mkt_call_bid"].to_numpy()[ixs] / discounted_forward, "call_ask": data["mkt_call_ask"].to_numpy()[ixs] / discounted_forward, "put_bid": data["mkt_put_bid"].to_numpy()[ixs] / discounted_forward, "put_ask": data["mkt_put_ask"].to_numpy()[ixs] / discounted_forward, "call_log_volume": data["mkt_call_log_volume"].to_numpy()[ixs], "call_log_open_interest": data["mkt_call_log_open_interest"].to_numpy()[ixs], "put_log_volume": data["mkt_put_log_volume"].to_numpy()[ixs], "put_log_open_interest": data["mkt_put_log_open_interest"].to_numpy()[ixs], } del discounted_forward, ixs # split into per-expiry # --------------------- market = PrettyObject() market.uid = unique_hash8(raw_day_filter, expiry_filter, options_filter, mk_arb_free) market.expiries = np.unique(tte_y) market.strikes = [] market.bids = [] market.asks = [] market.expiry_dates = [] market.expiry_ids = [] market.is_am = [] market.is_american = [] market.pre_af_masks = [] market.model_masks = [] market.call_bids = [] market.call_asks = [] market.put_bids = [] market.put_asks = [] market.call_log_volumes = [] market.call_log_open_interests = [] market.put_log_volumes = [] market.put_log_open_interests = [] assert len(market.expiries) > 0, ( f"{message()}No expiries found after filtering for ticker {ticker} on date {d} " f"with raw_day_filter={raw_day_filter}, expiry_filter={expiry_filter}, " f"options_filter={options_filter} and mk_arb_free={mk_arb_free}. {data}" ) for expiry in market.expiries: mask = tte_y == expiry market.strikes.append(strikes[mask]) market.bids.append(bid[mask]) market.asks.append(ask[mask]) expiry_dates = np.unique(direct["expiry"][mask].astype("datetime64[D]")) expiry_ids = np.unique(direct["expiry_id"][mask]) is_am = np.unique(direct["is_am"][mask]) assert len(expiry_dates) == len(expiry_ids) == len(is_am) == 1, ( f"{message()}Expected one contract expiry identity for tte_y={expiry}, found " f"dates={expiry_dates}, ids={expiry_ids}, is_am={is_am}" ) market.expiry_dates.append(str(expiry_dates.item())) market.expiry_ids.append(int(expiry_ids.item())) market.is_am.append(bool(is_am.item())) market.is_american.append(direct["is_american"][mask]) market.pre_af_masks.append(direct["model_mask"][mask]) market.model_masks.append(direct["model_mask"][mask].copy()) market.call_bids.append(direct["call_bid"][mask]) market.call_asks.append(direct["call_ask"][mask]) market.put_bids.append(direct["put_bid"][mask]) market.put_asks.append(direct["put_ask"][mask]) market.call_log_volumes.append(direct["call_log_volume"][mask]) market.call_log_open_interests.append(direct["call_log_open_interest"][mask]) market.put_log_volumes.append(direct["put_log_volume"][mask]) market.put_log_open_interests.append(direct["put_log_open_interest"][mask]) market.expiry_ids = np.asarray(market.expiry_ids, dtype=np.int64) market.is_am = np.asarray(market.is_am, dtype=bool) assert set(market) >= {"expiries", "strikes", "bids", "asks"}, ( f"{message()}Expected market to have keys 'expiries', 'strikes', 'bids', " f"'asks' but found {set(market)}" ) str_smth = f"{smoothness:.2f}-smooth" # fit a *big* smooth SANOS model to the market # -------------------------------------------- num_strikes = sum(len(strikes_t) for strikes_t in market.strikes) with verbose.write_t( lambda: f"\r{message()}Fitting {str_smth} SANOS to {num_strikes} strikes... ", end="", ) as tme: sanos_fit = MkArbFree(smoothness=smoothness, surface_expiry_linear=True) af_pricer: ArbFreePricer = sanos_fit( strikes=market.strikes, expiries=market.expiries, bids=market.bids, asks=market.asks, verbose=verbose.quiet, ) fit_result: PrettyObject = af_pricer.compute_market_fit( expiries=market.expiries, strikes=market.strikes, bids=market.bids, asks=market.asks, and_vols=False, ) verbose.write( f"done; median error is {fit_result.median_err:.2f} half-spreads for the " f"{fit_result.pcnt_fit * 100:.1f}% of options which were not fitted within " f"bid-ask spread. This took {tme}.", head=False, ) final_model_masks = [np.zeros_like(mask, dtype=bool) for mask in market.model_masks] for retained_index, input_index in enumerate(af_pricer.input_index): final_model_masks[int(input_index)] = ( market.model_masks[int(input_index)] & af_pricer.masks[retained_index] ) market.model_masks = final_model_masks market.af_call_mids = fit_result.fits market.af_put_mids = [ call_mid - 1.0 + strikes_t for call_mid, strikes_t in zip(market.af_call_mids, market.strikes, strict=True) ] market.af_mid_available = [ np.isfinite(call_mid) & np.isfinite(put_mid) for call_mid, put_mid in zip( market.af_call_mids, market.af_put_mids, strict=True, ) ] market.call_active = [] market.put_active = [] for call_bid, call_ask, put_bid, put_ask, pre_af_mask in zip( market.call_bids, market.call_asks, market.put_bids, market.put_asks, market.pre_af_masks, strict=True, ): market.call_active.append( pre_af_mask & np.isfinite(call_bid) & np.isfinite(call_ask) & (call_bid >= 0.0) & (call_ask > call_bid) ) market.put_active.append( pre_af_mask & np.isfinite(put_bid) & np.isfinite(put_ask) & (put_bid >= 0.0) & (put_ask > put_bid) ) return { "schema_version": MARKET_SCHEMA_VERSION, "ticker": ticker, "d": d, "spot_ref": spot_ref, "spot_ret": spot_ret, "market": dict(market), "af_pricer": af_pricer.to_dict(), "fit_result": dict(fit_result), }