Errors

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{
    AnyInstrument, Book, CalibrationError, CollateralSpec, FixingStore, FxRates, Interpolation,
    MarketContext, MarketDataError, PricingError, QuoteSheet, Termination, Tolerance, calibrate,
    template,
};

fn date(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

/// The named class Python raises for a pricing refusal, decided as it decides it.
fn pricing_class(error: &PricingError) -> &'static str {
    if error.missing_input().is_some() {
        "MissingMarketInputError"
    } else if error.is_unsolved() {
        "SolveError"
    } else {
        "PricingError"
    }
}

fn market_data_class(error: &MarketDataError) -> &'static str {
    match error {
        MarketDataError::MissingFixing { .. } => "MissingFixingError",
        MarketDataError::MissingFxRate { .. } => "MissingFxRateError",
        _ => "MarketDataError",
    }
}

fn calibration_class(error: &CalibrationError) -> &'static str {
    if error.is_unconverged() { "ConvergenceError" } else { "CalibrationError" }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let close = date(SOFR_CLOSE_DATE.0, SOFR_CLOSE_DATE.1, SOFR_CLOSE_DATE.2);
    let sheet = QuoteSheet::from_rows(USD_SOFR_CLOSE.iter().copied())?;
    let usd = CollateralSpec::Currency("USD".parse()?);
    let market = MarketContext::as_of(close).with_recipe_quotes(&usd, &sheet)?;
    let swap = |code: &str, traded: NaiveDate, rate: f64| -> AnyInstrument {
        template(code)
            .expect("a registered template")
            .swap(traded)
            .expect("a trade date")
            .with_maturity("5Y".parse::<Termination>().expect("a tenor"))
            .expect("a maturity")
            .with_notional(1e6)
            .with_fixed_rate(rate)
            .build()
            .expect("a complete trade")
    };
    let seasoned = swap("USD-SOFR-OIS", date(2026, 9, 24), 0.0466);
    let euro = swap("EUR-ESTR-OIS", close, 0.0200);
    let booked = |trade_id: &str, instrument: &AnyInstrument| {
        Book::new().add(trade_id, instrument.clone(), 1.0).attach_market(market.clone())
    };

    // One failure from each layer. The market holds the USD curve and no prints.
    let reset = booked("SEASONED", &seasoned).npv(close).expect_err("a reset is missing");
    let fixing = market.fixing("USD-SOFR", date(2026, 9, 1)).expect_err("nothing was published");
    let ladder = calibrate(
        close,
        &[],
        &FixingStore::default(),
        &FxRates::new(),
        Tolerance::default(),
        Interpolation::LogLinear,
    )
    .expect_err("a ladder needs a rung");
    let rows = [
        ("a seasoned swap's reset", pricing_class(&reset), "PricingError"),
        ("an unpublished fixing", market_data_class(&fixing), "MarketDataError"),
        ("a ladder with no rung", calibration_class(&ladder), "CalibrationError"),
    ];
    let mut classes: Vec<&str> = rows.iter().map(|(_, class, _)| *class).collect();
    classes.dedup();
    for (what, class, layer) in rows {
        println!("{what:<24} {class:<24} under {layer}");
    }

    // A missing market input names what is missing in the spelling the market lists
    // its contents in, and the trade it was missing for.
    let missing = booked("ESTR-5Y", &euro).npv(close).expect_err("no EUR curve");
    let (kind, key) = missing.missing_input().expect("a missing input");
    let message = missing.to_string();
    println!("kind   {kind}");
    println!("key    {key}");
    println!("trade  {}", missing.trade().expect("a trade"));
    println!("first  {}", message.split(';').next().expect("a first clause"));

    Ok(())
}

import datetime as dt

import helixio as hlx
from desk_sheets import SOFR_CLOSE_DATE, USD_SOFR_CLOSE

LAYERS = (hlx.PricingError, hlx.RiskError, hlx.CalibrationError, hlx.MarketDataError)
market = hlx.MarketContext(SOFR_CLOSE_DATE).with_recipe_quotes("USD", USD_SOFR_CLOSE)
sofr, estr = hlx.templates.get("USD-SOFR-OIS"), hlx.templates.get("EUR-ESTR-OIS")
seasoned = sofr.swap(dt.date(2026, 9, 24)).with_maturity("5Y").with_notional(1e6).with_fixed_rate(0.0466).build()
euro = estr.swap(SOFR_CLOSE_DATE).with_maturity("5Y").with_notional(1e6).with_fixed_rate(0.0200).build()

def refusal(attempt) -> hlx.HelixError:
    """The error a failing call raises. A call that succeeds is itself a failure."""
    try:
        attempt()
    except hlx.HelixError as error:
        return error
    raise AssertionError("the call was expected to be refused")

def layer_of(error: hlx.HelixError) -> str:
    return next(layer.__name__ for layer in LAYERS if isinstance(error, layer))

def booked(trade_id: str, instrument: hlx.Instrument) -> hlx.Book:
    book = hlx.Book().add(trade_id, instrument, 1.0)
    book.attach_market(market)
    return book

# One failure from each layer. The market holds the USD curve and no prints.
attempts = [
    ("a seasoned swap's reset", lambda: booked("SEASONED", seasoned).npv(as_of=SOFR_CLOSE_DATE)),
    ("an unpublished fixing", lambda: market.fixing("USD-SOFR", dt.date(2026, 9, 1))),
    ("a ladder with no rung", lambda: hlx.calibration.curve(SOFR_CLOSE_DATE, [])),
]
errors = [refusal(attempt) for _, attempt in attempts]
for (what, _), error in zip(attempts, errors):
    print(f"{what:<24} {type(error).__name__:<24} under {layer_of(error)}")

# A missing market input names what is missing in the spelling the market lists
# its contents in, and the trade it was missing for.
missing = refusal(lambda: booked("ESTR-5Y", euro).npv(as_of=SOFR_CLOSE_DATE))
print(f"kind   {missing.kind}")
print(f"key    {missing.key}")
print(f"trade  {missing.trade}")
print(f"first  {str(missing).split(';')[0]}")

use chrono::NaiveDate;
use helixio_docs_sheets::{SOFR_CLOSE_DATE, USD_SOFR_CLOSE};
use helixrs::{AnyInstrument, Book, CollateralSpec, DayCountFraction, MarketContext, QuoteSheet, Termination, template};

fn date(year: i32, month: u32, day: u32) -> NaiveDate {
    NaiveDate::from_ymd_opt(year, month, day).expect("a real calendar date")
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A spelling outside a closed vocabulary is refused before any layer runs, and
    // the refusal lists what the vocabulary accepts.
    let spelling_refusal = "ACT/364".parse::<DayCountFraction>().unwrap_err();
    let accepted = spelling_refusal.accepted();
    println!(
        "refused    {}",
        spelling_refusal.to_string().split(';').next().expect("a first clause")
    );
    let round_trips = accepted
        .iter()
        .filter(|code| code.parse::<DayCountFraction>().is_ok_and(|parsed| parsed.code() == **code))
        .count();
    println!("accepted   {} codes, {round_trips} of them parse back to themselves", accepted.len());

    Ok(())
}

import helixio as hlx

# A spelling outside a closed vocabulary is refused before any layer runs, and
# the message lists what the vocabulary accepts.
try:
    hlx.dates.DayCountFraction("ACT/364")
    spelling_refusal = None
except ValueError as error:
    spelling_refusal = error
accepted = str(spelling_refusal).split("expected one of: ")[1].split(", ")
print(f"refused    {str(spelling_refusal).split(';')[0]}")
round_trips = sum(hlx.dates.DayCountFraction(code).code() == code for code in accepted)
print(f"accepted   {len(accepted)} codes, {round_trips} of them parse back to themselves")