"""Command-line entry point for Tangent Lévy calibration and simulation."""
from __future__ import annotations
import argparse
import json
from dataclasses import asdict
from datetime import date
from pathlib import Path
import numpy as np
from cdxcore.verbose import Context
from .config import DynamicsConfig, SimulationConfig, TangentLevyConfig
from .experiment import load_calibrated_history, run_core_experiment
from .markets import common_grid_coverage
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--ticker", default="SPX")
parser.add_argument("--start", type=date.fromisoformat, default=date(2022, 1, 1))
parser.add_argument("--end", type=date.fromisoformat, default=date(2025, 8, 30))
parser.add_argument("--label", default="spx-2022-2025")
parser.add_argument("--paths", type=int, default=5_000)
parser.add_argument("--maximum-dates", type=int)
parser.add_argument(
"--dynamics-end",
type=date.fromisoformat,
default=date(2024, 12, 31),
)
parser.add_argument("--static-only", action="store_true")
parser.add_argument("--no-simulation", action="store_true")
parser.add_argument(
"--allow-failed-reconstruction",
action="store_true",
help=(
"diagnostic override: fit dynamics even when cumulative-density "
"reconstruction materially changes fitted surfaces"
),
)
parser.add_argument("--output", type=Path)
return parser
[docs]
def main() -> None:
"""Run the configured experiment and emit an audit summary."""
args = _parser().parse_args()
config = TangentLevyConfig(
label=args.label,
dynamics=DynamicsConfig(
require_reconstruction_pass=not args.allow_failed_reconstruction
),
simulation=SimulationConfig(num_paths=args.paths),
)
if args.static_only:
history = load_calibrated_history(
args.ticker,
args.start,
args.end,
config=config,
verbose=Context.all,
maximum_dates=args.maximum_dates,
)
result = None
else:
result = run_core_experiment(
args.ticker,
args.start,
args.end,
config=config,
verbose=Context.all,
maximum_dates=args.maximum_dates,
dynamics_end=args.dynamics_end,
simulate=not args.no_simulation,
)
history = result.history
coverage = common_grid_coverage(
history.audits,
candidate_tau=np.asarray(config.dynamics.tau_grid),
minimum_fraction=0.95,
)
maturity_fits = [fit for day in history.day_fits for fit in day.fits]
summary = {
"ticker": history.ticker,
"requested_dates": len(history.requested_dates),
"calibrated_dates": len(history.dates),
"successful_date_fraction": history.successful_date_fraction,
"failed_dates": history.failure_reasons,
"market_audit": {
"available_dates": sum(audit.available for audit in history.audits),
"early_close_dates": sum(audit.early_close for audit in history.audits),
"option_cap_bound_dates": sum(
audit.option_cap_bound for audit in history.audits
),
"candidate_tau": coverage.candidate_tau.tolist(),
"coverage_fraction": coverage.coverage_fraction.tolist(),
"selected_tau": coverage.selected_tau.tolist(),
},
"static_fit": {
"maturity_fits": len(maturity_fits),
"optimizer_success_fraction": float(
np.mean([fit.success for fit in maturity_fits])
),
"median_half_spread_rmse": float(
np.median([fit.weighted_rmse for fit in maturity_fits])
),
"maximum_price_error": float(
np.max([fit.maximum_absolute_error for fit in maturity_fits])
),
"reconstruction_pass_fraction": float(
np.mean(history.reconstruction_passed)
),
"maximum_reconstruction_relative_projection": float(
np.max(history.reconstruction_relative_error)
),
"maximum_reconstruction_l1_projection": float(
np.max(history.reconstruction_l1_error)
),
"median_reconstruction_repricing_rmse": float(
np.median(history.reconstruction_repricing_rmse)
),
"maximum_reconstruction_repricing_rmse": float(
np.max(history.reconstruction_repricing_rmse)
),
"maximum_reconstruction_price_error": float(
np.max(history.reconstruction_maximum_price_error)
),
},
"dynamics": (
None
if result is None
else {
"num_factors": result.dynamics.num_factors,
"observations": result.dynamics.observations,
"training_end": result.dynamics_end,
"explained_variance_ratio": (
result.dynamics.explained_variance_ratio.tolist()
),
"maximum_constraint_residual": (
result.dynamics.maximum_constraint_residual
),
"active_cell_fraction": float(
np.mean(result.dynamics.active_mask)
),
}
),
"simulation": (
None
if result is None or result.simulation is None
else {
"failed_path_fraction": result.simulation.failed_path_fraction,
"frozen_path_fraction": result.simulation.frozen_path_fraction,
"minimum_gamma": float(np.min(result.simulation.minimum_gamma)),
"boundary_limited_paths": int(
np.count_nonzero(result.simulation.boundary_limited_steps)
),
}
),
"config": asdict(config),
}
rendered = json.dumps(summary, indent=2, default=str)
if args.output is None:
print(rendered)
else:
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(rendered + "\n", encoding="utf-8")
print(f"Wrote {args.output}")
if __name__ == "__main__":
main()