Python reference

Every name the package exports, as the release this line pins declares it. Generated from the pinned wheel's own type stub rather than by importing it, so what is documented here is what that build exports — not what happened to be installed when the page was made.

This is the low-level surface: signatures, and what each name is for. Where a page documents a symbol, the entry links to it, labelled with the page's kind: a reference page lists its arguments, an explanation page its reasoning.

Measured against helixio 0.0.1.

	count
classes	29
functions	1
modules	15

Functions

set_data_source(source: object | None) — reference

Sets the process-wide default data source — any object with fetch(demand, as_of), and recipes(ask) where it serves recipes — or, with None, clears it. A market copies it when built.

Modules

helixio.bonds

Bond measures: spreads, yields to call and worst, forward prices, effective risk, a payment-in-kind bond's accretion, a zero's quotes, the readings of trades on bonds (a bond TRS's fair margin, a repo's margin and package value), and the reports they come back as. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
BondFutureAnalysis	BondFutureAnalysis — The basket analysis: the rows, the CTD, the theoretical price.
BondFutureOptionDiagnostics	BondFutureOptionDiagnostics — What a bond future option is priced from, per 100.
BondOptionDiagnostics	BondOptionDiagnostics — What a bond option resolved to when it was priced.
BondStrikeKind	BondStrikeKind — What a bond option's strike is stated as: a Clean or Dirty price, or a Yield. bond_option takes the member or its string.
CallKind	CallKind — Whose option a callability is: the issuer's Call or the holder's Put. A callable_bond schedule row carries the member or its string.
DeliverableAnalysis	DeliverableAnalysis — One deliverable's analytics at a quoted futures price.
ExDivDayType	ExDivDayType — The days an ex-dividend lag counts: Business days on the bond's settlement calendar (UK gilts) or Calendar days (South African government bonds).
PriceBasis	PriceBasis — Whether a bond price includes accrued interest. Clean or Dirty; every bond reading that takes a basis takes the member or its string. A member is not equal to its string; code() is the string the parser takes.
YieldConvention	YieldConvention — The convention a quoted yield is stated under, by one name. A street convention — UsStreet, UkGilt, DeGovt, or the bond's own Default — compounding at the market's frequency; a fixed compounding — Annual, SemiAnnual, Quarterly, Monthly, Continuous, Simple — whatever the bond pays; or one of the two conventions that are not a discounting relationship, Ise and JapaneseSimple. Every yield_convention parameter takes the member or its spelling ("ust", "semiannual", "jgb"). A reading that needs a single compounding basis, such as a duration, refuses Ise and JapaneseSimple by name. A member is not equal to its string.
YieldMoments	YieldMoments — A bond's dirty price and its first two yield derivatives at one yield; every yield-space measure is a reading of the three.
accreted_face	accreted_face(instrument: Instrument, date: datetime.date) — A payment-in-kind bond's accreted face on date: its par face grown by every capitalisation on or before it.
accreted_redemption	accreted_redemption(instrument: Instrument) — A payment-in-kind bond's one cash flow per 100 of par face: its redemption, accreted to maturity.
callable_oas	callable_oas(instrument: Instrument, market: MarketContext, clean_price: float) — The option-adjusted spread at which the callable's clean price is clean_price. A callable loan is quoted per 100 of its outstanding, once drawn and without a credit tag.
capitalisations	capitalisations(instrument: Instrument) — Every capitalisation on a payment-in-kind bond's life, in order: the date the coupon would have paid, the rate and year fraction it accrued at, the face entering and leaving the period, and the amount rolled into principal. A capitalisation is not a cash flow, which is why a PIK bond's cashflow_records refuses: it pays once, at maturity. This is the table the accretion is reconstructable from.
clean_price_at_oas	clean_price_at_oas(instrument: Instrument, market: MarketContext, oas: float) — The callable's clean price at an option-adjusted spread; a callable loan's per 100 of its outstanding.
discount_margin	discount_margin(instrument: Instrument, market: MarketContext, quoted_clean: float) — The note's discount margin at a quoted clean price: the flat continuous spread on the discounting that reprices the quote.
effective_risk	effective_risk(instrument: Instrument, market: MarketContext, oas: float=0.0) — The callable's effective duration, convexity and DV01, from one lattice pass. "Effective" because the exercise decision moves with the shift: a callable's cashflows depend on rates, so this is not its yield duration. The three are returned together because the core needs one lattice pass for all of them. Not the sum of the bond's risk ladder — that sum weights each pillar by what the curve family stores, while this shifts the discounting itself.
fair_margin	fair_margin(instrument: Instrument, market: MarketContext) — The funding margin that values a bond total return swap at zero.
forward_price	`forward_price(bond: FixedRateBond, market: MarketContext, forward_date: datetime.date, price_basis: PriceBasis
future_analysis	future_analysis(future: BondFuture, market: MarketContext, futures_price: float) — The basket of future on market, at a quoted futures_price per 100.
note_dirty_price	note_dirty_price(instrument: Instrument, market: MarketContext) — A structured note's value per 100 of face.
note_z_spread	note_z_spread(instrument: Instrument, market: MarketContext, dirty_price: float) — The flat continuous spread over a structured note's discounting that reprices dirty_price per 100, its coupons projected spread-free.
package_value	package_value(instrument: Instrument, market: MarketContext) — A repo's value with its collateral: the cash leg plus the bond received, less the bond returned at its repo forward, less — classic — the coupons manufactured back. A cross-currency repo's foreign bond is valued on its own currency's curve and converted at spot.
pv_weighted_time	`pv_weighted_time(flows: list[tuple[float, float]], yield_: float, yield_convention: YieldConvention
repo_margin	`repo_margin(instrument: Instrument, market: MarketContext, *, price: float
settlement_date	settlement_date(instrument: Instrument, trade_date: datetime.date) — The date a payment-in-kind bond traded on trade_date settles on: its settlement lag walked from it, never before issue.
simple_margin	simple_margin(instrument: Instrument, quoted_clean: float, settlement: datetime.date) — The note's simple margin at a quoted clean price — the closed-form shortcut to the discount margin. No curve, no projection, no solve.
spread_duration	spread_duration(instrument: Instrument, market: MarketContext) — The note's spread duration: its sensitivity to a flat continuous overlay on the discounting, and its dominant risk.
spread_over_curve	`spread_over_curve(bond: FixedRateBond, reference: DiscountCurve, dirty_price: float, settlement: datetime.date, yield_convention: YieldConvention
yield_convention_status	yield_convention_status — The vendor calc methods' convention status, one row per code: code, name, status ("pinned" or "pending") and outstanding.
yield_to_call	`yield_to_call(instrument: Instrument, dirty_price: float, date: datetime.date, settlement: datetime.date, yield_convention: YieldConvention
yield_to_maturity_scenario	`yield_to_maturity_scenario(instrument: Instrument, dirty_price: float, settlement: datetime.date, yield_convention: YieldConvention
yield_to_worst	`yield_to_worst(instrument: Instrument, dirty_price: float, settlement: datetime.date, yield_convention: YieldConvention
z_spread	`z_spread(bond: FixedRateBond, market: MarketContext, price: float, price_basis: PriceBasis
zero_coupon_quotes	zero_coupon_quotes(instrument: Instrument) — The three quotes a zero is traded on, and the price behind them: (price, discount_yield, money_market_yield, bond_equivalent_yield, quoted_yield). The price is per unit of face. quoted_yield is the number the zero's own market prints, under the convention its registered calculation method carries; bond_equivalent_yield is the semi-annually compounded ACT/365F yield that puts it beside a coupon note.

helixio.calibration

Solving curve parameters from instruments. The module is the verb, so an entry point is named for the object it solves. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
CalibratedBaseCorrelation	CalibratedBaseCorrelation — A base-correlation curve solved from a tranche capital structure, and how it was reached.
CalibratedInflation	CalibratedInflation — An inflation curve solved from a ladder of zero-coupon inflation swaps, and how it was reached.
CalibratedSurvival	CalibratedSurvival — A survival curve solved from a ladder of credit default swaps, and how it was reached.
Calibration	Calibration — A calibrated curve and how it was reached.
HullWhiteFit	HullWhiteFit — A fitted Hull-White volatility and what the fit knows about it.
JointCalibration	JointCalibration — Several curves solved together, each under its first role.
Rung	Rung — One rung of a ladder with its quote kind declared.
SigmaShape	SigmaShape — The shape a Hull-White volatility is calibrated in: Flat by least squares, or Piecewise, one piece per strip expiry.
SmoothedCalibration	SmoothedCalibration — A discount curve fitted globally, trading repricing error for forward smoothness.
Tolerance	Tolerance — How hard a ladder solver tries; the core's defaults unless overridden.
base_correlation	`base_correlation(discount: DiscountCurve, survival: SurvivalCurve, tranches: list[Instrument], recovery: float
bond_rung	`bond_rung(bond: FixedRateBond, quote: float, measure: str, reference: datetime.date, yield_convention: YieldConvention
cross_currency	`cross_currency(reference: datetime.date, pay_discount: DiscountCurve, pay_projection: DiscountCurve, recv_projection: DiscountCurve
cross_currency_rungs	`cross_currency_rungs(template: str
curve	`curve(reference: datetime.date, rungs: list[tuple[datetime.date, Instrument, float]
curves	`curves(reference: datetime.date, curves: list[tuple[str
helpers	helpers: types.ModuleType
hull_white	`hull_white(market: MarketContext, instrument: Instrument, mean_reversion: float, shape: SigmaShape
hull_white_pinned	`hull_white_pinned(market: MarketContext, instrument: Instrument, mean_reversion: float, shape: SigmaShape
hull_white_strip	`hull_white_strip(market: MarketContext, currency: str, strip: list[tuple[datetime.date, datetime.date]], mean_reversion: float, collateral: str
inflation	`inflation(reference: datetime.date, discount: DiscountCurve
par_rungs	`par_rungs(template: str
smoothed_curve	`smoothed_curve(reference: datetime.date, rungs: list[tuple[datetime.date, Instrument, float]
survival	`survival(reference: datetime.date, discount: DiscountCurve, rungs: list[tuple[datetime.date, Instrument, float]
survival_density	`survival_density(reference: datetime.date, discount: DiscountCurve, rungs: list[tuple[datetime.date, Instrument, float]

helixio.credit

Credit model readings taken directly: a swap's own legs, risky value, note components, and the tranche and basket losses. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
AccrualOnDefault	AccrualOnDefault — How premium accrued since the last coupon settles on default: Proportional (the ISDA standard model's), Halfway, or NoAccrual (code none). credit_default_swap takes the member or its string.
CdsDiagnostics	CdsDiagnostics — Each part of a credit default swap's value, signed as it enters that value, and the risky annuity behind its quote.
CreditLinkedSwapDiagnostics	CreditLinkedSwapDiagnostics — Each part of a credit-linked swap's value, in the trade currency, signed as it enters that value, in five parts. The parts sum to npv().
DefaultPaymentTime	DefaultPaymentTime — When a credit-linked swap's default-contingent payment is made: AtDefault (the interval's midpoint), AtPeriodEnd (the first scheduled payment date on or after the default) or AtMaturity. credit_linked_swap takes the member or its string.
GapCharge	GapCharge — A repack note's gap charge and its rows.
IndexSettlement	IndexSettlement — What a credit event settles on an index position, signed to the holder.
IndexSkew	IndexSkew — One term structure of hazard multipliers every constituent is scaled by.
LegRole	LegRole — How a credit-linked swap's leg depends on the reference entity's default: Independent (paid whatever happens), Contingent (paid while the entity survives), Default (paid on default, scaled by the loss) or Recovery (paid on default, scaled by the recovery). credit_linked_swap takes the member or its string.
SimulatedGap	SimulatedGap — A repack note's simulated gap: the charge, its standard error, its legs and its profile.
TrancheSettlement	TrancheSettlement — What a credit event settles on a tranche position, and where it leaves the tranche on the surviving pool.
after_credit_event	after_credit_event(instrument: Instrument, entity: str, weight: float, auction_recovery: float, event_date: datetime.date) — An index CDS or a CDO tranche after a credit event: the index re-versioned with an IndexSettlement, or the tranche eroded from the bottom and written down from the top, on the surviving pool, with a TrancheSettlement.
basket_survival_probability	`basket_survival_probability(pds: list[float], rho: float, n: int, *, factor_dof: float
cds_option	`cds_option(instrument: Instrument, expiry: datetime.date, *, strike: float, vol: float, kind: SwaptionKind
expected_tranche_loss	`expected_tranche_loss(pd: float, lgd: float, attach: float, detach: float, rho: float, *, factor_dof: float
index_intrinsic	index_intrinsic(instrument: Instrument, constituents: list[tuple[str, float]], market: MarketContext) — An index CDS against its constituents: (intrinsic value, intrinsic spread). Each constituent is a full ENTITY/SENIORITY/DOCCLAUSE spelling or a bare entity on the index family's standard tier and clause, valued on its curve in the index's currency; weights are shares of the original index notional.
index_skew	index_skew(instruments: list[Instrument], constituents: list[tuple[str, float]], market: MarketContext) — The skew that makes an index's constituents reprice it: index CDS at strictly ascending maturities, each valued on the index curve; solved tenor by tenor.
note_components	note_components(instrument: Instrument, market: MarketContext) — A credit-linked note's (coupons, redemption, recovery) components.
on_the_run	on_the_run(family: str, date: datetime.date) — The series of family on the run on date.
premium_contract	premium_contract(instrument: Instrument) — The credit default swap a tranche, an nth-to-default basket, an index CDS or a credit-linked note pays its premium on, as an instrument of its own: its premium leg is the product's premium schedule, its entity the curve the product references, and it books and prices like any CDS.
repack_gap	repack_gap(note: Instrument, market: MarketContext) — The repack gap charge of note against market, under the note's engine.
risky_value	risky_value(flows: list[tuple[datetime.date, float]], face: float, maturity: datetime.date, discount: DiscountCurve, survival: SurvivalCurve, recovery: float, default_from: datetime.date) — The survival-weighted value of the flows plus recovery of face on default, integrated over quarter-long intervals from default_from.
series_maturity	series_maturity(family: str, series: int, tenor_years: int) — The maturity of series of family at tenor_years, kept off the run.
series_roll	series_roll(family: str, series: int) — The nominal date series of family rolls on: the 20th of March or September.
simulate_repack_gap	simulate_repack_gap(note: Instrument, market: MarketContext, *, paths: int=20000, seed: int=24301, antithetic: bool=True, pfe_quantile: float=0.95, repeat_crises: bool=False, recovery_volatility: float=0.0) — The repack gap of note against market by Monte Carlo: crises, the valuation trigger and its liquidation lag included. With recovery_volatility, the recovery a default pays is beta-distributed about the issuer's market recovery with that standard deviation and integrated at each default; zero keeps it fixed. A model setting, with no risk row. Raises ValueError for fewer than two paths, an odd path count under antithetics, a quantile outside (0, 1), or a negative recovery volatility; one too wide for a beta raises when the run starts.
simulate_repack_gap_risk	simulate_repack_gap_risk(note: Instrument, market: MarketContext, *, paths: int=20000, seed: int=24301, antithetic: bool=True, pfe_quantile: float=0.95, repeat_crises: bool=False, recovery_volatility: float=0.0) — input and value: the simulated gap's sensitivity to every lifted input of market, by a central difference on common random numbers.

helixio.curves

The curve families, the parametric fit, and the curve readings a caller takes directly. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
BaseCorrelation	BaseCorrelation — A base-correlation skew across an index's capital structure.
BondFitRow	BondFitRow — One bond's place in a parametric curve fit.
CmsSpreadCorrelationCurve	CmsSpreadCorrelationCurve — The market's correlation between two swap indices' rates by option expiry in years — linear between pillars, flat beyond them — or one flat mark with no pillar, or a 2-D surface by expiry and strike.
CurveRecipe	CurveRecipe — How a market would build the curves under one key, as topology: the discount segments in order, each a role and the template that builds it, and per projection index whether it telescopes onto the discount curve or has its own strip. It carries no tenor: the quote sheet is the grid. Read back from MarketContext.recipe; str() is the core's one-line summary.
DiscountCurve	DiscountCurve — A discount curve, built from dated discount-factor pillars. A first pillar of exactly 1.0 on the reference date is the anchor the curve already holds, and is dropped; any other factor there is refused.
InflationCurve	InflationCurve — An inflation index-level curve.
Interpolation	Interpolation — The scheme a discount curve reads between its pillars, as a value that carries its parameters. One member per parameter-free scheme — LogLinear, BackwardFlat, ForwardFlat, LinearZero, NaturalCubic, NotAKnotCubic, MonotoneConvex, MonotoneCubic, Akima, Kruger — and tension_spline(sigma) / clamped_cubic(left, right) for the two that take them. Every interpolation parameter on a discount curve or a curve calibration takes the member or its code; given the value, tension and end_slopes are refused, since the value carries its own. code() is what DiscountCurve.interpolation() reads back.
LevelInterpolation	LevelInterpolation — How an inflation curve reads an index level between its nodes: Linear in the level, or LogLinear. InflationCurve and calibration.inflation take the member or its string.
RecipeSpec	RecipeSpec — A curve recipe stated as data, validated as the recipe builder validates it: discount segments as (role, template), per projection index "telescoping" or its own strip's template, windows as (template, start, end).
RepoSpreadCurve	RepoSpreadCurve — A repo spread: the simple spreads a desk marks — GC against the overnight curve, a special against GC — at dated pillars, linear between them and flat outside, accruing on a money-market day_count. Pinned with MarketContext.with_repo_spread over a base, it adds in simple-rate space, 1/P = 1/P_base + s * tau, and its pillars report risk on the repo axis.
SpreadCurve	SpreadCurve — A continuously compounded spread over a date, applied on top of the discounting a security is priced on. Dated, its pillars are free parameters and report risk on the security_spread axis; flat, it is declared data and reports none.
SurvivalCurve	SurvivalCurve — A survival curve: the probability of surviving to a date.
fit_bond_curve	fit_bond_curve(reference: datetime.date, quotes: list[tuple[FixedRateBond, float]], form: str='nelson_siegel', weights: str='inverse_duration', basis: int=3) — Fit a parametric discount curve to a bond universe. A smoother, not a repricer: a handful of parameters over many bonds cannot reproduce every price and is not meant to. The rows returned beside the curve are what say how far it misses — use calibrate when exactness matters. form is nelson_siegel/ns, svensson/nss, or exponential_splines/splines (which reads basis). weights is inverse_duration/duration or equal; the choice changes the answer. Raises CalibrationError if the universe cannot determine the form, the solve does not converge, or — for the splines form — the fitted curve is not a discount curve across the horizon.
yield_at	`yield_at(curve: DiscountCurve, date: datetime.date, yield_convention: YieldConvention

helixio.dates

The date substrate: schedules, rolls, tenors, IMM dates, and the convention vocabularies a dated term is written in. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
BusinessDayConvention	BusinessDayConvention — How a non-business date rolls to a business date. A member is a spelling of the core value the string names — its code() is the string the parser takes — so every parameter that takes a business-day convention takes the member or the string. The core's None (no adjustment) is the member Unadjusted, because X.None cannot be written in Python; the strings "None" and "NONE" still parse to it. A member is not equal to its string.
CalendarSpec	CalendarSpec — A calendar stated as data for dates.ingest_calendars: the code it binds, its holidays, and its weekend (Saturday and Sunday by default).
DayCountFraction	DayCountFraction — A day-count convention, named once and measured with repeatedly. Every convention is a named member — DayCountFraction.ActActIcma is DayCountFraction("ACT/ACT.ICMA") — and every parameter that takes a day count takes the member or its code. repr is the member's address; str and code() are the code.
Frequency	Frequency — A coupon frequency: a named member, or a period a caller spells. Frequency("6M") is Frequency.SemiAnnual; Frequency("28D") is the 28-day markets' coupon and has no named member. Once is a single payment at maturity with no recurring period, and is refused where a schedule is generated. Every parameter that takes a frequency takes the member or its spelling; a member is not equal to its string.
JointCalendarRule	JointCalendarRule — How a joint calendar combines its members: JoinHolidays (a holiday in any member is a holiday) or JoinBusinessDays (a business day in any member is a business day).
MeetingSchedule	MeetingSchedule — A central bank's schedule: its published decision days, with the date each takes effect derived by the bank's rule — the Fed the next business day, the ECB the following Wednesday, the Bank of England the decision day. Pinned on a market with MarketContext.with_meetings; seeded(bank) is the embedded 2026 schedule the market uses where none is pinned.
Period	Period — A tenor: a signed count of days, weeks, months or years, or the whole term. Period("3M") or Period(3, "M"). Equality and hashing are by duration (Period("12M") == Period("1Y")); ordering is by duration where it is decidable and raises ValueError where it is not (1M against 30D); + and - combine tenors of one unit family. Every tenor or frequency parameter takes one beside its spelling.
RollConvention	RollConvention — Where a period boundary sits inside its month. A named member, or a day of the month from RollConvention.day(n) (1 to 30). The core's None (no roll) is the member Unadjusted. Every parameter that takes a roll takes the member or its spelling ("EOM", "15"); a member is not equal to its string.
Schedule	Schedule — A generated set of calculation-period boundary dates.
add_period	`add_period(date: datetime.date, tenor: Period
cds_standard_maturity	cds_standard_maturity(date: datetime.date, tenor_years: int) — The CDS2015 standard maturity tenor_years out from date.
cds_standard_maturity_months	cds_standard_maturity_months(date: datetime.date, months: int) — The CDS2015 standard maturity months out from date — the sub-annual form, which the whole-year one is a case of.
forward_tenor	forward_tenor(spelling: str) — The forward start (None for a term from spot) and the tenor of a <forward-start><tenor> spelling, each in canonical form: "2y2y" is ("2Y", "2Y") and "10Y" is (None, "10Y").
imm_code_of	imm_code_of(date: datetime.date) — The IMM code naming date ("JUN27"), or None where date is not a third Wednesday or its year is outside the 2000–2099 window a two-digit code can spell.
imm_code_to_dates	imm_code_to_dates(code: str, cycle: str='Quarterly') — The unadjusted (start, end) reference period an IMM code names — the period of the futures contract it names, as a futures template's reference_period reads it, and the inverse of imm_code_of, which renders the start. start is the third Wednesday of the code's own month; end is the third Wednesday of the next IMM in cycle. Raises ValueError naming the code where it is not MMM + YY, its year falls outside 2000–2099, or the quarterly cycle is asked for a month it does not admit.
imm_date	imm_date(month: int, year: int, cycle: str='Quarterly', day: str='ThirdWednesday') — The IBOR-IMM date of month in year, the third Wednesday. A month outside cycle raises ValueError. day is "ThirdWednesday" or "WednesdayOnOrAfterNinth", the first Wednesday on or after the 9th.
ingest_calendars	`ingest_calendars(source: list[CalendarSpec]
ingested_calendars	ingested_calendars — The codes ingested this process, sorted.
is_imm_date	is_imm_date(date: datetime.date, cycle: str='Quarterly') — Whether date is an IBOR-IMM date — the third Wednesday of a cycle month. The quarterly cycle admits only March, June, September and December.
lagged_observation	lagged_observation(date: datetime.date, lag_months: int) — The observation date a lag of lag_months puts before date — where an inflation swap reads the index, and therefore where its rung's pillar sits.
last_day_of_month	last_day_of_month(date: datetime.date) — The last calendar day of date's month, blind to weekends and holidays. The business month end is Calendar.end_of_month.
meeting_dates	`meeting_dates(bank: str, start: datetime.date, end: datetime.date, *, schedule: MeetingSchedule
next_cds_imm_date	next_cds_imm_date(date: datetime.date) — The next CDS-IMM date strictly after date — the 20th of the next March, June, September or December; a CDS-IMM date rolls to the following one. A calendar date, never adjusted.
next_imm_date	next_imm_date(date: datetime.date, cycle: str='Quarterly') — The next IBOR-IMM date strictly after date: an IMM date rolls to the following one.
next_weekday	next_weekday(date: datetime.date, weekday: str) — The first weekday on or after date. Calendar-blind: may be a holiday.
nth_weekday	nth_weekday(n: int, weekday: str, year: int, month: int) — The nth weekday in a month, counting from one. None where the month holds no such day — most months have four of each weekday and some five.
prior_cds_imm_date	prior_cds_imm_date(date: datetime.date) — The prior CDS-IMM date strictly before date: a CDS-IMM date rolls to the preceding one.
prior_imm_date	prior_imm_date(date: datetime.date, cycle: str='Quarterly') — The prior IBOR-IMM date strictly before date: an IMM date rolls to the preceding one.
roll	`roll(date: datetime.date, roll_convention: RollConvention
schedule	`schedule(effective: datetime.date, termination: datetime.date, frequency: Frequency
tenor	tenor(spelling: str) — Normalizes a tenor to its canonical spelling ("12M" stays "12M"; "1Y" stays "1Y" — the unit is part of the tenor, not a quantity to convert away).
turn_dates	turn_dates(period: str, start: datetime.date, end: datetime.date) — The turn-of-period dates after start and up to end: every 31 December for "YearEnd", every quarter end for "QuarterEnd".

helixio.fpml

The FpML reader: a confirmation-view trade document into an instrument, with the cashflows the document itself states kept beside it. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
FpmlTrade	FpmlTrade — A trade read from an FpML 5 confirmation document.
StatedCashflow	StatedCashflow — One paymentCalculationPeriod a FpML stream's cashflows block states: the dates and notional the document itself says the stream pays.
complete	complete(text: str, market: MarketContext) — Completes the first trade's stated cashflows in an FpML 5 confirmation document with their values on market, and returns the document's text. Every stated row still owed gains its days, year fraction, rates, forecast amount, discount factor and present value, and every stated principal exchange its discount factor and present value. Nothing else in the text changes. A stream without a cashflows block is left alone. A document the reader refuses, a stream whose stated rows do not pair with the coupons helixio generates, a document already carrying such values, and a market that cannot price the trade raise ValueError naming why.
read	read(text: str) — Reads the first trade of an FpML 5 confirmation document from its text. The first party in the document is the reporting party: a stream it pays is a paid leg. A swaption or a cancelable swap is read as the option or callable swap it is, its swap kept as underlying(). Anything the reader does not understand — another namespace, a missing element, an element that changes the economics, an index the registry does not carry — raises ValueError naming it.
read_all	`read_all(text: str, *, party: str

helixio.fx

FX option diagnostics — what an option resolved to when it was priced. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
FxOptionDiagnostics	FxOptionDiagnostics — What an FX option resolved to when it was priced.

helixio.legs

Leg and coupon builders: the cashflow strips a product is assembled from, and the coupon class they return. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
AccrualCompounding	AccrualCompounding — How an overnight leg accumulates its prints over a period: Simple (the market's averaged leg), Compounded or Continuous. Every accrual_compounding parameter takes the member or its string.
AnyCoupon	AnyCoupon — One coupon of the core's closed set: fixed, IBOR, overnight or redemption. Opaque — there is no constructor. A coupon is built by one of :func:fixed_rate_coupon, :func:ibor_coupon, :func:overnight_coupon or :func:redemption, which is where the set stays closed.
Direction	Direction — Which side of a leg the holder is on: Receive or Pay. Every direction parameter takes the member or its string ("Pay", "payer", "short").
ResetCompounding	ResetCompounding — How a multi-reset coupon combines its resets into one payment: the ISDA 2006 methods Straight, Flat and SpreadExclusive, or Averaged. The compounding of multi_reset_coupon takes the member or its string.
accumulated_fixed_leg	`accumulated_fixed_leg(currency: str, effective: datetime.date, maturity: datetime.date, *, notional: float, fixed_rate: float, day_count: str
accumulated_float_leg	`accumulated_float_leg(coupons: list[AnyCoupon], pays: datetime.date, direction: Direction
cms_coupon	`cms_coupon(template: str, tenor: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, day_count: str
cms_leg	`cms_leg(schedule: Schedule, payment_dates: list[datetime.date], template: str, tenor: str, *, notional: float, day_count: str
cms_spread_coupon	`cms_spread_coupon(template: str, tenor: str, minus_tenor: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, day_count: str
cms_spread_leg	`cms_spread_leg(schedule: Schedule, payment_dates: list[datetime.date], template: str, tenor: str, minus_tenor: str, *, notional: float, day_count: str
cpi_coupon	`cpi_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, fixed_rate: float, day_count: str
cpi_leg	`cpi_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float, fixed_rate: float, day_count: str
cpi_redemption	`cpi_redemption(currency: str, payment_date: datetime.date, *, notional: float, index: str, base_index: float, observation: datetime.date
fixed_rate_coupon	`fixed_rate_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, fixed_rate: float, day_count: str
fixed_rate_leg	`fixed_rate_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float
ibor_coupon	`ibor_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, index: str, day_count: str
ibor_leg	`ibor_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float
multi_reset_coupon	`multi_reset_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, index: str, day_count: str
multi_reset_leg	`multi_reset_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float, index: str, day_count: str
overnight_coupon	`overnight_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, index: str, day_count: str
overnight_leg	`overnight_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float
range_accrual_coupon	`range_accrual_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, fixed_rate: float, day_count: str
range_accrual_leg	`range_accrual_leg(schedule: Schedule, payment_dates: list[datetime.date], currency: str, *, notional: float, fixed_rate: float, day_count: str
redemption	redemption(currency: str, payment_date: datetime.date, *, amount: float) — A dated payment of a known amount — a redemption, a fee, a notional exchange. It accrues over nothing and pays no rate.
yoy_inflation_coupon	`yoy_inflation_coupon(currency: str, accrual_start: datetime.date, accrual_end: datetime.date, payment_date: datetime.date, *, notional: float, day_count: str
yoy_inflation_leg	`yoy_inflation_leg(currency: str, schedule: Schedule, payment_dates: list[datetime.date], *, notional: float, day_count: str

helixio.linker

Inflation-linked street conventions — index ratios, real price and yield, and the market-specific quote rules. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
AnbimaQuote	AnbimaQuote — An ANBIMA quotation: its parcels, the cotação and the unit price.
anbima_nominal_value	anbima_nominal_value(instrument: Instrument, market: MarketContext, date: datetime.date) — The ANBIMA VNA at date.
anbima_price	`anbima_price(instrument: Instrument, market: MarketContext, tir: float, settlement: datetime.date, calendar: Calendar, vna: float
anbima_yield_from_price	`anbima_yield_from_price(instrument: Instrument, market: MarketContext, price: float, settlement: datetime.date, calendar: Calendar, vna: float
australian_coupon_factor	australian_coupon_factor(instrument: Instrument, market: MarketContext, next_coupon: datetime.date) — The AOFM p for the payment at next_coupon, rounded to two places.
australian_indexation_factor	australian_indexation_factor(instrument: Instrument, market: MarketContext, date: datetime.date) — The Australian Kt indexation factor at date, in ratio form.
australian_price_from_real_yield	`australian_price_from_real_yield(instrument: Instrument, market: MarketContext, real_yield: float, settlement: datetime.date, kt: float
australian_real_yield_from_price	`australian_real_yield_from_price(instrument: Instrument, market: MarketContext, price: float, settlement: datetime.date, kt: float
index_ratio	index_ratio(instrument: Instrument, market: MarketContext, date: datetime.date) — The linker's index ratio at date: the lagged index level over the base.
invoice	invoice(instrument: Instrument, market: MarketContext, street: str, real_clean: float, settlement: datetime.date) — The settlement invoice per 100 nominal: (index_ratio, clean, accrued, dirty).
real_price	`real_price(instrument: Instrument, street: str, real_yield: float, settlement: datetime.date, price_basis: PriceBasis
real_yield	real_yield(instrument: Instrument, street: str, real_clean: float, settlement: datetime.date) — The street real yield implied by a real clean quote.
reference_index	reference_index(instrument: Instrument, market: MarketContext, observation: str, date: datetime.date) — The linker's street reference index at date. observation is "flat" (one published figure for the lagged month) or "daily" (interpolated between the lagged month and the next by the day-of-month fraction). This is what a quote reads; index_ratio is what the bond's value is built from.
street_index_ratio	street_index_ratio(instrument: Instrument, market: MarketContext, street: str, date: datetime.date) — The linker's street index ratio, by its market's convention. Distinct from index_ratio, which is the observation the bond's value is built from. This is the rule its quote is expressed in: most markets interpolate daily inside the lagged month, then round by their own chain. street is one of tips/us_tips, rrb/canadian_rrb, gilt/uk_dmo, anbima/ntnb, aofm/australian.
uk_money_accrued	`uk_money_accrued(instrument: Instrument, market: MarketContext, settlement: datetime.date, assumed_inflation: float
uk_money_price	`uk_money_price(instrument: Instrument, market: MarketContext, real_yield: float, settlement: datetime.date, assumed_inflation: float
uk_money_yield	`uk_money_yield(real_yield: float, assumed_inflation: float
uk_real_yield_from_money	`uk_real_yield_from_money(money_yield: float, assumed_inflation: float
uk_real_yield_from_money_dirty	`uk_real_yield_from_money_dirty(instrument: Instrument, market: MarketContext, money_dirty: float, settlement: datetime.date, assumed_inflation: float

helixio.models

The closed-form option and short-rate machinery, for a caller who reaches into the model layer directly. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
HullWhite	HullWhite — A validated one-factor Hull-White model: mean reversion a (strictly positive) and a volatility — a non-negative float, or (t_end, σ) pieces with strictly increasing positive ends in years, the last extending flat.
HullWhiteLattice	HullWhiteLattice — The Hull-White trinomial lattice, built and curve-fitted on construction.
bachelier	`bachelier(forward: float, strike: float, vol: float, expiry: float, kind: OptionKind
black76	`black76(forward: float, strike: float, vol: float, expiry: float, kind: OptionKind
black76_implied_vol	`black76_implied_vol(price: float, forward: float, strike: float, expiry: float, kind: OptionKind
compounded_oas	`compounded_oas(oas: float, frequency: Frequency
coupon_bond_option	`coupon_bond_option(model: HullWhite, curve: DiscountCurve, expiry: datetime.date, pay_dates: list[datetime.date], coupons: list[float], strike: float, kind: OptionKind
discount_bond_affine	discount_bond_affine(model: HullWhite, curve: DiscountCurve, t: datetime.date, maturity: datetime.date) — (A, B) with P(t, maturity; r) = A · exp(−B · r).
instantaneous_forward	instantaneous_forward(curve: DiscountCurve, date: datetime.date) — f(0, date) off the curve by the lattice fit's own week-wide stencil.
inv_norm_cdf	inv_norm_cdf(p: float) — The inverse of the standard normal cumulative distribution.
norm_cdf	norm_cdf(x: float) — The standard normal cumulative distribution.
payer_swaption	payer_swaption(mean_reversion: float, sigma: float, curve: DiscountCurve, expiry: datetime.date, pay_dates: list[datetime.date], accruals: list[float], fixed_rate: float) — A European payer swaption under Hull-White, per unit notional: the par-struck put on the coupon bond paying fixed_rate × accrual on pay_dates plus redemption, on curve.
receiver_swaption	receiver_swaption(mean_reversion: float, sigma: float, curve: DiscountCurve, expiry: datetime.date, pay_dates: list[datetime.date], accruals: list[float], fixed_rate: float) — A European receiver swaption under Hull-White, per unit notional: the par-struck call on the same coupon bond as payer_swaption.
sigma_from_price	`sigma_from_price(model: HullWhite, curve: DiscountCurve, expiry: datetime.date, bond_maturity: datetime.date, strike: float, kind: OptionKind
strip_from_callable	strip_from_callable(instrument: Instrument, valuation: datetime.date) — The co-terminal swaption strip a callable implies: one (expiry, end) per exercisable call, each running to the bond's maturity.
zero_bond_option	`zero_bond_option(model: HullWhite, curve: DiscountCurve, expiry: datetime.date, bond_maturity: datetime.date, strike: float, kind: OptionKind

helixio.products

Product constructors — every contract the library can build, and the two handles the bond-linked products share. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
AssetSwapKind	AssetSwapKind — How an asset swap is packaged: ParPar or Proceeds.
BarrierKind	BarrierKind — Where a single barrier sits and what touching it does. Every barrier_kind takes the member or its string; a member is not its string.
BondFuture	BondFuture — A bond future: a delivery date and its resolved deliverable basket.
BondOptionEngine	BondOptionEngine — Which model prices a bond option: the bond's YieldVol or HullWhite. Instrument.engine() reads the code back.
CapFloorKind	CapFloorKind — A Cap or a Floor.
CdsOptionStyle	CdsOptionStyle — What a default before a CDS option's expiry does to it: SingleName knocks out, FrontEndProtection settles it as the payer's protection, Index is an index option with its exercise price.
CdsStrikeType	CdsStrikeType — How a CDS option's strike is quoted: Spread, or Price per unit notional the holder enters the index at.
CmeMaturityRounding	CmeMaturityRounding — How a CME contract group rounds a deliverable's maturity: to the Month (the 2-, 3- and 5-year contracts) or the Quarter (the 10-year and bond contracts).
ExerciseStyle	ExerciseStyle — When an option on a future may be exercised: European or American.
FixedRateBond	FixedRateBond — A fixed-rate bullet bond — the underlying of the bond-linked products.
OptionKind	OptionKind — An option's right: a Call or a Put. Every option-pricing kind takes the member or its string; a member is not its string.
PremiumStyle	PremiumStyle — How an option on a future settles its premium: FuturesStyle (margined daily, Eurex and ICE) or Paid up front (CBOT).
ProductBuilder	ProductBuilder — A swap draft: a template's swap with every term defaulted, refined by verbs, struck by a stated rate or at par against a market. Template.swap(trade_date) opens one: effective at the template's spot from the trade date, ten years long, 10,000,000 notional, receiving fixed, and no fixed rate. Frozen: every with_* returns a new draft. A draft is not an instrument — it has no npv — and build() on one with no rate raises ValueError naming with_fixed_rate and at_par.
RepackEngine	RepackEngine — How a repack note's gap is priced: Independent of rates, or Correlated through the issuer's Gaussian intensity.
RepackRole	RepackRole — Who holds a booked repack note: the bank's swap facing the SPV (SwapCounterparty) or the notes per unit notional (Noteholder).
SwaptionEngine	SwaptionEngine — Which model prices a swaption: the market's vol Surface or HullWhite. Instrument.engine() reads the code back.
SwaptionKind	SwaptionKind — Whether a swaption's holder pays (Payer) or receives (Receiver) the fixed leg on exercise. The swaption constructors' kind takes the member or its string.
SwaptionSettlement	SwaptionSettlement — How a swaption settles on exercise: into the swap (Physical) or for its value (Cash).
ValuationTrigger	ValuationTrigger — A repack note's valuation trigger: terminate when the collateral's market value falls below level of notional on a monitoring date, selling it liquidation_lag_days later.
asset_swap	`asset_swap(bond: Instrument, start: datetime.date, index: str, float_frequency: Frequency
basket_total_return_swap	`basket_total_return_swap(constituents: list[tuple[FixedRateBond, float, float]
bermudan_swaption	`bermudan_swaption(underlying: Instrument, exercise_dates: list[datetime.date], *, strike: float, kind: SwaptionKind
bond_forward	bond_forward(bond: FixedRateBond, *, notional: float, strike: float, forward_date: datetime.date, settlement_date: datetime.date, repo_key: str, short: bool=False, dirty_strike: bool=False) — A forward on notional of bond at a clean strike (dirty when dirty_strike), financed on the repo curve under repo_key.
bond_future	`bond_future(delivery: datetime.date, basket: list[tuple[FixedRateBond, float, str
bond_future_option	`bond_future_option(contract: str, expiry: datetime.date, *, strike: float, currency: str, premium_style: PremiumStyle
bond_future_option_from_template	`bond_future_option_from_template(code: str, year: int, month: int, *, strike: float, kind: OptionKind
bond_future_position	bond_future_position(future: BondFuture, *, contracts: float, contract_size: float, traded_price: float, short: bool=False) — A position in future: contracts contracts, each delivering contract_size of face, struck at traded_price per 100. Unlike bond_future, this is an Instrument and joins a book. Its value is side · contracts · (contract_size / 100) · (model − traded), undiscounted — a daily-margined future settles variation margin — where the model price comes off the cheapest-to-deliver's forward. The basket is the future's, already resolved: no security master is consulted at pricing time, and each row carries on its own repo cascade — its key, its repo group, its currency, then the discount curve.
bond_option	`bond_option(bond: FixedRateBond
bond_total_return_swap	`bond_total_return_swap(bond: FixedRateBond, *, notional: float, initial_price: float, reset_schedule: list[datetime.date], repo_key: str, paying_total_return: bool=False, funding_margin: float
callable_bond	`callable_bond(bond: FixedRateBond, schedule: list[tuple[datetime.date, float, CallKind
callable_loan	`callable_loan(loan: Instrument, schedule: list[tuple[datetime.date, float, CallKind
callable_swap	callable_swap(swap: Instrument, exercise_dates: list[datetime.date], *, callable_by: str='holder') — swap — a vanilla or overnight swap — cancellable on exercise_dates by callable_by: "holder" (a right bought) or "counterparty" (a right sold). Valued as the swap plus a Bermudan struck at its fixed rate on the Hull-White lattice, so its market needs the model pinned.
cdo_tranche	`cdo_tranche(family: str, trade_date: datetime.date, series: int, tenor_years: int, *, pool_notional: float, attach: float, detach: float, spread: float, buys_protection: bool=True, version: int=1, index_factor: float
cme_conversion_factor	`cme_conversion_factor(coupon: float, maturity: datetime.date, delivery_month_start: datetime.date, rounding: CmeMaturityRounding
cms_swap	`cms_swap(template: str, tenor: str, schedule: Schedule, day_count: str
credit_default_swap	`credit_default_swap(trade_date: datetime.date, reference: str, currency: str, tenor_years: int
credit_default_swap_option	`credit_default_swap_option(underlying: Instrument, expiry: datetime.date, *, strike: float, kind: SwaptionKind
credit_linked_note	`credit_linked_note(trade_date: datetime.date, reference: str, currency: str, tenor_years: int, *, notional: float, coupon: float, issued: bool=False, fixed_recovery: float
credit_linked_swap	`credit_linked_swap(reference: str, currency: str, legs: list[tuple[Leg, LegRole
curve_pin	curve_pin(currency: str, date: datetime.date, reading: str='discount_factor') — A curve's own reading at a date as an instrument — discount_factor or zero_rate of the currency's discount curve — so a curve node can be pinned directly: Rung.priced(date, curve_pin(...), value, 1.0).
equity_basket_total_return_swap	`equity_basket_total_return_swap(constituents: list[tuple[str, float, float]], currency: str, *, reset_schedule: list[datetime.date], paying_total_return: bool=False, funding_margin: float
equity_option	`equity_option(name: str, currency: str, *, strike: float, expiry: datetime.date, kind: OptionKind
equity_total_return_swap	`equity_total_return_swap(name: str, currency: str, *, quantity: float, initial_price: float, reset_schedule: list[datetime.date], paying_total_return: bool=False, funding_margin: float
eurex_btp_conversion_factor	eurex_btp_conversion_factor(coupon: float, interest_start: datetime.date, first_coupon: datetime.date, maturity: datetime.date, delivery: datetime.date, notional_coupon: float=0.06) — Eurex conversion factor for a semi-annual BTP into the Euro-BTP future, rounded to 7dp: the EUR formula on half-year periods, each payment that rolls off a weekend or TARGET holiday discounted the further fraction of a period it rolls. Rates are decimals.
eurex_chf_conversion_factor	eurex_chf_conversion_factor(coupon: float, maturity: datetime.date, delivery: datetime.date, notional_coupon: float) — Eurex conversion factor for a CHF Swiss Confederation bond into the CONF future: whole years to maturity and full months to the next coupon, as Eurex's CHF document states it, unrounded. Rates are decimals.
eurex_conversion_factor	eurex_conversion_factor(coupon: float, interest_start: datetime.date, first_coupon: datetime.date, maturity: datetime.date, delivery: datetime.date, notional_coupon: float=0.06) — Eurex conversion factor for an annual-coupon EUR bond, rounded to 6dp. Rates are decimals.
european_swaption	`european_swaption(underlying: Instrument, expiry: datetime.date, *, strike: float, kind: SwaptionKind
fee	fee(currency: str, payment_date: datetime.date, *, amount: float) — A standalone fee: amount in currency on payment_date, positive received and negative paid, discounted on the currency's cash collateral — the way an upfront is attached to a structure. Its cashflow table is one Fee row worth its npv.
fixed_rate_bond	`fixed_rate_bond(currency: str, issue: datetime.date, maturity: datetime.date, *, coupon: float, frequency: Frequency
floating_rate_note	`floating_rate_note(index: str, issue: datetime.date, maturity: datetime.date, *, margin: float, face: float, gearing: float
fx_forward	`fx_forward(base: str, quote: str, *, base_amount: float, contract_rate: float
fx_option	`fx_option(base: str, quote: str, *, notional_base: float, kind: OptionKind
fx_swap	fx_swap(near: Instrument, far: Instrument) — An FX swap: a near forward and an opposite far forward on one pair.
ice_gilt_conversion_factor	ice_gilt_conversion_factor(bond: FixedRateBond, delivery_month_start: datetime.date, notional_coupon: float=0.04) — ICE Long Gilt conversion factor: the clean price per unit nominal at the notional coupon on the delivery month's first day, under gilt conventions, rounded to 7dp.
index_credit_default_swap	`index_credit_default_swap(family: str, trade_date: datetime.date, series: int, tenor_years: int, *, notional: float, buys_protection: bool=True, version: int=1, index_factor: float
inflation_linked_bond	`inflation_linked_bond(currency: str, index: str, *, base_index: float, real_coupon: float, lag_months: int, frequency: Frequency
interest_rate_cap_floor	`interest_rate_cap_floor(index: str, effective: datetime.date, termination: datetime.date, *, notional: float, strike: float, kind: CapFloorKind
loan	`loan(schedule: Schedule, currency: str, *, notional: float, fixed_rate: float
meeting_ois	`meeting_ois(template: str
nth_to_default_swap	`nth_to_default_swap(trade_date: datetime.date, entities: list[str], n: int, currency: str, tenor_years: int, *, notional: float, spread: float, correlation: float
payment_in_kind_bond	`payment_in_kind_bond(currency: str, issue: datetime.date, maturity: datetime.date, *, rate: float, frequency: Frequency
repack_note	`repack_note(asset_swap: Instrument, issuer: str, *, notional: float, repack_role: RepackRole
straddle	straddle(first: Instrument, second: Instrument) — Two options of one strategy booked as one product — a straddle, or a strangle when the strikes differ: FX options on one pair or European swaptions in one currency. Worth the options' sum; Instrument.implied_vol quotes it on one flat vol, the way a straddle is quoted. Options of two strategies raise ValueError.
structured_note	`structured_note(leg: Leg, *, face: float, issuer: str
swap_from_legs	swap_from_legs(fixed: Leg, floating: Leg) — A fixed-versus-floating swap from two legs, booked as one trade. The currency and index are read off the coupons and the collateral is the legs' shared discount key. Legs on two keys raise ValueError; legs that are not a swap (a coupon on the wrong leg, two indices, two currencies, one side) raise PricingError naming why.
vanilla_swap	`vanilla_swap(currency: str, effective: datetime.date, termination: datetime.date, *, fixed_rate: float, index: str, notional: float, pays_fixed: bool=False, accrual_compounding: AccrualCompounding
weekly_bond_future_option_from_template	`weekly_bond_future_option_from_template(code: str, expires_on: datetime.date, *, strike: float, kind: OptionKind
yoy_inflation_cap_floor	`yoy_inflation_cap_floor(currency: str, index: str, base_date: datetime.date, maturity: datetime.date, *, notional: float, strike: float, kind: CapFloorKind
yoy_inflation_swap	`yoy_inflation_swap(currency: str, index: str, base_date: datetime.date, maturity: datetime.date, *, notional: float, fixed_rate: float, lag_months: int=3, receiver: bool
zero_coupon_bond	`zero_coupon_bond(currency: str, calc_method: int, settlement: datetime.date, maturity: datetime.date, *, face: float, discount_yield: float, day_count: str
zero_coupon_inflation_cap_floor	`zero_coupon_inflation_cap_floor(currency: str, index: str, base_date: datetime.date, maturity: datetime.date, *, notional: float, strike: float, kind: CapFloorKind
zero_coupon_inflation_swap	`zero_coupon_inflation_swap(currency: str, index: str, base_date: datetime.date, maturity: datetime.date, *, notional: float, fixed_rate: float, lag_months: int=3, receiver: bool

helixio.rates

Linear-rates readings: settlement, futures price and its convexity, the fair forward rate, and CMS rates and options. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
cms_coupon_rate	`cms_coupon_rate(market: MarketContext, template: str, tenor: str, fixing: datetime.date, payment: datetime.date, mean_reversion: float, *, gearing: float=1.0, spread: float=0.0, cap: float
cms_option	`cms_option(market: MarketContext, template: str, tenor: str, fixing: datetime.date, payment: datetime.date, mean_reversion: float, *, strike: float, kind: OptionKind
cms_rate	cms_rate(market: MarketContext, template: str, tenor: str, fixing: datetime.date, payment: datetime.date, mean_reversion: float) — The CMS rate on the swap index template at tenor, fixing on fixing and paid on payment: the index swap's forward and the rate convexity-adjusted by the linear terminal swap rate model at mean_reversion, as (forward, rate).
cms_spread_coupon_rate	`cms_spread_coupon_rate(market: MarketContext, template: str, tenor: str, minus_tenor: str, fixing: datetime.date, payment: datetime.date, mean_reversion: float, *, correlation: float
cms_spread_option	`cms_spread_option(market: MarketContext, template: str, tenor: str, minus_tenor: str, fixing: datetime.date, payment: datetime.date, mean_reversion: float, *, correlation: float
fair_forward_rate	fair_forward_rate(instrument: Instrument, market: MarketContext) — The forward rate covered interest parity implies for an FX forward.
fra_settlement	fra_settlement(instrument: Instrument, market: MarketContext) — The FRA's settlement amount — the discounted difference between the projected and the struck rate on the notional.
futures_convexity	futures_convexity(instrument: Instrument, market: MarketContext) — The future's convexity adjustment as a rate: its futures rate less the forward rate of the same contract with no adjustment.
futures_price	futures_price(instrument: Instrument, market: MarketContext) — The future's fair price, 100 − rate, convexity-adjusted as the contract says.
hull_white_convexity_bias	hull_white_convexity_bias(futures_price: float, t: float, maturity: float, sigma: float, mean_reversion: float) — The Hull-White convexity bias: the futures rate less the forward under Hull-White.

helixio.risk

Risk measures, P&L prediction, attribution and reconciliation. The measures a desk names — DV01, PAR_LADDER, CS01, INF01 — are filed by asset class: risk.rates, risk.credit, risk.fx, risk.inflation and risk.equity, with risk.NPV beside them. risk.catalogue() lists every one; Book.measures lists the ones a book can answer. Any other point of the grammar is a risk.Measure, built with risk.delta from typed parts — Axis, Basis, Aggregation and Scale. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
Aggregation	Aggregation — How a sensitivity is collapsed for reporting: one row (Total), a row per tenor bucket, per curve (ByCurve), or per contribution (Ladder).
Axis	Axis — What a sensitivity is to: the risk axes a report and a frame read. Every axis parameter takes the member or its string ("rate", "security_spread"); a member is not its string.
Basis	Basis — Whose quote a sensitivity is expressed against: the curve nodes' own (Zero) or the calibrating instruments' (Par).
ExplainReport	ExplainReport — The step-revaluation explain: the prints that became known first, then one leg per axis, telescoping exactly.
Measure	Measure — A quantity a report asks for: Measure.Npv, or a first-order sensitivity on an axis against a basis, collapsed by an aggregation, in a scale — what the grammar spells delta:<axis>[:<basis>[:<aggregation>]][:<scale>]. A value beside the string, never instead of it: code() and str print the grammar, Measure(spelling) parses it, delta(...) builds one from typed parts, and Book.report takes either. Equal and hashable by value; repr reads back.
NPV	NPV: Preset
PredictedPnl	PredictedPnl — The predicted explain: first order from risk plus one second-order pass.
Preset	Preset — A named risk measure — DV01, PAR_LADDER, CS01 — and the scale it reports in.
Reconciliation	Reconciliation — The two explains aligned by axis.
ResetPnl	ResetPnl — The reset step read per print: what each print the ending market holds and the starting market does not made against the forecast it replaced.
Scale	Scale — The unit a sensitivity is reported in: Scale.Unit (per unit move of the quote), Scale.Bp, Scale.Percent, Scale.VolPoint, or Scale.custom(factor). Spelled unit, bp, pct, volpt or x<factor>.
Scales	Scales — A book's default scale per quantity kind: rate, spread, vol, recovery, correlation, fx.
ShiftType	ShiftType — Whether a scenario leg moves its inputs relatively, x·(1 + s), or absolutely, x + s. Unset, each input keeps its own convention: curves absolute, FX spots and vols relative. Scenario's builders take the member or its string.
catalogue	catalogue — Every preset the library names, as records: name, class, measure, scale, how, requires.
credit	credit: types.ModuleType
default_order	default_order — The axis order explain uses when given none.
delta	`delta(axis: Axis
equity	equity: types.ModuleType
explain	`explain(book: Book, before: MarketContext, after: MarketContext, order: list[Axis
fx	fx: types.ModuleType
inflation	inflation: types.ModuleType
predicted_pnl	predicted_pnl(book: Book, before: MarketContext, after: MarketContext) — The predicted explain of book between two markets of the same shape, a print the after market alone holds being the reset step rather than a difference of shape. Raises ValueError where after differs from before by more than its parameters — a market under a scenario, whose shock the risk vector has no coordinate for; explain attributes such a move.
rates	rates: types.ModuleType
reconcile	reconcile(predicted: PredictedPnl, explained: ExplainReport) — The two explains aligned by axis.
reset_pnl	reset_pnl(book: Book, before: MarketContext, after: MarketContext) — The reset P&L of book from before to after: one row per print after holds and before does not, or holds at another value, each the exact revaluation from the forecast it replaced to the print, beside the move and the book's sensitivity to it. Raises ValueError where the two markets are valued on different days, or differ by anything other than the prints.

helixio.templates

Convention templates: the registered ones by code, the whole registry as a table, and the swap and cross-currency templates a caller states. A template drafts its products through its own methods (get("USD-SOFR-OIS").vanilla_swap). Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
catalogue	catalogue — Every registered template: code (what template takes), family (as Template.family reads it), and the registry's group and name.
cross_currency	`cross_currency(name: str, leg1: Index
get	get(code: str) — The registered template under code, as a value. Named template in Python. The Rust name differs because this module already has a crate-private template returning the bare AnyTemplate, which every code-keyed constructor resolves through.
swap	`swap(name: str, index: Index
swap_conventions	`swap_conventions(effective: datetime.date, termination: datetime.date, *, template: str

helixio.vols

Volatility surfaces, the caplet strippers, and the delta/strike conversions an FX quote is stated in. Re-exports from the native extension and defines nothing: a behaviour defined here would be a behaviour with no Rust twin.

Function	Signature
CpiVolSurface	CpiVolSurface — A zero-coupon CPI option vol surface over expiry x annualised zero-coupon strike, pinned per price index: lognormal is Black on the forward index ratio I(T)/I(T0) at strike (1+k)^tau, normal is Bachelier on that ratio (the vol in ratio units). Read at the time from the first of the month of (valuation - lag) to maturity - lag, ACT/365F.
CreditVolSurface	CreditVolSurface — The Black volatility of a credit name's forward CDS spread by option expiry, in years: linear in total variance between quoted expiries, flat beyond them.
DeltaConvention	DeltaConvention — How an FX delta is quoted: Spot or Fwd, each plain or premium-adjusted (PaSpot, PaFwd). Every delta_convention parameter takes the member or its string ("spot", "forward_premium"). A member is not its string.
FutureOptionVolSurface	FutureOptionVolSurface — A listed bond future's option vol surface over listed expiry dates x strikes per 100 face, pinned per contract: lognormal is a Black-76 price vol, normal a Bachelier price vol in points per year. Sticky-strike: linear in vol between strikes, linear in total variance between expiries, flat beyond every edge; time is day_count (ACT/365F unless stated) from reference.
FxVolSmile	FxVolSmile — One expiry's smile: (quote, vol) nodes, the quote spelled as the market spells it — "25P", "ATM", "25C" — held from the lowest strike's quote to the highest's.
FxVolSurface	FxVolSurface — An FX volatility surface: one smile per expiry.
RateVolSurface	RateVolSurface — A rate volatility surface on an expiry x tenor grid, optionally smiled.
SabrFit	SabrFit — A fitted SABR surface and the diagnostics of each slice that built it.
SabrFormula	SabrFormula — The expansion a SABR smile is read under: Hagan's lognormal (HaganLognormal), Hagan's normal (HaganNormal), or the normal beta = 0 form that reads a negative forward (NormalBetaZero). Every formula parameter takes the member or its string.
SabrSpec	SabrSpec — How a grid is fitted to SABR: the formula, beta and the shift, all stated, and the acceptance — the RMS vol error as a fraction of a slice's mean quote — with the Halton restarts a slice may spend reaching it.
SabrVolSurface	SabrVolSurface — A SABR rate smile over expiry x tenor: ATM vol, rho and nu at each node, beta and the shift stated once, alpha implied at each read from the ATM vol at the read's own forward. Pinned with with_swaption_vols or with_cap_vols beside a grid.
StrikeAxis	StrikeAxis — What a cube's strikes measure: an Absolute rate, or a SpreadToAtm over the forward. Every strike_axis parameter takes the member or its string.
StripScheme	StripScheme — How caplet vols are stripped from cap quotes: ConstantBetweenQuotes or one vol PerCaplet. The strippers' scheme takes the member or its string.
VolConvention	VolConvention — How a rate volatility is quoted: Normal (basis-point) or Lognormal. Every vol_convention parameter takes the member or its string.
YoyVolSurface	YoyVolSurface — A year-on-year inflation optionlet vol surface over expiry x absolute YoY strike, pinned per price index: normal or lognormal, a lognormal one optionally displaced (a displacement of one prices on 1 + rate). Each optionlet reads it at the time from the first of the month of (valuation - lag) to its period end - lag, ACT/365F.
alpha_from_atm	`alpha_from_atm(formula: SabrFormula
atm_delta_neutral_strike	`atm_delta_neutral_strike(forward: float, vol: float, expiry: float, delta_convention: DeltaConvention
calibrate_sabr	calibrate_sabr(grid: RateVolSurface, forwards: list[list[float]], spec: SabrSpec) — Fits SABR to every node of the smiled grid, each at its forward — forwards[expiry][tenor] — under spec.
calibrate_sabr_with_atm	calibrate_sabr_with_atm(atm: RateVolSurface, atm_forwards: list[list[float]], cube: RateVolSurface, cube_forwards: list[list[float]], spec: SabrSpec) — Fits SABR on a dense ATM matrix with a sparse smile cube: ATM vol from the matrix at every node, rho and nu fitted at the cube's nodes and read onto the matrix's. Every cube node must be a matrix node.
caplet_forwards	caplet_forwards(market: MarketContext, index: str, effective: datetime.date, termination: datetime.date, first_caplet_excluded: bool=True) — Each caplet's expiry (years) and forward for the cap on the term index, filtered to the rows the caplet stripper strips.
caplet_smile	`caplet_smile(index: str, effective: datetime.date, terminations: list[datetime.date], strikes: list[float], vols: list[list[float]], market: MarketContext, vol_convention: VolConvention
caplet_vols	`caplet_vols(index: str, effective: datetime.date, quotes: list[tuple[datetime.date, float]], market: MarketContext, vol_convention: VolConvention
fx_delta	`fx_delta(forward: float, strike: float, vol: float, expiry: float, df_base: float, delta_convention: DeltaConvention
sabr_vol	`sabr_vol(formula: SabrFormula
strike_from_delta	`strike_from_delta(target: float, forward: float, vol: float, expiry: float, df_base: float, delta_convention: DeltaConvention
swaption_forwards	`swaption_forwards(market: MarketContext, template: str, expiries: list[Period

Classes

Book — reference

A collection of trades valued together, carrying the market its verbs value against.

Method	Signature
add	add(self, id: str, instrument: Instrument, quantity: float) — Books quantity of instrument under id; the new book carries this book's market.
extend	extend(self, trades: list[tuple[str, Instrument, float]]) — Books every (id, instrument, quantity) of trades at once; the new book carries this book's market. The form for a book of many trades: add copies the book per call, so booking thousands of trades one add at a time is quadratic; this copies it once. A non-finite quantity is refused naming its trade, and nothing is booked.
attach_market	`attach_market(self, market: MarketContext
market_context	market_context(self) — The market this book carries, or None.
fetch_market_data	fetch_market_data(self, as_of: datetime.date) — Fetches what this book reads at as_of from its market's data source and keeps it — the explicit form of the fetch every verb makes, as the Rust book's fetch_market_data. Raises SnapshotError (or the source's own exception) on a refusal and leaves the market as it was.
fetch_report	fetch_report(self) — What the last fetch asked for and got: family, key, status.
recipe_ask	`recipe_ask(self, as_of: datetime.date
demand_for	demand_for(self, as_of: datetime.date, recipes: list[RecipeSpec]=...) — recipes kept as the source's recipes for as_of, the market moved there, and that date's demand — empty where nothing is missing.
install	install(self, demand: Demand, data: MarketData) — data built into the market at the demand's date and kept; fetch_report() written, on a refusal as well.
npv	`npv(self, *, as_of: datetime.date
npv_by_trade	`npv_by_trade(self, *, as_of: datetime.date
risk	`risk(self, *, as_of: datetime.date
from_fpml	`from_fpml(cls, documents: list[str
reporting_in	reporting_in(self, code: str) — The book reporting in code: every trade's value converted to that currency at the market's spot.
through	through(self, lens: Lens) — The book restricted to the trades lens admits.
trades	trades(self) — The book's trades as (id, instrument, quantity), in booking order.
report	`report(self, measures: list[Preset
scaled	scaled(self, scales: Scales) — The book reporting each quantity kind in scales wherever a measure states no scale of its own.
available_measures	`available_measures(self, *, as_of: datetime.date
market_vega	`market_vega(self, fit: HullWhiteFit, *, as_of: datetime.date
under	`under(self, scenario: Scenario, *, as_of: datetime.date
credit_bumps	`credit_bumps(self, kind: str, bump: float=0.01, *, as_of: datetime.date
implied_vol	`implied_vol(self, premium: float
explain_pnl	`explain_pnl(self, as_of1: datetime.date, as_of2: datetime.date, order: list[Axis
predicted_pnl	predicted_pnl(self, as_of1: datetime.date, as_of2: datetime.date) — The predicted explain within one day, on the terms of explain_pnl; across days it is refused.
reset_pnl	reset_pnl(self, as_of1: datetime.date, as_of2: datetime.date) — The reset P&L within one day, on the terms of explain_pnl; across days it is refused.

Calendar — reference

A business-day calendar, resolved from a lookup expression. The expression is a business-centre code ("GBLO") or a comma-separated list joined into the union of its members' holidays ("GBLO,EUTA"). "EVERYDAY" names the calendar on which every day is a business day and "WEEKDAYS" the one on which only weekends are not. A value date that must also be good on a second calendar is stated with Calendar.settle's settlement. Calendars are immutable. No operation amends the calendar in hand: there is no add_holiday, no remove_holiday, and nothing here changes what any other holder resolves for a centre. Construction is a different thing from amendment, and is permitted: from_holidays builds a calendar from an explicit holiday set, and amended derives one from a calendar in hand. Both return a new value, register nothing, and leave every other holder's resolution unchanged.

Method	Signature
from_holidays	`from_holidays(name: str, holidays: list[datetime.date], weekend: list[str]
amended	`amended(self, closing: list[datetime.date]
join	`join(calendars: list[Calendar], rule: JointCalendarRule
expression	expression(self) — The expression this calendar was resolved from.
name	name(self) — The resolved calendar's own name (diagnostic).
is_weekend	is_weekend(self, date: datetime.date) — Whether date falls on the weekend of this calendar's week.
is_holiday	is_holiday(self, date: datetime.date) — Whether date is closed for a reason beyond the weekend. A listed closure, not a Saturday: a weekend day carrying no listed closure is not a holiday, so is_weekend and is_holiday do not overlap. Selects exactly the dates holidays returns.
is_business_day	is_business_day(self, date: datetime.date) — Whether date is a good business day.
adjust	`adjust(self, date: datetime.date, business_day_convention: BusinessDayConvention
settle	`settle(self, date: datetime.date, n: int, unit: str='business_days', settlement: Calendar
advance	`advance(self, date: datetime.date, tenor: Period
end_of_month	end_of_month(self, date: datetime.date) — The last business day of date's month. The calendar month end is the free function last_day_of_month, which is blind to holidays.
is_end_of_month	is_end_of_month(self, date: datetime.date) — Whether date is its month's last business day. Strict: a trailing weekend day is not, though it does anchor the end-of-month roll.
is_month_end_anchor	is_month_end_anchor(self, date: datetime.date) — Whether date anchors the end-of-month roll — on or after its month's last business day, so a month-end falling on a Saturday still fires.
next_business_day	next_business_day(self, date: datetime.date) — The first business day on or after date.
previous_business_day	previous_business_day(self, date: datetime.date) — The first business day on or before date.
add_business_days	add_business_days(self, date: datetime.date, n: int) — Steps date by n good business days. Negative looks backward; zero returns date unchanged even where it is itself a holiday. This is the primitive a settlement or fixing lag is built on.
business_days_between	`business_days_between(self, start: datetime.date, end: datetime.date, *, include_first: bool
holidays	holidays(self, start: datetime.date, end: datetime.date, include_weekends: bool=False) — The non-business days in the inclusive range, ascending. Weekends are included only when asked for. Both endpoints are required: a calendar spans a century and an unbounded listing is not a useful answer.
business_days	business_days(self, start: datetime.date, end: datetime.date) — The business days in the inclusive range, ascending.

CalibrationError

A calibration could not solve or verify its ladder.

ConvergenceError

A calibration or fit ran out of steps, sweeps or iterations.

Counterparty — [reference

A trading counterparty: its acronym and the CSA governing its trades. The CSA is named by its overnight index code ("EUR-ESTR"), as with_csa accepts one; a code naming no overnight index raises ValueError. A draft facing it (ProductBuilder.with_counterparty) discounts under the CSA: a USD trade under a EUR CSA on USD-CSA-EUR.

Method	Signature
acronym	acronym(self) — The counterparty's short identifier.
csa	csa(self) — The CSA's overnight index code.
collateral_currency	collateral_currency(self) — The currency the CSA posts collateral in.
collateral_for	collateral_for(self, currency: str) — The discount key a trade in currency facing this counterparty declares: the currency itself where it is the CSA's, "<ccy>-CSA-<csa>" otherwise.

CurveError

A curve could not be built or could not answer a query.

Demand — reference

What a book needs from outside to price on a market, as MarketContext.demand derives it and a source's fetch reads it.

Method	Signature
asks	asks(self) — Whether this demand asks a source for any strip, fixing or spot.
as_of	as_of(self) — The date the market is as of.
reporting	reporting(self) — The currency the book reports in, where it has one.
keys	keys(self) — The collateral keys the snapshot builds, in build order.
strips	strips(self) — key and template, one row a quote strip.
fixings	fixings(self) — series and date, one row a print a valuation reads.
fx	fx(self) — The spots, each in its conventional quotation (EUR/USD).
unresolved	unresolved(self) — curve and reason, one row a curve no recipe builds.
out_of_scope	out_of_scope(self) — What the book declares that sources do not serve yet.
recipe_ask	recipe_ask(self) — The keys a recipe source is asked about.

HelixError — reference

Base for every failure originating in the helixrs core.

Index — reference

An interest-rate, price or FX index: its conventions and the rate it quotes. Resolved from a registry code or display name, or built from conventions for a market the registry does not carry. Building one registers nothing. An accessor a kind does not carry raises ValueError naming the kind: a price index has no tenor, and saying so beats returning None.

Method	Signature
codes	codes — Every registered index, as (kind, name, code). The set a rejection names, obtainable rather than only readable inside an error message. name is the index's display name — what Index.name() returns and what its fixings are stored under. The core's own table carries the accessor name in that position, which is a Rust identifier no Python caller can use for anything, so each row is resolved to report the name a caller can actually match on.
ibor	`ibor(name: str, currency: str, tenor: str, day_count: str
inflation	`inflation(name: str, region: str, currency: str, publication_frequency: Frequency
overnight	`overnight(name: str, currency: str, day_count: str
fx	`fx(base: str, quote: str, fixing_calendar: Calendar, fixing_lag_days: int, settlement: Calendar
pair	pair(self) — The pair an FX index names, as BASEQUOTE.
value_date	value_date(self, fixing_date: datetime.date) — The value date an FX fixing settles on. FX indices only.
kind	kind(self) — Which kind of index this is: "Overnight", "Ibor", "Fx" or "Price".
name	name(self) — The index's display name — the key its fixings are stored under.
code	code(self) — The registry code this index resolved under. A constructed index has none, and says so rather than inventing one.
currency	currency(self) — The ISO 4217 currency the index quotes in.
tenor	tenor(self) — The index's tenor, as a tenor string ("3M"). Term indices only.
day_count	day_count(self) — The index's accrual day count.
fixing_calendar	fixing_calendar(self) — The calendar the index's fixings are published on. The same calendar object the engine resolves, so a caller stepping dates on it steps them the way the index's own arithmetic does.
fixing_lag_days	fixing_lag_days(self) — The fixing lag, in good business days.
business_day_convention	business_day_convention(self) — The index's conventional business-day convention.
end_of_month	end_of_month(self) — The index's conventional end-of-month rule.
region	region(self) — The region a price index covers.
publication_frequency	publication_frequency(self) — How often a price index publishes, as a frequency code (1M for a monthly CPI). Refused for a rate index, which fixes daily.
observation_lag_months	observation_lag_months(self) — A price index's availability lag, in whole months.
reference_month	reference_month(self, date: datetime.date) — The first day of the lagged reference month for date. The date calibration.inflation names for a rung's pillar. Price indices only.
interpolation	interpolation(self) — How a price index maps a coupon date onto its monthly prints.
fixing_date	fixing_date(self, accrual_start: datetime.date) — The fixing date for an accrual starting on the date; for an FX index the date is the value date and the answer is its spot fixing date.
maturity_date	maturity_date(self, value_date: datetime.date) — The end of the window a rate valued on value_date covers: the value date advanced by the index's tenor under its own conventions. Not the coupon's accrual end: a schedule's business-day convention may have moved a boundary, and the index still quotes its tenor.
forecast	forecast(self, curve: DiscountCurve, value_date: datetime.date) — The rate this index quotes for a period starting on value_date, projected off curve. The simple forward over the index's own window, on the index's own day count — the same expression the engine applies to an unfixed coupon, so this reproduces the rate a priced instrument reports. Not DiscountCurve.forward_rate, which is continuously compounded on ACT/365 and is a property of the curve rather than of any index. For an ACT/360 index the two differ. A price or FX index refuses: each forecasts through a different seam.

Instrument

A tradable instrument.

Method	Signature
product	product(self) — The product family's name.
engine	engine(self) — Which model prices this instrument, where it chooses one: a European swaption's surface/hull_white, a bond option's yield_vol/hull_white; None otherwise.
underlying	underlying(self) — The instrument an option is written on — a swaption's swap, a bond option's bond — or None.
market_data_needs	market_data_needs(self) — The market data this instrument needs, as identifiers only. A dictionary of strings — no numbers, because a declaration carries none. Every value is the identifier's canonical spelling, the one the vocabulary parses back to the same identifier — never debug formatting, which nothing round-trips.
fixings_needed	fixings_needed(self, valuation: datetime.date) — The published fixings a valuation on valuation will read, as (index, date) pairs. A query over the instrument's own resets, not a valuation: it takes no market, and the date decides only which resets are already past — those are the ones a fixings store must hold, and the only ones reported, because a reset still to come is projected off a curve. Every index spelling is the canonical store key, so a reported pair goes straight into MarketContext.with_fixings unretyped. An instrument with no floating reset reports an empty list.
contract_dates	contract_dates(self) — The contract dates this instrument resolved to, as (name, date) pairs. These are exactly the dates a stated constructor takes, so a product built through the derived form can be read back and rebuilt through the stated one — which is what makes the two forms checkable against each other rather than merely both present. Empty for a product with no stated form: the listing names what a caller could state, not every date a product holds. final_payment_date remains the accessor for a calibration pillar.
diagnostics	diagnostics(self, market: MarketContext) — What this product's valuation resolved to on market: a bond option (yield-vol engine; the Hull-White engine has no such decomposition and raises), a bond future option, an FX option, a CDS or a credit-linked swap, each as its own diagnostics class. Any other product raises ValueError naming diagnostics.
with_hull_white_convexity	with_hull_white_convexity(self) — This rate future with its convexity modelled under Hull-White on the market's parameters for its currency: a term contract by the Hull-White convexity bias, a compounded overnight one (SR3, SONIA) in arrears from its first unprinted day, an averaged one (SR1) print by print. Any other product raises ValueError naming it.
final_payment_date	final_payment_date(self) — The date of the instrument's final payment — the pillar a calibration rung on it belongs to — or None for a product no ladder is built from.
latest_relevant_date	latest_relevant_date(self) — The latest date the instrument reads: the latest of its payment dates and of its IBOR coupons' fixing-window ends. None for a product with no legs.
legs	legs(self) — The instrument's legs, in the order it declares them, or None for a product that carries no coupon schedule. Each carries the discount key this instrument declares, so a leg taken out of an instrument values on the same curve it valued on inside it. Two legs the instrument declares that a caller sums must therefore come to the instrument's own present value, and a test asserts they do. A cross-currency swap's legs are on the sides the trade has them, each discounted on its own currency's collateral, so each values to its leg_npvs row in its own currency. A resetting leg comes back for its schedule and refuses to be valued: its notionals are forward FX.
npv	npv(self, market: MarketContext) — The instrument's present value against market, in npv_ccy(). The passive instantiation of the same seam a book values through — lift, view, resolve the declaration, price — with the interpreter lock released for the duration, as Book.npv releases it.
implied_vol	`implied_vol(self, market: MarketContext, premium: float
npv_ccy	npv_ccy(self) — The currency npv is in: a cash-settled forward's (an NDF's) settlement currency, a physical one's quote currency, a cross-currency swap's quoted leg's whichever side is paid (a non-deliverable one's settlement currency).
leg_npvs	`leg_npvs(self, market: MarketContext, pnl_ccy: str
par_rate	par_rate(self, market: MarketContext) — The par rate — the fixed rate, coupon or forward that values the instrument at zero.
par_spread	par_spread(self, market: MarketContext) — The par spread — the margin over the floating side that values the instrument at zero, where the product defines one.
cashflow_records	cashflow_records(self, market: MarketContext) — The instrument's cashflow schedule against market, as named parallel columns. One row per coupon, over the instrument's legs in the order it declares them. It takes a market, not a curve: the projected rate, the pay-date discount factor and the present value are priced quantities, and which curve fills which role is the market's to resolve. The same lift-view-resolve seam npv walks, with the interpreter lock released for the duration. A product carrying no leg raises rather than returning an empty table, which would be indistinguishable from a schedule whose coupons have all paid. Every row names its leg (its leg's position in that order) and the index it resets on (empty where it resets on none). A FRA, which carries no leg, reports its one settlement as a Settlement row on the accrual start, worth its npv. A zero-coupon inflation swap reports its two payments at maturity, Fixed then Indexed, whose pv sums to its npv. A non-deliverable swap's rows keep their own currency's amount, and fill settlement_currency and fx_fixing_date; their discount_factor is the FX conversion and the discount in one factor, so pv is in the settlement currency and sums to npv.

Leg — reference

A compiled leg: coupons in payment order, valued on its own. A leg's floating coupons may name any number of distinct indices. The leg declares the first two, in first-seen order, as its projection and second_projection, and any further ones in its projection_basket, so a market missing one refuses the valuation naming it. Each coupon is priced off the curve its own index names — a stub read off a second tenor, or a basis leg beside its base, is one leg.

Method	Signature
coupons	coupons(self) — The coupons, in payment order.
with_collar	`with_collar(self, cap: float
with_digital	`with_digital(self, call: tuple[float, float
direction	direction(self) — The side this leg is on.
accumulation	accumulation(self) — How this leg's coupons combine into what it is worth: "per_coupon" for a leg whose coupons each pay on their own date, or the zero-coupon rule the leg accumulates under.
pays	pays(self) — The single date a zero-coupon leg pays on, or None where each coupon pays on its own.
currency	currency(self) — The currency the leg pays in, or None for an empty leg.
market_data_needs	market_data_needs(self) — The market data this leg needs, as identifier pairs in the shape an instrument reports: discount, then projection and second_projection for the indices its coupons name, in first-seen order.
npv	npv(self, market: MarketContext) — The leg's present value against market. The same lift-view-resolve seam an instrument's npv walks, resolving the declaration this leg makes rather than one an instrument makes for it, with the interpreter lock released for the duration.
bps	bps(self, market: MarketContext) — This leg's basis-point sensitivity against market: one basis point of every accruing coupon's rate, discounted. A redemption adds nothing; a paid leg's BPS is negative.
bps_by_flow	bps_by_flow(self, market: MarketContext) — bps flow by flow: one figure per cashflow_records row, in its order, each flow's one basis point on its own. A redemption gives zero; the figures sum to bps.
cashflow_records	cashflow_records(self, market: MarketContext) — This leg's cashflow schedule against market, as named parallel columns — the same table, with the same columns in the same order, that Instrument.cashflow_records produces for the instrument holding it, except leg: a leg on its own is its table's only leg, numbered 0.

Lens

A selection over a book: what a trade is, never what it is worth.

Method	Signature
all	all — Every trade.
currency	currency(code: str) — Trades in one currency.
product	product(name: str) — Trades of one product family, by the family's name.
id_prefix	id_prefix(prefix: str) — Trades whose identifier starts with prefix.
and_	and_(self, other: Lens) — This lens and other.
or_	or_(self, other: Lens) — This lens or other.
excluding	excluding(self) — The complement of this lens.

MarketContext — reference

The market a valuation is priced against: reference data with no date (recipes, counterparties, meeting schedules, the data source), one fixing history, and a snapshot per date — at one of which the market is.

Method	Signature
as_of	as_of(self) — The date this market is at, or None for an undated market.
on	on(self, date: datetime.date) — This market at date, its other snapshots kept.
dates	dates(self) — The dates this market holds a snapshot for.
without	without(self, date: datetime.date) — This market without its snapshot at date.
fixing_history	fixing_history(self) — Every version of every print, as index, date, known_on, source, value; source is "fetched" or "pinned", a pin read over any fetched version.
data_source	data_source(self) — The object this market fetches from, or None where it is offline or none was set.
with_data_source	`with_data_source(self, source: object
with_curve_helpers	`with_curve_helpers(self, rungs: list[Rung
with_recipe_quotes	`with_recipe_quotes(self, key: str, quotes: dict[str, dict[Locator, float]], *, notional: float=1.0, interpolation: Interpolation
demand	demand(self, book: Book) — What book needs from outside to price on this market: the quote strips its curves' recipes name, the fixings its resets read, the FX spots its currencies convert through, and the curves no recipe builds. What this market already holds is not demanded.
with_recipes_from	with_recipes_from(self, book: Book, source: object) — This market with the recipes source.recipes(ask) holds for book's keys joined in — only for keys this market's own recipes do not set. The first step of snapshot.
with_market_data	with_market_data(self, demand: Demand, data: MarketData) — This market with what data carries of demand built in, or a SnapshotError naming every gap. The receiver is unchanged; where an async source hands back what it awaited.
recipe_rungs	recipe_rungs(self, key: str, quotes: dict[str, dict[Locator, float]], *, notional: float=1.0) — The helpers quotes binds to under this market's recipe for key, in sheet order and unsolved, each built on notional — what with_recipe_quotes solves, for checking that every quote reprices on the market it marked. with_recipe_quotes(key, quotes) is with_curve_helpers(recipe_rungs(key, quotes)). Refuses exactly as with_recipe_quotes does, with the same ValueError.
with_discount	`with_discount(self, currency: str, curve: DiscountCurve, *, collateral: str
with_projection	`with_projection(self, index: str
with_repo_curve	with_repo_curve(self, key: str, curve: DiscountCurve) — Pins curve as the repo (financing) curve under key.
with_repo_spread	`with_repo_spread(self, key: str, curve: RepoSpreadCurve
repo_base	repo_base(self, key: str) — The key repo(KEY) is declared over, or None for a whole repo curve or an absent key.
with_security_spread	with_security_spread(self, key: str, curve: SpreadCurve) — Pins curve as the security spread under key — dated or flat.
with_credit_curve	`with_credit_curve(self, credit: str, curve: SurvivalCurve, recovery: float
with_inflation_curve	`with_inflation_curve(self, index: str
with_cms_spread_correlation	`with_cms_spread_correlation(self, index: str, other: str, value: float
with_basket_correlation	with_basket_correlation(self, key: str, value: float) — Pins a basket's asset correlation under key — what an nth-to-default basket booked with correlation_key=key reads — as one risk parameter on the correlation axis. A correlation outside [0, 1) raises ValueError.
with_base_correlation	with_base_correlation(self, credit_index: str, curve: BaseCorrelation) — Pins curve as the base-correlation skew for the credit index credit_index, spelled FAMILY.SERIESvVERSION ("CDX.NA.IG.46v1"); another spelling raises ValueError.
with_recovery_floor	with_recovery_floor(self, credit_index: str, value: float) — Pins a credit index's Amraoui-Hitier recovery floor — what a tranche booked with recovery_floor="Market" on that index reads — as one risk parameter on the recovery axis. credit_index is the index the base correlation is keyed by ("CDX.NA.IG.46v1"). A floor outside [0, 1) raises ValueError.
with_copula_dof	with_copula_dof(self, credit_index: str, factor_dof: float, idiosyncratic_dof: float) — Pins a credit index's double-t degrees of freedom — what a tranche booked with factor_dof="Market", idiosyncratic_dof="Market" on that index reads — as two risk parameters on the correlation axis. A degree of freedom not above 2 raises ValueError.
fixing	fixing(self, index: str, date: datetime.date) — The rate index fixed at on date. Raises when the observation was never published, naming both — a historical reset that should have been observed and was not is a data problem, and returning a zero or projecting one hides it. Use try_fixing where absence is an ordinary answer. The key is the one the observation was pinned under, which is also the one the pricer reads: a coupon carries the index string its leg was built from, and the store is keyed by that string literally. Reading under a different spelling of the same index would hand back a number the pricer could not find.
try_fixing	try_fixing(self, index: str, date: datetime.date) — The rate index fixed at on date, or None if it was never published. For deciding whether a reset has been observed, where absence is an ordinary answer rather than a failure. The distinction the core draws between absent and failed survives the crossing.
fixings	fixings(self) — Every pinned observation, as (index, date, value). The shape with_fixings accepts, so the pair round-trips: a market's observations can be read out and pinned back unchanged.
with_meetings	with_meetings(self, schedule: MeetingSchedule) — This market carrying schedule as the bank's calendar of decisions: reference data, not a market input, so it moves no value and leaves equality untouched. A policy window opened on one of its effective dates is named by that decision on the curve, in risk rows and in the par ladder; where none is pinned the seeded 2026–2027 schedule answers.
meetings	meetings(self, bank: str) — The schedule pinned for bank, the seeded one where none is, or None for a bank with neither.
recipes	recipes(self) — How the curves this market does not hold would be built, as (key, curve, role, template, window). One row per recipe segment, plus one per projection source. The key column carries the canonical collateral spelling, so every listed row is addressable through recipe rather than merely readable. A bare market lists the shipped base.
contents	contents(self) — Every stored input's identifier, as (kind, key) pairs. The kinds name the pins that fill the stores, so a row reads as the call that would put it back, and the keys are the spellings a risk row prints and a scenario leg parses — so every listed row is addressable, not merely readable. Recipes are not listed: they describe curves this market does not hold, and are read through recipes() and recipe(key). The as_of date is not a row either — every market has one, so it is a property of the listing rather than an entry in it, and as_of() reports it.
with_discount_via	with_discount_via(self, currency: str, via: str, *, collateral: str) — Cash flows in currency under collateral discounted through hub currency via: discount({currency}-CSA-{collateral}) reads D(collateral) · D(currency under via) / D(collateral under via), composed at pricing from those three keys, so a later pin of a source moves it and its risk lands on the sources. # Errors ValueError where via is currency or collateral: the hub must be a third currency.
discount_via	discount_via(self, currency: str, *, collateral: str) — The hub currency under collateral was declared derived through (with_discount_via), or None for a curve held any other way — beside its discount row in contents(), what declares it again.
discount_factor	`discount_factor(self, currency: str, date: datetime.date, *, collateral: str
repo_discount	repo_discount(self, key: str, date: datetime.date) — The discount factor a trade financed on repo(KEY) reads on date: a spread chain composed onto its base, 1/P = 1/P_base + Σ s·τ, as pricing composes it; a whole repo curve as pinned.
curve	curve(self, id: str) — The curve pinned under id, with the ladder it was pinned with reattached — so a curve read out of one market and pinned into another still carries the par risk a ladder reads. id is the spelling contents() lists and a risk row prints, e.g. discount(USD) or projection(USD-SOFR). # Errors ValueError for an unparseable id; PricingError naming the held keys for a curve this market does not hold. A credit(...) or inflation(...) id is refused naming the reader that serves it — those are different curve types and cross as different classes.
credit_curve	credit_curve(self, credit: str) — The survival curve and stated recovery pinned under the credit identity credit — the spelling a contents() row under credit prints, which respells into this reader and into a scenario selector. The recovery comes back with the curve because it is the assumption the quote carries: a survival curve without it has unrecoverable units. # Errors PricingError naming the identity where the market pins no credit for it; ValueError for a spelling that is no identity, a bare entity included.
inflation_curve	inflation_curve(self, index: str) — The inflation curve pinned under index. # Errors PricingError naming the index where the market pins no inflation curve.
cms_spread_correlation	cms_spread_correlation(self, index: str, other: str) — The CMS spread correlation pinned for the swap indices index and other, in either order — the flat mark or the term structure. # Errors PricingError naming the pair where the market pins none.
basket_correlation	basket_correlation(self, key: str) — The basket correlation pinned under key. # Errors PricingError naming the key where the market pins none.
recovery_floor	recovery_floor(self, credit_index: str) — The recovery floor pinned for credit_index. # Errors PricingError naming the index where the market pins none.
copula_dof	copula_dof(self, credit_index: str) — The double-t degrees of freedom (factor_dof, idiosyncratic_dof) pinned for credit_index. # Errors PricingError naming the index where the market pins none.
base_correlation	base_correlation(self, credit_index: str) — The base correlation pinned under credit_index. Raises PricingError naming the index where the market pins none.
fx_rate	fx_rate(self, base: str, quote: str) — The FX rate pinned for the pair, as it was given. Not a triangulated cross: a rate the market reaches only through a pivot is a valuation-time derivation, and a pinned EURUSD does not make USDEUR readable here. Raises MarketDataError on a miss.
fx_vols	fx_vols(self, base: str, quote: str) — The FX volatility surface pinned for the pair. Takes the pair because the store holds one surface per pair.
swaption_vols	swaption_vols(self, currency: str) — The swaption volatility surface pinned for currency. # Errors PricingError naming the currency where the market pins no surface.
bond_yield_vols	bond_yield_vols(self, key: str) — The bond-yield volatility surface pinned under key: a currency code, or the security an option names. # Errors PricingError naming the key where the market pins no surface.
cap_vols	cap_vols(self, currency: str) — The cap volatility surface pinned for currency. # Errors PricingError naming the currency where the market pins no surface.
cpi_vols	cpi_vols(self, index: str) — The zero-coupon CPI option vol surface pinned for the price index index. # Errors PricingError naming the index where the market pins no surface.
yoy_vols	yoy_vols(self, index: str) — The year-on-year inflation optionlet vol surface pinned for the price index index. # Errors PricingError naming the index where the market pins no surface.
credit_vols	credit_vols(self, credit: str) — The credit volatility surface pinned under the credit identity credit. # Errors PricingError naming the identity where the market pins no surface.
with_counterparties	with_counterparties(self, counterparties: list[Counterparty]) — This market carrying counterparties as the master a draft's counterparty is resolved from. Reference data, not a market input: it moves no value and two markets differing only here compare equal.
counterparty	counterparty(self, acronym: str) — The counterparty under acronym, or None on a market given no master or an acronym it does not hold.
recipe	recipe(self, key: str) — How a curve under key would be built, as a CurveRecipe value, or None where this market carries no recipe for it. key is the collateral spelling a discount pin and a risk row use — "USD", or "EUR-CSA-USD" for a cross-collateral key. A key naming no currency pair has no recipe, because the registry is keyed by pairs.
with_fixings	`with_fixings(self, observations: list[tuple[str
with_fx_rates	with_fx_rates(self, quotes: list[tuple[str, str, float]]) — Pins spot FX as (base, quote, rate) quotes — rate units of quote per one base.
with_fx_vols	with_fx_vols(self, surface: FxVolSurface) — Pins an FX volatility surface.
with_swaption_vols	`with_swaption_vols(self, currency: str, surface: RateVolSurface
with_bond_yield_vols	with_bond_yield_vols(self, key: str, surface: RateVolSurface) — Pins a bond yield volatility surface under key — a currency code, or the security an option names: the same grid type, read at a forward modified duration on its second axis.
with_cap_vols	`with_cap_vols(self, currency: str, surface: RateVolSurface
with_future_price	with_future_price(self, contract: str, price: float) — Pins the listed future contract's quoted price ("CBOT-ZN-2027-03"), per 100 face — one lifted input on the futures-price axis.
with_equity_spot	with_equity_spot(self, equity: str, price: float) — Pins the equity's quoted spot — one lifted input on the equity axis.
equity_spot	equity_spot(self, equity: str) — The quoted spot of the equity, or None.
with_equity_vols	with_equity_vols(self, equity: str, surface: FutureOptionVolSurface) — Pins the equity's option vol surface — listed expiry × strike, what every option on the equity reads.
equity_vols	equity_vols(self, equity: str) — The option vol surface pinned for the equity.
future_price	future_price(self, contract: str) — The quoted price of the listed future contract, per 100, or None.
with_future_option_vols	with_future_option_vols(self, contract: str, surface: FutureOptionVolSurface) — Pins the listed future contract's option vol surface — what every option exercising into it reads.
future_option_vols	future_option_vols(self, contract: str) — The option vol surface pinned for the listed future contract.
with_cpi_vols	with_cpi_vols(self, index: str, surface: CpiVolSurface) — Pins a price index's zero-coupon CPI option vol surface — what a zero-coupon inflation cap, floor or collared CPI notional on index reads.
with_yoy_vols	with_yoy_vols(self, index: str, surface: YoyVolSurface) — Pins a price index's year-on-year inflation optionlet vol surface — what a YoY cap, floor or collared YoY coupon on index reads.
with_credit_vols	with_credit_vols(self, credit: str, surface: CreditVolSurface) — Pins surface as the credit vol surface for the credit identity credit — the identity its credit curve is under, a single name's or an index's — what a CDS option on it reads.
with_credit_intensity	with_credit_intensity(self, credit: str, currency: str, mean_reversion: float, vol: float, correlation: float) — Pins credit's Gaussian intensity — its mean reversion, volatility and correlation with currency's Hull–White factor — under the labels a correlated repack gap reads.
with_fx_rate_correlation	with_fx_rate_correlation(self, base: str, quote: str, currency: str, correlation: float) — Pins the correlation between the FX pair base/quote and currency's Hull–White factor, read by a cross-currency repack simulation on the correlation axis.
with_fx_credit_correlation	with_fx_credit_correlation(self, base: str, quote: str, credit: str, correlation: float) — Pins the correlation between the FX pair base/quote and credit's intensity.
with_rate_correlation	with_rate_correlation(self, currency: str, other: str, correlation: float) — Pins the correlation between two currencies' Hull–White factors.
with_credit_crisis	with_credit_crisis(self, credit: str, rate: float, jump_mean: float, default_probability: float) — Pins credit's crises — their arrival rate, the mean spread jump each brings, and the probability one defaults the issuer at once — under the labels a simulated repack gap reads.
with_hull_white	`with_hull_white(self, currency: str, mean_reversion: float, sigma: float
pin_input	pin_input(self, label: str, value: float) — Pins an exogenous input under label — a number the market watches and risks on its own axis.
with_flat_swaption_vol	with_flat_swaption_vol(self, currency: str, expiry: datetime.date, end: datetime.date, normal_vol: float) — Pin one ATM swaption normal vol. Named apart from :meth:with_swaption_vols, which pins a whole surface.
pinned_input	pinned_input(self, label: str) — The value pinned under label, or None if the market carries none.
under	under(self, scenario: Scenario) — This market under scenario: every admitted input wrapped in its family's shock, everything else carried through. A market like any other — value, risk, report and attribution all run against it, and it lifts to the base's parameter vector, so a risk vector taken under a scenario lines up with the base's row for row. The receiver is untouched.

MarketData — reference

What a source answered: strips as (template, observed, [(locator, value), ...]), fixings as (series, date, value), spots as (pair, rate, observed). Anything a demand names and this does not carry is a gap.

Method	Signature
strips	strips(self) — template, observed, locator, value — one row a pillar.
fixings	fixings(self) — series, date, value.
fx	fx(self) — pair, rate, observed.

MarketDataError

A market-data lookup asked for a value that was never supplied.

MissingFixingError — reference

No fixing was published for the index on the date; kind and key name it as MarketContext.contents() lists it.

MissingFxRateError

No FX rate was supplied for the pair; kind and key name it as MarketContext.contents() lists it.

MissingMarketInputError — reference

A valuation found no curve, vol surface, correlation, scalar, fixing or FX rate in the market. kind and key name the input as MarketContext.contents() lists it once supplied — ("projection", "USD-SOFR"), ("swaption_vol", "EUR"), ("fixing", "EUR-EURIBOR-6M@2026-01-02"); trade is the book trade the refusal came from, or None.

NoLadderError

A par basis was asked of an input no calibration ladder has a row for.

PricingError

A valuation could not be produced from the market it was given.

RecipeAsk

What a recipe source is asked about: the date and the collateral keys.

Method	Signature
as_of	as_of(self) — The date the market is as of.
keys	keys(self) — The collateral keys the book's trades declare.

Records

A table of results: named columns of equal length, each carrying its kind. Returned by every reading taken against market data. to_dict and to_rows are readings of the same table; to_polars and to_pandas build a dataframe with a declared schema rather than an inferred one, which is what the column kinds are carried across the boundary for. len counts rows while [...] takes a column name, and the table refuses to be iterated rather than choose between the two axes: pandas iterates column names and polars iterates columns, so any choice made here would surprise whichever a caller arrived from. Call to_rows, columns or to_dict.

Method	Signature
columns	columns(self) — The column names, in the order the producing frame wrote them.
column_kinds	column_kinds(self) — Each column's kind — "text", "number" or "date" — in column order. What a caller building their own frame needs, and what the two dataframe readings declare their schema from.
to_dict	to_dict(self) — The table as a mapping of column name to list of values. Text becomes str, Number float, and Date datetime.date with None where a row has none. An absent number is nan, not None: the cell belongs to a numeric column and keeping it numeric is what stops the column changing type around it.
to_rows	to_rows(self) — The table as a list of row tuples, each in column order.
to_polars	to_polars(self) — The table as a polars.DataFrame, built with a declared schema. # Errors ImportError naming the helixio[polars] extra when polars is absent.
to_pandas	to_pandas(self) — The table as a pandas.DataFrame, with declared dtypes. A date column becomes datetime64[ns] with NaT where absent, rather than the object column pandas infers from datetime.date values. # Errors ImportError naming the helixio[pandas] extra when pandas is absent.
to_csv	to_csv(self, path: str) — Writes the table to path as CSV — a header row, then one line per row. Imports nothing. Writing a text format through a dataframe library would make a plain to_csv the one call in this package that needs a dependency, which is what this avoids. # Errors OSError if the file cannot be written.

RiskError

A risk pass failed in valuation or adjoint read-back.

RiskFrame

One risk pass and the market it was taken against, read on any axis, basis and aggregation.

Method	Signature
read	`read(self, axis: Axis
npv	npv(self) — The book's value in the pass this frame holds.
valuation_date	valuation_date(self) — The valuation date of the market the pass was taken against.
risk	risk(self) — The raw input sensitivities the pass produced: input, value.

Scenario

A named perturbation of the market, in the units its quotes are made in.

Method	Signature
shift	`shift(self, selector: str, amount: float, *, shift_type: ShiftType
slope	`slope(self, selector: str, level: float, per_year: float, pivot_years: float, *, shift_type: ShiftType
bucket	`bucket(self, selector: str, start: datetime.date, end: datetime.date, amount: float, *, shift_type: ShiftType
tent	`tent(self, selector: str, peak: datetime.date, amount: float, *, left: datetime.date
holding_outrights	holding_outrights(self) — This scenario moving FX-implied curves' spots with every FX leg and holding their outrights, so an FX shock's P&L is the one the AD FX delta predicts. By default the implied curves' rates are held instead.
label	label(self) — What a report keys this scenario's row by.

SnapshotError

A snapshot built no market: gaps lists every strip, fixing, spot or curve the source did not supply, as family and key.

SolveError

A quote solve found no root in its bracket or did not converge.

SourceError

A market-data, recipe or calendar source itself failed — transport, authentication, a payload it could not read — as distinct from a key it does not hold, which is a gap.

Template — reference

A resolved convention template, and the code it resolved from. Frozen: every with_* returns a new Template and leaves the receiver unchanged. A builder the family's conventions do not carry raises ValueError naming the code and the family, rather than returning an unchanged template.

Method	Signature
code	code(self) — The registry code this template resolved from.
swap	swap(self, trade_date: datetime.date) — A draft of this template's swap on trade_date, every term defaulted: effective at spot, ten years long, 10,000,000, receiving fixed, and no fixed rate until with_fixed_rate or at_par(market). template("USD-SOFR-OIS").swap(VAL).at_par(market) is the commonest trade in one line. A template whose family builds no swap raises ValueError naming the family.
family	family(self) — The template family's name — the same spelling a wrong-family refusal uses, so the two cannot drift.
calendar	calendar(self) — The calendar this template's schedules are built on — the resolved calendar itself, not a code that would have to be re-resolved. Handing back the engine's own handle is what makes a caller's date arithmetic the engine's: a code re-resolved on this side could differ from the one the template holds and nothing would say so. A family that carries no single schedule calendar is refused by name.
spot_lag	spot_lag(self) — The spot lag this template's default effective date is taken at, as a tenor ("2D"). A family that carries none is refused by name.
spot_date	spot_date(self, valuation: datetime.date) — The default effective date this template takes for valuation — the one seam every product builder and calibration helper resolves an effective date through. Exposed so that a caller can check their own date arithmetic against the engine's rather than assume it: calendar(), spot_lag() and the business-day primitives should compose to exactly this.
with_spot_lag	with_spot_lag(self, days: int) — This template with the spot lag overridden, in business days. Accepted only where a constructor method on this class reads it: the zero-coupon swap, whose zero_coupon_swap(valuation, tenor, ...) derives its effective date from the lag. Every other family is refused, and the two refusals say different things. A family that carries no spot lag at all is told so. A family that carries one whose constructor here takes explicit dates is told that — because the field is real and a caller who set it would otherwise reasonably believe it had done something.
with_meeting_node	with_meeting_node(self, node: str) — This meeting-OIS template with its rungs noded at node: "window_end" (the default, where each decision's rate takes effect) or "payment_date" (the swap's payment date, for reconciling to a curve noded there; a turn is refused under it). Any other family raises ValueError.
with_payment_lag	with_payment_lag(self, days: int) — This template with the payment lag overridden, in business days. Accepted for the overnight and vanilla swap families, whose vanilla_swap here builds the legs the lag dates. A CDS carries one too, but this class has no CDS constructor for it to reach.
with_business_day_convention	`with_business_day_convention(self, business_day_convention: BusinessDayConvention
with_payment_convention	`with_payment_convention(self, business_day_convention: BusinessDayConvention
with_float_payment_convention	`with_float_payment_convention(self, business_day_convention: BusinessDayConvention
with_float_payment_lag	with_float_payment_lag(self, days: int) — This template with the floating leg's own payment lag, leaving the fixed leg on the shared one.
with_calendar	`with_calendar(self, calendar: Calendar
with_date_generation	with_date_generation(self, date_generation: str) — This template generating its swaps' schedules in date_generation's direction: "Backward" from the termination, any stub at the front, or "Forward" from the effective date, the stub at the back, as every registered template builds. An OIS or vanilla swap template takes it; another family raises ValueError.
with_roll_convention	`with_roll_convention(self, roll_convention: RollConvention
with_float_payment_calendar	with_float_payment_calendar(self, calendar: str) — This template with the floating leg's own payment calendar, leaving the fixed leg on the shared one.
vanilla_swap	`vanilla_swap(self, effective: datetime.date, termination: datetime.date
forward_rate_agreement	`forward_rate_agreement(self, valuation: datetime.date
money_market_deposit	`money_market_deposit(self, start: datetime.date, maturity: datetime.date, *, rate: float, notional: float, lending: bool=True, issuer: str
tri_party_repo	`tri_party_repo(self, start: datetime.date, end: datetime.date
securities_loan	`securities_loan(self, start: datetime.date, end: datetime.date
repo	`repo(self, start: datetime.date, end: datetime.date
rate_future	`rate_future(self, valuation: datetime.date
reference_period	reference_period(self, year: int, month: int) — The reference period of this rate-future template's listed contract for a delivery month: the IMM quarter starting on the month's third Wednesday, or the calendar month itself.
last_trading_day	last_trading_day(self, year: int, month: int) — The day the listed contract for a delivery month stops trading under the exchange's rule — the template's calendar standing in for the exchange's — or None where the rule is not sourced.
tick_size	tick_size(self, year: int, month: int, as_of: datetime.date) — The listed contract's minimum price fluctuation on as_of, in index points, or None where the exchange's rule is not sourced.
rate_future_contract	`rate_future_contract(self, year: int, month: int, *, contracts: float, traded_price: float, short: bool=False, convexity_adjustment: float
zero_coupon_swap	`zero_coupon_swap(self, valuation: datetime.date
nds	nds(self, trade_date: datetime.date, tenor: str, *, notional: float, fixed_rate: float, pays_fixed: bool=False) — A non-deliverable swap drafted from this NDS template. The local swap its market trades, tenor long from spot on trade_date, every payment of both legs settling in USD at the FX fixing two business days before it (BRL: Brazil and New York days). A tenor within the template's zero-coupon limit pays once at maturity. Any other family raises ValueError.
ndf	ndf(self, trade_date: datetime.date, tenor: str, *, notional: float, forward_rate: float, short: bool=False) — A non-deliverable forward drafted from this NDF template. notional of the settlement currency is bought (sold when short) against the reference currency at forward_rate. Spot, the value date and the fixing date come from the template's calendars and lags; the forward is cash-settled on the pair's FX key (FX-USDKRW) in the settlement currency. Any other family raises ValueError.
tenor_basis_swap	`tenor_basis_swap(self, effective: datetime.date, termination: datetime.date, *, notional: float, spread: float, spread_leg: str
cross_currency_swap	`cross_currency_swap(self, effective: datetime.date, termination: datetime.date, *, notional: float, fx_rate: float, spread: float
with_leg_index	`with_leg_index(self, leg: str, index: Index
with_leg_conventions	`with_leg_conventions(self, leg: str, *, frequency: Frequency
with_quoted_leg	with_quoted_leg(self, leg: str) — This cross-currency template quoting its spread on leg.
with_resetting_leg	`with_resetting_leg(self, leg: str
with_leg_fx	`with_leg_fx(self, leg: str, ndf: str
with_initial_exchange	with_initial_exchange(self, initial: bool) — This cross-currency template exchanging its notional at the start as well as the end, or, with False, at the end alone. An opted-in initial exchange on a non-deliverable template converts at the deal rate (the swap's fx_rate). A resetting template, or any other family, raises ValueError.
with_settlement_currency	with_settlement_currency(self, code: str) — This NDS or non-deliverable cross-currency template settling in code; a fixing sourced against USD crosses through USD into it. Any other family, or a deliverable cross-currency template, raises ValueError naming it.
ndo	`ndo(self, trade_date: datetime.date, tenor: str, *, notional: float, strike: float, kind: OptionKind
with_csa	with_csa(self, csa: str) — This cross-currency template under the CSA csa: its overnight index ("EUR-ESTR"), or a collateral currency ("EUR"), read as the index that currency's shipped own curve calibrates on — a currency with none raises ValueError asking for the index code.
cross_currency_legs	cross_currency_legs(self) — Each leg's currency, index and role (quoted, resetting).

Module types

helixio.bonds.BondFutureAnalysis

The basket analysis: the rows, the CTD, the theoretical price.

Method	Signature
rows	rows(self) — One row per deliverable, in basket order.
ctd	ctd(self) — The cheapest-to-deliver row's key: the minimum net basis.
ctd_index	ctd_index(self) — The cheapest-to-deliver row's position in rows() — the same row ctd names, typed, so a cross-language check compares an index rather than a label.
theoretical_price	theoretical_price(self) — forward_clean(CTD) / CF(CTD).

helixio.bonds.BondFutureOptionDiagnostics — reference

What a bond future option is priced from, per 100.

Method	Signature
futures_price	futures_price(self) — The quoted futures price.
vol	vol(self) — The vol read at the option's expiry and strike.
vol_convention	vol_convention(self) — "lognormal" or "normal".
time	time(self) — The option's life in the surface's time measure, in years.
discount	discount(self) — The discount factor to expiry — 1 for a futures-style option.
european	european(self) — The European value, per 100.
early_exercise	early_exercise(self) — What early exercise adds, per 100.
critical_price	critical_price(self) — The Barone-Adesi-Whaley critical futures price, where it applies.

helixio.bonds.BondOptionDiagnostics

What a bond option resolved to when it was priced.

Method	Signature
forward_dirty	forward_dirty(self) — Forward dirty price per 100 at exercise settlement.
forward_yield	forward_yield(self) — Forward yield on the dirty forward, compounded at the coupon frequency.
forward_duration	forward_duration(self) — Forward modified duration at the forward yield, in years.
yield_vol	yield_vol(self) — The yield vol read at (expiry, forward_duration).
price_vol	price_vol(self) — The price vol after the duration conversion: absolute per 100 under Normal, relative under Lognormal.
accrued_at_exercise	accrued_at_exercise(self) — Accrued per 100 at exercise settlement.
dirty_strike	dirty_strike(self) — The dirty cash strike per 100.
expiry_years	expiry_years(self) — Expiry in years, Act/365F from valuation.

helixio.bonds.BondStrikeKind

What a bond option's strike is stated as: a Clean or Dirty price, or a Yield. bond_option takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.bonds.CallKind

Whose option a callability is: the issuer's Call or the holder's Put. A callable_bond schedule row carries the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.bonds.DeliverableAnalysis

One deliverable's analytics at a quoted futures price.

Method	Signature
key	key(self) — The row's name — the key its basket entry carried.
conversion_factor	conversion_factor(self) — Its exchange-published conversion factor.
spot_clean	spot_clean(self) — Spot clean price per 100, settling on the valuation date.
forward_clean	forward_clean(self) — Forward clean price per 100 at delivery, on the carry curve.
carry_tier	carry_tier(self) — Which cascade rung supplied the carry curve — "security", "group", "currency" — or None for the discount-curve fallback.
gross_basis	gross_basis(self) — spot_clean − F·CF.
net_basis	net_basis(self) — forward_clean − F·CF.
interim_coupons	interim_coupons(self) — Coupons per 100 the deliverable pays after the valuation date and on or before delivery.
repo_day_count	repo_day_count(self) — The day count implied_repo is quoted on.
implied_repo	implied_repo(self) — The simple financing rate the invoice implies, each interim coupon reinvested to delivery at the same rate: (I + Σcᵢ − P) / (P·τ − Σcᵢ·τᵢ), on repo_day_count.

helixio.bonds.ExDivDayType

The days an ex-dividend lag counts: Business days on the bond's settlement calendar (UK gilts) or Calendar days (South African government bonds).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.bonds.PriceBasis

Whether a bond price includes accrued interest. Clean or Dirty; every bond reading that takes a basis takes the member or its string. A member is not equal to its string; code() is the string the parser takes.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.bonds.YieldConvention

The convention a quoted yield is stated under, by one name. A street convention — UsStreet, UkGilt, DeGovt, or the bond's own Default — compounding at the market's frequency; a fixed compounding — Annual, SemiAnnual, Quarterly, Monthly, Continuous, Simple — whatever the bond pays; or one of the two conventions that are not a discounting relationship, Ise and JapaneseSimple. Every yield_convention parameter takes the member or its spelling ("ust", "semiannual", "jgb"). A reading that needs a single compounding basis, such as a duration, refuses Ise and JapaneseSimple by name. A member is not equal to its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.bonds.YieldMoments

A bond's dirty price and its first two yield derivatives at one yield; every yield-space measure is a reading of the three.

Method	Signature
dirty_price	dirty_price(self) — The dirty price per 100 face.
first	first(self) — ∂P/∂y.
second	second(self) — ∂²P/∂y².
modified_duration	modified_duration(self) — Modified duration −P′/P.
convexity	convexity(self) — Convexity P″/P.
dv01	dv01(self) — DV01 per 100 face.
yield_sensitivity	yield_sensitivity(self) — ∂y/∂P, the implicit-function derivative 1/P′.
money_duration	money_duration(self, face: float) — Money duration at a stated face.
money_dv01	money_dv01(self, face: float) — DV01 in money at a stated face.

helixio.calibration.CalibratedBaseCorrelation

A base-correlation curve solved from a tranche capital structure, and how it was reached.

Method	Signature
curve	curve(self) — The solved curve: one correlation per detachment.
solves	solves(self) — One row per tranche in solve order: pillar (the tranche index), iterations, residual.

helixio.calibration.CalibratedInflation

An inflation curve solved from a ladder of zero-coupon inflation swaps, and how it was reached.

Method	Signature
curve	curve(self) — The solved curve: one index-level node per rung, carrying its ladder.
solves	solves(self) — One row per rung in solve order: pillar, iterations, residual.
rungs	rungs(self) — The ladder this curve reprices: pillar and quote per rung.
jacobian	jacobian(self) — ∂level/∂q row-major: jacobian[node][rung].

helixio.calibration.CalibratedSurvival

A survival curve solved from a ladder of credit default swaps, and how it was reached.

Method	Signature
curve	curve(self) — The solved curve — ISDA piecewise-flat hazards, or a default density — one parameter per rung, carrying its ladder into with_credit_curve.
solves	solves(self) — One row per rung in solve order: pillar, iterations, residual.
rungs	rungs(self) — The ladder this curve reprices: pillar and quote per rung, in solve order — the same order as the curve's parameters.
jacobian	jacobian(self) — ∂p/∂q row-major: jacobian[parameter][rung] is how far that parameter — a segment's hazard, or a pillar's density — moves per unit move in that rung's quote.

helixio.calibration.Calibration — reference

A calibrated curve and how it was reached.

Method	Signature
curve	curve(self) — The solved curve.
solves	solves(self) — One row per rung in solve order: pillar, iterations, residual. pillar and iterations are counts, and arrive as floats: a column carries text, a number or a date, and widening that set for two diagnostic columns would change every producer of a table.
sweeps	sweeps(self) — How many full-curve sweeps moved a pillar after the sequential pass.
rungs	rungs(self) — The ladder this curve reprices: (maturity, quote) per rung, in solve order — the same order as the curve's pillars.
jacobian	jacobian(self) — ∂z/∂q row-major: jacobian[pillar][rung] is how far that pillar's parameter moves per unit move in that rung's quote. The transform behind a par-basis risk number. A caller rarely needs it directly — Book.report flips through it — but a desk checking a hedge ratio by hand does.
jacobian_engine	jacobian_engine(self) — Which engine built jacobian(): ("lanes", None) for the tape-free forward passes, ("reverse", sweeps) for one reverse recording read back in sweeps vector sweeps.
interpolation	interpolation(self) — The interpolation scheme the ladder solved under.

helixio.calibration.HullWhiteFit — reference

A fitted Hull-White volatility and what the fit knows about it.

Method	Signature
sigma	sigma(self) — The fitted volatility: a float for a flat fit, a Records of end and sigma — one row per piece — for a piecewise one.
shape	shape(self) — The shape the fit ran in, flat or piecewise.
mean_reversion	mean_reversion(self) — The mean reversion the fit held fixed.
currency	currency(self) — The currency whose curve and quotes were fitted.
evaluations	evaluations(self) — How many objective evaluations the Gauss–Newton search took.
fits	fits(self) — One row per strip point: (expiry, end, market, model, vol_misfit).
quote_sensitivities	quote_sensitivities(self) — How the fitted σ moves with each quote, from the optimality condition rather than a re-calibration: expiry, end, d_sigma_d_vol per quote for a flat fit; per (piece, quote) pair, with the piece's end date first as piece, for a piecewise one. A point read off the swaption surface (see surface_points) has no quote and no row.
surface_points	surface_points(self) — The strip points read at the money off the currency's swaption surface, because no flat vol was pinned for them, as (expiry, end).

helixio.calibration.JointCalibration — reference

Several curves solved together, each under its first role.

Method	Signature
curves	curves(self) — The solved curves as (role, DiscountCurve) pairs, in the order given.
curve	curve(self, role: str) — The curve solved under role; a role no curve carries is a ValueError.
iterations	iterations(self) — The Newton iterations the joint solve took.
residual	residual(self) — The largest absolute rung residual at the solution.

helixio.calibration.Rung — reference

One rung of a ladder with its quote kind declared.

Method	Signature
par	par(pillar: datetime.date, instrument: Instrument, quote: float) — A rung at par: the instrument is worth nothing, quote is its par rate.
spread	spread(pillar: datetime.date, instrument: Instrument, quote: float) — A rung quoted as a spread on its floating leg, worth nothing at it.
priced	`priced(pillar: datetime.date, instrument: Instrument, quote: float, money_per_quote: float, settlement: datetime.date
upfront	upfront(pillar: datetime.date, cds: Instrument, upfront: float) — An upfront-quoted credit default swap: the contract without its upfront, priced at upfront per unit notional.
pillar	pillar(self) — The pillar date.
quote	quote(self) — The declared quote, in its own units.
kind	kind(self) — Which quantity the quote is: par, spread or priced.
tenor	tenor(self) — The tenor the rung was quoted at (5Y), where it was built from one — what labels its column of a par ladder beside the pillar date.
label	label(self) — How a ladder labels this rung's column: its tenor (5Y), else the label it was built with — a futures contract (DEC26), a FRA's months (3x6) — else its pillar date.
instrument	instrument(self) — The rung's instrument, to be priced back on a solved curve.

helixio.calibration.SigmaShape

The shape a Hull-White volatility is calibrated in: Flat by least squares, or Piecewise, one piece per strip expiry.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.calibration.SmoothedCalibration

A discount curve fitted globally, trading repricing error for forward smoothness.

Method	Signature
curve	curve(self) — The fitted curve.
residuals	residuals(self) — One row per rung in ladder order: pillar, quote, and residual — the repriced quote less the declared one, in the quote's units.
roughness	roughness(self) — The sum of squared jumps in the segment forward at the interior pillars.
smoothness	smoothness(self) — The smoothness the curve was fitted at.
iterations	iterations(self) — Levenberg–Marquardt iterations that proposed an accepted step.

helixio.calibration.Tolerance

How hard a ladder solver tries; the core's defaults unless overridden.

Method	Signature
residual	residual(self) — Residual below which a pillar is solved, in the instrument's units.
step	step(self) — Newton step below which the parameter is taken as converged.
max_iterations	max_iterations(self) — Iterations allowed per pillar.
max_backtracks	max_backtracks(self) — Halvings allowed of one Newton step.
max_sweeps	max_sweeps(self) — Full-curve sweeps allowed after the sequential pass.

helixio.credit.AccrualOnDefault

How premium accrued since the last coupon settles on default: Proportional (the ISDA standard model's), Halfway, or NoAccrual (code none). credit_default_swap takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.credit.CdsDiagnostics

Each part of a credit default swap's value, signed as it enters that value, and the risky annuity behind its quote.

Method	Signature
premium	premium(self) — The survival-weighted premium leg.
accrual	accrual(self) — The premium accrued to the default date.
rebate	rebate(self) — The accrual the first coupon charges for but protection did not cover, returned at settlement.
upfront	upfront(self) — The upfront, as money rather than a decimal of the notional.
protection	protection(self) — The protection leg: the default-time integral over the contract's grid.
annuity	annuity(self) — The risky annuity at unit coupon, which the quote divides by. Unsigned: a per-unit-coupon cost rather than a value.
npv	npv(self) — The contract's value: the parts, already signed, added up.

helixio.credit.CreditLinkedSwapDiagnostics

Each part of a credit-linked swap's value, in the trade currency, signed as it enters that value, in five parts. The parts sum to npv().

Method	Signature
independent	independent(self) — The independent legs: discounted, whatever happens.
contingent	contingent(self) — The contingent legs' scheduled payments, survival-weighted.
contingent_accrual	contingent_accrual(self) — The contingent legs' accrual settled on default.
default_payments	default_payments(self) — The default legs: paid on default, scaled by the loss.
recovery_payments	recovery_payments(self) — The recovery legs: paid on default, scaled by the recovery.
npv	npv(self) — The swap's value: the parts added up.

helixio.credit.DefaultPaymentTime

When a credit-linked swap's default-contingent payment is made: AtDefault (the interval's midpoint), AtPeriodEnd (the first scheduled payment date on or after the default) or AtMaturity. credit_linked_swap takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.credit.GapCharge

A repack note's gap charge and its rows.

Method	Signature
charge	charge(self) — The charge: the sum of the rows' contributions, in currency.
rows	rows(self) — date, default_probability, expected_gap (given default there, undiscounted, at the date) and contribution (this date's part of the charge, discounted to today) per default date.

helixio.credit.IndexSettlement

What a credit event settles on an index position, signed to the holder.

Method	Signature
entity	entity(self) — The defaulted entity.
event_date	event_date(self) — The event date.
protection	protection(self) — The protection on the defaulted weight.
accrued	accrued(self) — The premium accrued on the defaulted weight.

helixio.credit.IndexSkew

One term structure of hazard multipliers every constituent is scaled by.

Method	Signature
segments	segments(self) — (pillar, factor) pairs; each factor applies up to its pillar.
adjust	adjust(self, curve: SurvivalCurve) — curve scaled by this skew.
adjusted_market	adjusted_market(self, market: MarketContext, constituents: list[tuple[str, float]]) — market with every constituent re-pinned under its adjusted curve. A constituent is a full ENTITY/SENIORITY/DOCCLAUSE spelling, or a bare entity on the standard North American tier and clause, keyed in the index's currency.

helixio.credit.LegRole

How a credit-linked swap's leg depends on the reference entity's default: Independent (paid whatever happens), Contingent (paid while the entity survives), Default (paid on default, scaled by the loss) or Recovery (paid on default, scaled by the recovery). credit_linked_swap takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.credit.SimulatedGap

A repack note's simulated gap: the charge, its standard error, its legs and its profile.

Method	Signature
charge	charge(self) — The charge: the mean of the paths' discounted gaps, in currency.
standard_error	standard_error(self) — The charge's standard error, over antithetic pair means when paired.
legs	legs(self) — leg (diffusive_default, crisis_default, trigger_gapped, trigger_slow) and charge: the charge split by what ended the note.
profile	profile(self) — date, default_weight, expected_gap, pfe per default date.

helixio.credit.TrancheSettlement

What a credit event settles on a tranche position, and where it leaves the tranche on the surviving pool.

Method	Signature
entity	entity(self) — The defaulted entity.
event_date	event_date(self) — The event date.
protection	protection(self) — The loss the tranche absorbs, signed to the holder.
write_down	write_down(self) — The recovered amount written off the tranche's notional from the top.
accrued	accrued(self) — The premium accrued on the notional removed, signed to the holder.
attach	attach(self) — The attachment after the event, on the surviving pool.
detach	detach(self) — The detachment after the event, on the surviving pool.

helixio.curves.BaseCorrelation

A base-correlation skew across an index's capital structure.

Method	Signature
flat	flat(rho: float) — One correlation for every detachment.
correlation	correlation(self, detachment: float) — The base correlation at a detachment point.

helixio.curves.BondFitRow

One bond's place in a parametric curve fit.

Method	Signature
maturity	maturity(self) — The bond's maturity, its identity in the report.
market_clean	market_clean(self) — The clean price the bond was quoted at.
model_clean	model_clean(self) — The clean price the fitted curve gives it.
yield_misfit	yield_misfit(self) — Model yield less market yield — a price miss with the bond's own duration already divided out.

helixio.curves.CmsSpreadCorrelationCurve

The market's correlation between two swap indices' rates by option expiry in years — linear between pillars, flat beyond them — or one flat mark with no pillar, or a 2-D surface by expiry and strike.

Method	Signature
flat	flat(correlation: float) — One correlation at every expiry, with no pillar.
with_strikes	with_strikes(nodes: list[tuple[tuple[float, float], float]]) — A 2-D surface from ((expiry, strike), correlation) nodes.
is_flat	is_flat(self) — Whether this is the flat mark, with no pillar.
is_surface	is_surface(self) — Whether this is a 2-D surface.
expiries	expiries(self) — The pillar expiries in years; empty for a flat mark.
parameters	parameters(self) — The correlations, one per pillar (or the one flat mark).
correlation	`correlation(self, expiry: float, strike: float

helixio.curves.CurveRecipe

How a market would build the curves under one key, as topology: the discount segments in order, each a role and the template that builds it, and per projection index whether it telescopes onto the discount curve or has its own strip. It carries no tenor: the quote sheet is the grid. Read back from MarketContext.recipe; str() is the core's one-line summary.

Method	Signature
currency	currency(self) — The currency the recipe builds for.
discount_segments	discount_segments(self) — The discount segments in declaration order: role (deposit, policy, futures, swaps, fx_swaps, basis, fixed_float_xccy, or window), template, and window (the dates of a window row, empty otherwise).
projection_indices	projection_indices(self) — The projection indices the recipe resolves, in order.
own_strip	own_strip(self, index: str) — The template of index's own strip, or None where it telescopes onto the discount curve or the recipe does not resolve it.
telescopes	telescopes(self, index: str) — Whether index telescopes onto the discount curve rather than calibrating a forward curve of its own.
windows	windows(self) — The windows the recipe fixes whatever the sheet says, as (template, start, end).
discount_via	discount_via(self) — The hub currency this recipe's cross discount is derived through (with_discount_via), or None.
is_fx_implied	is_fx_implied(self) — Whether the discount curve is implied from FX swaps alone.

helixio.curves.DiscountCurve — reference

A discount curve, built from dated discount-factor pillars. A first pillar of exactly 1.0 on the reference date is the anchor the curve already holds, and is dropped; any other factor there is refused.

Method	Signature
flat	`flat(reference: datetime.date, rate: float, day_count: str
from_zero_rates	`from_zero_rates(reference: datetime.date, nodes: list[tuple[datetime.date, float]], day_count: str
discount	discount(self, at: datetime.date) — The discount factor to a date. Past the last pillar the curve carries on at its last segment's forward rate — a flat-forward extrapolation, taken silently rather than refused. A date before the reference date raises ValueError.
zero_rate	zero_rate(self, at: datetime.date) — The continuously-compounded zero rate to at, under the curve's rate_day_count — ACT/365 fixed unless it was built with another. A property of the curve, on the measure it was told rates are quoted in. It is not the rate any index quotes: see Index.forecast, which is simple, on the index's own day count, over the index's own window.
forward_rate	forward_rate(self, start: datetime.date, end: datetime.date) — The continuously-compounded forward rate between start and end, on ACT/365. As with zero_rate, a reading of the curve rather than of an index. A caller who wants the rate a coupon fixes on wants Index.forecast; for an ACT/360 index the two differ, which a test asserts.
parameter_count	parameter_count(self) — How many free parameters the curve has.
natural	natural(self) — The fitted form's natural parameters, as Rust's natural() reads them: [β0, β1, β2, λ] for a Nelson-Siegel curve, [β0, β1, β2, β3, λ1, λ2] for a Svensson one, the decays squashed back to their natural scale. What curves.fit_bond_curve solved, read back without re-deriving it from the zero rates. Raises ValueError on any other curve: a piecewise curve has pillars, an exponential-splines fit has basis weights, and neither is a natural parameter vector.
with_zero_spread	`with_zero_spread(self, spread: float, day_count: str
rebased	rebased(self, reference: datetime.date) — This curve read forward from reference: its discount factor over its own there. A date before this curve's own reference is refused.
with_spread	with_spread(self, spread: DiscountCurve) — This curve's discount factors times spread's, which must share its reference date. A zero-rate curve as spread adds its zero rates, on that curve's day count, to this curve's.
fx_implied	fx_implied(base: DiscountCurve, pair: str, spot: float, spot_date: datetime.date, forwards: list[tuple[datetime.date, float]]) — A curve implied by FX forwards over base by covered interest parity: for pair quoted as quote units per one base, the quote currency's discount factor is (spot / F(t)) · DF_base(t) / DF_base(spot_date). The spot is the curve's one risk parameter; the outrights pin its shape.
step_forward	step_forward(reference: datetime.date, knots: list[tuple[datetime.date, str]], discount_factors: list[float]) — A step curve: log-linear between pillars that carry an identity — a central-bank meeting, a turn of period, or none — so risk read back from it is keyed by the event. knots are (date, tag) pairs, the tag "meeting:FED" (any bank code), "turn" or "anon"; one discount factor per knot. dates.meeting_dates and dates.turn_dates give the dates.
knot_tags	knot_tags(self) — The tag of each pillar of a step curve, in date order, or None for a curve whose pillars carry no identity.
interpolation	interpolation(self) — The scheme the curve reads between its pillars, by its spelling.
long_interpolation	long_interpolation(self) — The second scheme and the pillar it takes over at, when this curve reads under two.
rate_day_count	rate_day_count(self) — The day count this curve forms a rate under. Not what it discounts on. The pillars are dated discount factors, so the curve is a function of dates and this moves no factor it returns — it is read where zero_rate and forward_rate divide a log factor into a rate, and nowhere else.

helixio.curves.InflationCurve — reference

An inflation index-level curve.

Method	Signature
index_level	index_level(self, at: datetime.date) — The index level at a date.

helixio.curves.Interpolation — explanation

The scheme a discount curve reads between its pillars, as a value that carries its parameters. One member per parameter-free scheme — LogLinear, BackwardFlat, ForwardFlat, LinearZero, NaturalCubic, NotAKnotCubic, MonotoneConvex, MonotoneCubic, Akima, Kruger — and tension_spline(sigma) / clamped_cubic(left, right) for the two that take them. Every interpolation parameter on a discount curve or a curve calibration takes the member or its code; given the value, tension and end_slopes are refused, since the value carries its own. code() is what DiscountCurve.interpolation() reads back.

Method	Signature
tension_spline	tension_spline(sigma: float) — A tension spline with tension sigma.
anchored_linear_zero	anchored_linear_zero(anchor: float) — Linear in the zero rate, from the continuously compounded rate anchor at the reference date (on ACT/365 fixed time).
clamped_cubic	clamped_cubic(left: float, right: float) — A clamped cubic with the end slopes left and right.
code	code(self) — The scheme's code, as DiscountCurve.interpolation() reads it back.
read_log_df	read_log_df(self, taus: list[float], ys: list[float], tau: float) — The log discount factor this scheme reads at tau from knots at taus (year fractions, positive and strictly increasing) with log discount factors ys, the anchor (0, 0) implicit and the forward held flat past the last knot — what a DiscountCurve under this scheme reads. Malformed knots raise ValueError naming the defect.

helixio.curves.LevelInterpolation

How an inflation curve reads an index level between its nodes: Linear in the level, or LogLinear. InflationCurve and calibration.inflation take the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.curves.RecipeSpec

A curve recipe stated as data, validated as the recipe builder validates it: discount segments as (role, template), per projection index "telescoping" or its own strip's template, windows as (template, start, end).

Method	Signature
of	of(key: str, recipe: CurveRecipe) — The spec stating recipe under key — the inverse of to_recipe.
to_recipe	to_recipe(self) — The recipe this spec states; a refused template raises ValueError naming the spec's key.
key	key(self) — The collateral key.

helixio.curves.RepoSpreadCurve — reference

A repo spread: the simple spreads a desk marks — GC against the overnight curve, a special against GC — at dated pillars, linear between them and flat outside, accruing on a money-market day_count. Pinned with MarketContext.with_repo_spread over a base, it adds in simple-rate space, 1/P = 1/P_base + s * tau, and its pillars report risk on the repo axis.

Method	Signature
from_term_rates	`from_term_rates(base: DiscountCurve, quotes: list[tuple[datetime.date, float]], day_count: str
reference_date	reference_date(self) — The date the spread is measured from.
pillars	pillars(self) — The pillars as (date, spread).
day_count	day_count(self) — The money-market day count the spread accrues on.
spread	spread(self, at: datetime.date) — The spread at at: linear between pillars, flat outside.

helixio.curves.SpreadCurve — reference

A continuously compounded spread over a date, applied on top of the discounting a security is priced on. Dated, its pillars are free parameters and report risk on the security_spread axis; flat, it is declared data and reports none.

Method	Signature
flat	flat(reference: datetime.date, spread: float) — One constant spread, anchored at reference.
reference_date	reference_date(self) — The date the spread is measured from.
spread	spread(self, at: datetime.date) — Linear between pillars, flat beyond the last and before the first.
pillars	pillars(self) — The dated pillars as (date, spread); a flat spread has none.
discount	discount(self, at: datetime.date) — The factor the spread alone contributes: exp(-s * tau).

helixio.curves.SurvivalCurve — reference

A survival curve: the probability of surviving to a date.

Method	Signature
default_density	`default_density(reference: datetime.date, nodes: list[tuple[datetime.date, float]], day_count: str
flat_hazard	`flat_hazard(reference: datetime.date, hazard: float, day_count: str
survival	survival(self, at: datetime.date) — The probability of surviving to a date.
hazard_rate	hazard_rate(self, at: datetime.date) — The instantaneous hazard rate −d/dt ln S at a date.
density_at	density_at(self, at: datetime.date) — The default density h·S at a date; default_density is the constructor from densities.

helixio.dates.BusinessDayConvention

How a non-business date rolls to a business date. A member is a spelling of the core value the string names — its code() is the string the parser takes — so every parameter that takes a business-day convention takes the member or the string. The core's None (no adjustment) is the member Unadjusted, because X.None cannot be written in Python; the strings "None" and "NONE" still parse to it. A member is not equal to its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.dates.CalendarSpec

A calendar stated as data for dates.ingest_calendars: the code it binds, its holidays, and its weekend (Saturday and Sunday by default).

Method	Signature
code	code(self) — The code the calendar binds.
holidays	holidays(self) — The holidays it closes.

helixio.dates.DayCountFraction — reference

A day-count convention, named once and measured with repeatedly. Every convention is a named member — DayCountFraction.ActActIcma is DayCountFraction("ACT/ACT.ICMA") — and every parameter that takes a day count takes the member or its code. repr is the member's address; str and code() are the code.

Method	Signature
code	code(self) — The convention's canonical code.
year_fraction	year_fraction(self, start: datetime.date, end: datetime.date) — The year fraction between two dates, context-free. A convention that wants period context or a business calendar — ACT/ACT.ICMA, 30E/360.ISDA, 30U/360, BUS/252 — is answered under its context-free reading here: ACT/ACT.ICMA measures the two dates as their own reference period, and 30U/360 applies no end-of-month February rule. The two methods below give each what it wants.
year_fraction_with_context	`year_fraction_with_context(self, start: datetime.date, end: datetime.date, period_end: datetime.date, frequency: Frequency
year_fraction_with_calendar	year_fraction_with_calendar(self, start: datetime.date, end: datetime.date, calendar: Calendar) — The year fraction measured against a business calendar — what BUS/252 divides its business-day count by. Conventions that ignore the calendar return what they would have returned without one.

helixio.dates.Frequency

A coupon frequency: a named member, or a period a caller spells. Frequency("6M") is Frequency.SemiAnnual; Frequency("28D") is the 28-day markets' coupon and has no named member. Once is a single payment at maturity with no recurring period, and is refused where a schedule is generated. Every parameter that takes a frequency takes the member or its spelling; a member is not equal to its string.

Method	Signature
code	code(self) — The canonical period code ("6M"), or "ONCE".

helixio.dates.JointCalendarRule

How a joint calendar combines its members: JoinHolidays (a holiday in any member is a holiday) or JoinBusinessDays (a business day in any member is a business day).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.dates.MeetingSchedule — reference

A central bank's schedule: its published decision days, with the date each takes effect derived by the bank's rule — the Fed the next business day, the ECB the following Wednesday, the Bank of England the decision day. Pinned on a market with MarketContext.with_meetings; seeded(bank) is the embedded 2026 schedule the market uses where none is pinned.

Method	Signature
seeded	seeded(bank: str) — The embedded schedule of bank ("FED", "ECB", "BOE"); any other bank raises ValueError naming the seeded ones.
bank	bank(self) — The bank's code.
decisions	decisions(self) — The decision days, ascending.
effective_dates	effective_dates(self) — The date each decision takes effect, ascending.

helixio.dates.Period — reference

A tenor: a signed count of days, weeks, months or years, or the whole term. Period("3M") or Period(3, "M"). Equality and hashing are by duration (Period("12M") == Period("1Y")); ordering is by duration where it is decidable and raises ValueError where it is not (1M against 30D); + and - combine tenors of one unit family. Every tenor or frequency parameter takes one beside its spelling.

Method	Signature
multiplier	multiplier(self) — The signed count.
unit	unit(self) — The unit code: "D", "W", "M", "Y" or "T".
in_months	in_months(self) — The length in whole months, or None for days, weeks or the term.
in_days	in_days(self) — The length in days, or None for months, years or the term.
normalize	normalize(self) — The same tenor in the largest unit that states it exactly.

helixio.dates.RollConvention

Where a period boundary sits inside its month. A named member, or a day of the month from RollConvention.day(n) (1 to 30). The core's None (no roll) is the member Unadjusted. Every parameter that takes a roll takes the member or its spelling ("EOM", "15"); a member is not equal to its string.

Method	Signature
day	day(day: int) — A roll on the dayth of the month, from 1 to 30.
code	code(self) — The roll code ("EOM", "15").

helixio.dates.Schedule

A generated set of calculation-period boundary dates.

Method	Signature
dates	dates(self) — The boundary dates, ascending. n boundaries delimit n - 1 periods.
periods	periods(self) — The periods as (start, end) pairs.
from_dates	from_dates(dates: list[datetime.date]) — A schedule from boundary dates stated verbatim — no calendar, no roll, no business-day adjustment. A stated boundary has already had all three applied by whoever stated it, so this is the entry point for a schedule read off a confirm or another system's output, where schedule() is the one for a schedule generated from conventions. Unconventional dates are not refused — a boundary on a weekend, or periods of unequal length, are what stating dates is for. Raises ValueError only where the list is ill-formed: fewer than two dates, a descending pair, or a repeated date.
paying	`paying(self, lag_days: int, calendar: Calendar, business_day_convention: BusinessDayConvention

helixio.fpml.FpmlTrade

A trade read from an FpML 5 confirmation document.

Method	Signature
instrument	instrument(self) — The instrument the product was read into.
trade_date	trade_date(self) — The trade date from the trade header.
leg_of_stream	leg_of_stream(self) — The zero-based index into the stream instrument's legs each one-based stream was read into: a swap orders its legs by role, not as the document orders its streams.
stated_cashflows	stated_cashflows(self) — Every stream's stated cashflow rows, in document order; empty where no stream carries a cashflows block.
cashflows_match_parameters	cashflows_match_parameters(self) — Whether the document claims its stated cashflows match its parameters, or None where no stream states the flag.
id	id(self) — The reporting party's trade identifier, or the first the header states, or None.
us	us(self) — The reporting party's id attribute.
counterparty	counterparty(self) — The counterparty's id attribute, or None where the product names no other party.
components	components(self) — Every component the trade books as (suffix, instrument, quantity), the product first: its suffix empty, then /fee/1, /premium/1, ...
underlying	underlying(self) — The swap a swaption or a cancelable swap is written on, or None.
stream_instrument	stream_instrument(self) — The instrument whose legs the swap streams were read into: the underlying of a wrapper, the product otherwise. leg_of_stream indexes its legs.

helixio.fpml.StatedCashflow

One paymentCalculationPeriod a FpML stream's cashflows block states: the dates and notional the document itself says the stream pays.

Method	Signature
stream	stream(self) — The one-based swap stream the row belongs to, in document order.
payment_date	payment_date(self) — The adjusted payment date.
accrual_start	accrual_start(self) — The adjusted start of the first calculation period.
accrual_end	accrual_end(self) — The adjusted end of the last calculation period.
notional	notional(self) — The notional, where the document states one.
fixing_dates	fixing_dates(self) — The adjusted fixing dates, one per rate observation, in document order.

helixio.fx.FxOptionDiagnostics — reference

What an FX option resolved to when it was priced.

Method	Signature
forward	forward(self) — The covered-interest-parity forward to delivery, quote per one base.
strike	strike(self) — The absolute strike the option priced at.
vol	vol(self) — The vol read off the surface at that strike.
delta	delta(self) — The signed delta at that strike under the surface's convention.
expiry_years	expiry_years(self) — Time to expiry in the surface's measure, years.

helixio.legs.AccrualCompounding

How an overnight leg accumulates its prints over a period: Simple (the market's averaged leg), Compounded or Continuous. Every accrual_compounding parameter takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.legs.AnyCoupon

One coupon of the core's closed set: fixed, IBOR, overnight or redemption. Opaque — there is no constructor. A coupon is built by one of :func:fixed_rate_coupon, :func:ibor_coupon, :func:overnight_coupon or :func:redemption, which is where the set stays closed.

Method	Signature
kind	kind(self) — Which kind of coupon this is: the kind column's spelling.
payment_date	payment_date(self) — The payment date.
accrual_start	accrual_start(self) — Accrual start, or None for a coupon that accrues over nothing.
accrual_end	accrual_end(self) — Accrual end, or None for a coupon that accrues over nothing.
fixing_date	fixing_date(self) — The reset date, for a coupon that has one.
notional	notional(self) — The notional the coupon accrues on. Zero for a redemption, which accrues on nothing. Its amount is amount.
amount	amount(self) — The amount this flow pays where the contract fixes it: a redemption's stated amount, or a fixed coupon's notional times rate times year fraction. None when the rate must be projected.
year_fraction	year_fraction(self) — The accrual year fraction under the coupon's own day count.
day_count	day_count(self) — The basis the coupon accrues on, or None for one that accrues over nothing — the code the core's own vocabulary round-trips.
currency	currency(self) — The currency the coupon pays in.
contract_rate	contract_rate(self) — The rate written into the contract, for a coupon that carries one — a fixed rate, never a projection.

helixio.legs.Direction

Which side of a leg the holder is on: Receive or Pay. Every direction parameter takes the member or its string ("Pay", "payer", "short").

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.legs.ResetCompounding

How a multi-reset coupon combines its resets into one payment: the ISDA 2006 methods Straight, Flat and SpreadExclusive, or Averaged. The compounding of multi_reset_coupon takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.linker.AnbimaQuote

An ANBIMA quotation: its parcels, the cotação and the unit price.

Method	Signature
cotacao	cotacao(self) — The quotation per cent of VNA, truncated to four decimals.
unit_price	unit_price(self) — The unit price (PU) VNA · cotação / 100, truncated to six decimals.
parcels	parcels(self) — (date, du, pv) per parcel in payment order.

helixio.models.HullWhite

A validated one-factor Hull-White model: mean reversion a (strictly positive) and a volatility — a non-negative float, or (t_end, σ) pieces with strictly increasing positive ends in years, the last extending flat.

Method	Signature
mean_reversion	mean_reversion(self) — Mean-reversion speed a.
sigma	sigma(self) — Short-rate volatility: the float for a flat model, the pieces otherwise.
variance	variance(self, s: float, t: float) — V(s, t): the variance of the Gaussian factor at t given its state at s.
drift_convexity	drift_convexity(self, t: float) — C(t): the drift convexity Cov(∫₀ᵗ x, x_t).
integrated_variance	integrated_variance(self, s: float, t: float) — I(s, t): the variance of ∫ₛᵗ x given the state at s.
convexity_exponent	convexity_exponent(self, t: float, maturity: float) — Λ: the futures convexity exponent of a term rate fixing at t and running to maturity (years), E[1/P(t, T)] = P(0, t)/P(0, T)·e^Λ.
compounded_convexity_exponent	compounded_convexity_exponent(self, start: float, end: float) — The compounded futures convexity exponent from start to end (years): what with_hull_white_convexity applies to a futures rate compounded in arrears.
b	b(self, t: float, maturity: float) — B(t, T) = (1 − e^{−a(T−t)}) / a, in years.
bond_option_vol	bond_option_vol(self, expiry: float, bond_maturity: float) — The volatility of the bond_maturity discount bond seen from expiry, in years.

helixio.models.HullWhiteLattice

The Hull-White trinomial lattice, built and curve-fitted on construction.

Method	Signature
n_steps	n_steps(self) — The number of steps; there are n_steps + 1 slices.
dates	dates(self) — The slice dates, the reference date first.
times	times(self) — The slice times in years from the reference date.
step_of	step_of(self, date: datetime.date) — Exact on a grid date, else the nearest slice, or None outside the grid.
levels	levels(self, step: int) — The node levels j at step, from −half_width to half_width.
node_rate	node_rate(self, step: int, level: int) — The short rate at node (step, level).
discount_bond	discount_bond(self, maturity: datetime.date, oas: float=0.0) — A unit payment at maturity rolled back to the root under a continuous spread.

helixio.products.AssetSwapKind

How an asset swap is packaged: ParPar or Proceeds.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.BarrierKind

Where a single barrier sits and what touching it does. Every barrier_kind takes the member or its string; a member is not its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.BondFuture

A bond future: a delivery date and its resolved deliverable basket.

Method	Signature
delivery	delivery(self) — The delivery date the basket forwards to.
keys	keys(self) — The rows' keys, in basket order.

helixio.products.BondOptionEngine

Which model prices a bond option: the bond's YieldVol or HullWhite. Instrument.engine() reads the code back.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.CapFloorKind

A Cap or a Floor.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.CdsOptionStyle

What a default before a CDS option's expiry does to it: SingleName knocks out, FrontEndProtection settles it as the payer's protection, Index is an index option with its exercise price.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.CdsStrikeType

How a CDS option's strike is quoted: Spread, or Price per unit notional the holder enters the index at.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.CmeMaturityRounding

How a CME contract group rounds a deliverable's maturity: to the Month (the 2-, 3- and 5-year contracts) or the Quarter (the 10-year and bond contracts).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.ExerciseStyle

When an option on a future may be exercised: European or American.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.FixedRateBond

A fixed-rate bullet bond — the underlying of the bond-linked products.

Method	Signature
with_penultimate_coupon	with_penultimate_coupon(self, penultimate: datetime.date) — This bond with its last regular coupon on penultimate: the grid anchored there and a short or long final period to maturity, accruing by the ICMA split (notional periods forward from penultimate) under ACT/ACT ICMA.
with_first_coupon	with_first_coupon(self, first_coupon: datetime.date) — This bond with its first coupon on first_coupon: a long first period where it falls more than a period after issue, accruing by the ICMA split under ACT/ACT ICMA.
with_ex_div	`with_ex_div(self, days: int, day_type: ExDivDayType
ex_div_date	ex_div_date(self, coupon_date: datetime.date) — The ex-dividend date of the coupon paying on coupon_date, or None for a bond with no ex-dividend rule.
forgone_coupon_date	forgone_coupon_date(self, settlement: datetime.date) — The coupon date a buyer settling on settlement forgoes, or None when the bond trades cum-dividend then.
is_ex_div	is_ex_div(self, settlement: datetime.date) — Whether the bond trades ex-dividend at settlement.
with_end_of_month	with_end_of_month(self, end_of_month: bool=True) — This bond with its coupon grid rolled on the calendar end of the month. Takes effect only when the maturity is the last day of its month: every coupon date is then the last day of the month a whole number of periods before maturity (a 30 November maturity pays on 31 May; a 28 February one reaches 29 February in a leap year), where the default keeps the maturity's day of month. Precedes with_amortisation.
currency	currency(self) — The bond's currency code.
maturity	maturity(self) — The redemption date.
coupon	coupon(self) — The annual coupon rate.
face	face(self) — The face amount.
instrument	instrument(self) — This bond as an instrument — the callable with an empty exercise schedule — so a bullet books, values and tables without naming the callable; callable_bond(bond, []) is the same instrument.
issued_by	issued_by(self, issuer: str) — This bond as an instrument valued risky on issuer's credit: survival-weighted flows plus recovery of face; callable_bond(bond, [], issuer=issuer) is the same.
npv	npv(self, market: MarketContext) — The bond's value against market, through instrument().
cashflow_records	cashflow_records(self, market: MarketContext) — The bond's cashflow table against market, through instrument().
with_payment_calendar	`with_payment_calendar(self, calendar: Calendar, business_day_convention: BusinessDayConvention
with_settlement_lag	with_settlement_lag(self, days: int, calendar: Calendar) — This bond settling days business days on calendar after it trades. bonds.z_spread reads it.
settlement_date	settlement_date(self, trade_date: datetime.date) — The date a trade on trade_date settles on: the settlement lag walked from it, never before issue.
with_accrual_adjustment	`with_accrual_adjustment(self, calendar: Calendar, business_day_convention: BusinessDayConvention
payment_date	payment_date(self, accrual_end: datetime.date) — The date an accrual ending on accrual_end is paid.
with_amortisation	with_amortisation(self, outstanding: list[float]) — This bond with a notional profile: one fraction of the original face per coupon period, starting at 1, positive and never rising. Every price and flow stays per 100 of the original face; per_current_face restates one as the market's per-current-face quote.
is_amortising	is_amortising(self) — Whether any principal is repaid before maturity.
outstanding_fraction	outstanding_fraction(self, date: datetime.date) — The fraction of the original face alive on date.
current_face	current_face(self, date: datetime.date) — The face alive on date.
per_current_face	per_current_face(self, amount: float, date: datetime.date) — An amount per 100 of the original face restated per 100 of the face alive on date — the market's quote for an amortiser. Raises at or after maturity.
per_original_face	per_original_face(self, amount: float, date: datetime.date) — The inverse: per 100 of the current face restated per 100 of the original, which the pricing methods take.
flows	`flows(self, settlement: datetime.date, day_count: str
accrued	accrued(self, settlement: datetime.date) — The coupon accrued per 100 of face at settlement.
price	`price(self, yield_: float, settlement: datetime.date, price_basis: PriceBasis
yield_	`yield_(self, price: float, settlement: datetime.date, price_basis: PriceBasis
yield_moments	`yield_moments(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
modified_duration	`modified_duration(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
macaulay_duration	`macaulay_duration(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
convexity	`convexity(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
dv01	`dv01(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
money_dv01	`money_dv01(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention
money_duration	`money_duration(self, yield_: float, settlement: datetime.date, yield_convention: YieldConvention

helixio.products.OptionKind

An option's right: a Call or a Put. Every option-pricing kind takes the member or its string; a member is not its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.PremiumStyle

How an option on a future settles its premium: FuturesStyle (margined daily, Eurex and ICE) or Paid up front (CBOT).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.ProductBuilder — reference

A swap draft: a template's swap with every term defaulted, refined by verbs, struck by a stated rate or at par against a market. Template.swap(trade_date) opens one: effective at the template's spot from the trade date, ten years long, 10,000,000 notional, receiving fixed, and no fixed rate. Frozen: every with_* returns a new draft. A draft is not an instrument — it has no npv — and build() on one with no rate raises ValueError naming with_fixed_rate and at_par.

Method	Signature
with_notional	with_notional(self, notional: float) — This draft on notional.
with_fixed_rate	with_fixed_rate(self, fixed_rate: float) — This draft at fixed_rate.
with_side	with_side(self, side: str) — This draft on side: "payer" pays fixed, "receiver" receives it. Anything else raises ValueError naming the two words.
with_discount_key	with_discount_key(self, key: str) — This draft discounting on the raw key key ("USD-CSA-EUR", or a named curve such as "CSA-ACME-2026"), overriding the family's default. The escape hatch: with_csa states a CSA, this a key. The last stated wins between this, with_csa and with_counterparty.
with_csa	with_csa(self, csa: str) — This draft under the CSA csa: a collateral currency ("EUR") or the CSA's overnight index ("EUR-ESTR"), which names its currency. with_csa("EUR") on a USD draft discounts on USD-CSA-EUR, with_csa("USD") on the USD curve. Anything else raises ValueError naming both forms. The last stated wins.
with_counterparty	with_counterparty(self, counterparty: Counterparty) — This draft facing counterparty, collateralised under its CSA: a USD draft facing a EUR-CSA counterparty discounts on USD-CSA-EUR. The collateral is the last stated between this and with_csa.
with_termination	`with_termination(self, end: datetime.date
with_maturity	`with_maturity(self, end: datetime.date
build	build(self) — The instrument at the rate stated. A draft with no rate raises ValueError naming with_fixed_rate and at_par.
at_par	at_par(self, market: MarketContext) — The instrument struck at the par rate market implies on the draft's own dates — worth zero on market to the par solve's precision, carrying that rate as a number like any confirmed trade, and indistinguishable from vanilla_swap built with the same terms at it.

helixio.products.RepackEngine

How a repack note's gap is priced: Independent of rates, or Correlated through the issuer's Gaussian intensity.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.RepackRole

Who holds a booked repack note: the bank's swap facing the SPV (SwapCounterparty) or the notes per unit notional (Noteholder).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.SwaptionEngine

Which model prices a swaption: the market's vol Surface or HullWhite. Instrument.engine() reads the code back.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.SwaptionKind

Whether a swaption's holder pays (Payer) or receives (Receiver) the fixed leg on exercise. The swaption constructors' kind takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.SwaptionSettlement

How a swaption settles on exercise: into the swap (Physical) or for its value (Cash).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.products.ValuationTrigger

A repack note's valuation trigger: terminate when the collateral's market value falls below level of notional on a monitoring date, selling it liquidation_lag_days later.

Method	Signature
level	level(self) — The trigger level as a fraction of notional.
monitoring	monitoring(self) — The monitoring dates.
liquidation_lag_days	liquidation_lag_days(self) — Calendar days from a breach to the sale.

helixio.risk.Aggregation

How a sensitivity is collapsed for reporting: one row (Total), a row per tenor bucket, per curve (ByCurve), or per contribution (Ladder).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.risk.Axis

What a sensitivity is to: the risk axes a report and a frame read. Every axis parameter takes the member or its string ("rate", "security_spread"); a member is not its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.risk.Basis

Whose quote a sensitivity is expressed against: the curve nodes' own (Zero) or the calibrating instruments' (Par).

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.risk.ExplainReport

The step-revaluation explain: the prints that became known first, then one leg per axis, telescoping exactly.

Method	Signature
legs	legs(self) — The legs, (axis, contribution): across days cash and carry first, then resets where the ending market publishes prints the starting one lacks, then the axes, and last the empty-axis leg, what no axis explains.
order	order(self) — The axis order the legs were taken in.
before	before(self) — The value before the move.
after	after(self) — The value after the move.
cash	cash(self) — The cash paid between the two dates; zero within one day.
actual	actual(self) — after − before + cash.
explained	explained(self) — The sum of the legs.

helixio.risk.Measure

A quantity a report asks for: Measure.Npv, or a first-order sensitivity on an axis against a basis, collapsed by an aggregation, in a scale — what the grammar spells delta:<axis>[:<basis>[:<aggregation>]][:<scale>]. A value beside the string, never instead of it: code() and str print the grammar, Measure(spelling) parses it, delta(...) builds one from typed parts, and Book.report takes either. Equal and hashable by value; repr reads back.

Method	Signature
code	code(self) — The grammar spelling, as a report row prints it.
axis	axis(self) — The axis, or None for Npv.
basis	basis(self) — The basis, or None for Npv.
aggregation	aggregation(self) — The aggregation, or None for Npv.
scale	scale(self) — The scale the measure states, or None where it states none — a value, or a delta left to the book's and the preset's defaults.

helixio.risk.PredictedPnl

The predicted explain: first order from risk plus one second-order pass.

Method	Signature
rows	rows(self) — Each market input's contribution, (input, risk × move).
by_axis	by_axis(self) — The rows summed by axis, (axis, contribution); None for an input on no axis.
first_order	first_order(self) — The sum of the first-order rows.
quadratic	quadratic(self) — The one-pass second-order term along the move.
own_gamma	own_gamma(self) — The quadratic's own-gamma terms, (axis, value) per axis group that moved, an empty axis for the inputs on no axis.
cross_gamma	cross_gamma(self) — The quadratic's cross-gamma terms, (axis, other, value) per pair of moved groups, one symmetric number each.
gamma_closure	gamma_closure(self) — quadratic less the own and cross terms: round-off, reported as a health check of the split.
resets	resets(self) — The reset step: the exact revaluation from each new print's forecast to the print, for the prints after holds and before does not; zero when there are none. resets + first_order + quadratic + residual is actual.
before	before(self) — The value before the move — with each new print standing at the forecast it replaced, where there are any.
after	after(self) — The value after the move.
actual	actual(self) — after − before.
residual	residual(self) — What the reset step and the first and second order together leave unexplained.

helixio.risk.Preset

A named risk measure — DV01, PAR_LADDER, CS01 — and the scale it reports in.

Method	Signature
name	name(self) — The name a report row is keyed by.
asset_class	asset_class(self) — The asset class it is filed under — rates, credit, fx, inflation — or None for NPV.
measure	measure(self) — The measure's spelling, with its stated scale where one was stated.
default_scale	default_scale(self) — The scale it reports in by default, when nothing else states one.
how	how(self) — report, or the method that computes it outside a report.
requires	requires(self) — What the market must hold beyond the trades' own curves.
per	`per(self, scale: Scale

helixio.risk.Reconciliation

The two explains aligned by axis.

Method	Signature
rows	rows(self) — (axis, predicted, explained, difference, own_gamma, cross_gamma, residual) per leg: the first-order term from risk, the ladder's leg, the leg less the prediction, and that difference decomposed into the leg's own gamma, its cross gamma with the axes moved before it, and the residual the two leave. The resets row, present when a print became known, has both terms equal to the reset step and the three decomposed terms zero.
total_difference	total_difference(self) — The sum of the rows' differences.
total_residual	total_residual(self) — The sum of the rows' residuals: the prediction's closure plus residual within round-off.

helixio.risk.ResetPnl

The reset step read per print: what each print the ending market holds and the starting market does not made against the forecast it replaced.

Method	Signature
rows	rows(self) — One row per print published or restated, in date order: index, date, forecast (what the print replaced — the index's own forecast off the starting market's projection curve, at the curve's reference date where the print is dated before it, or the value the starting market held for a restated print), print, move_bp, risk_bp (the book's sensitivity to the print on the ending market, per basis point) and pnl, the exact revaluation from the forecast to the print with the earlier prints already published.
before	before(self) — The book's value with each print standing at the forecast it replaced: what the book carried while the prints were projected.
after	after(self) — The book's value with every print published.
total	total(self) — The step itself, after − before, which the rows' pnl sum to and the explain's resets leg carries.

helixio.risk.Scale

The unit a sensitivity is reported in: Scale.Unit (per unit move of the quote), Scale.Bp, Scale.Percent, Scale.VolPoint, or Scale.custom(factor). Spelled unit, bp, pct, volpt or x<factor>.

Method	Signature
custom	custom(factor: float) — Per factor of the quote, for any other multiple.
factor	factor(self) — The multiplier a per-unit reading is taken by.
code	code(self) — The spelling the grammar and every scale= argument take.

helixio.risk.Scales

A book's default scale per quantity kind: rate, spread, vol, recovery, correlation, fx.

Method	Signature
get	get(self, kind: str) — The scale stated for kind, or None.

helixio.risk.ShiftType

Whether a scenario leg moves its inputs relatively, x·(1 + s), or absolutely, x + s. Unset, each input keeps its own convention: curves absolute, FX spots and vols relative. Scenario's builders take the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.CpiVolSurface

A zero-coupon CPI option vol surface over expiry x annualised zero-coupon strike, pinned per price index: lognormal is Black on the forward index ratio I(T)/I(T0) at strike (1+k)^tau, normal is Bachelier on that ratio (the vol in ratio units). Read at the time from the first of the month of (valuation - lag) to maturity - lag, ACT/365F.

Method	Signature
flat	`flat(vol: float, vol_convention: VolConvention
expiries	expiries(self) — The expiries the grid is quoted on, in years.
strikes	strikes(self) — The annualised strikes the smile is quoted on; None on a flat surface.
vol_convention	vol_convention(self) — Whether the vols are normal or lognormal.
vol	vol(self, expiry_years: float, strike: float) — The vol at expiry_years and the annualised strike.

helixio.vols.CreditVolSurface

The Black volatility of a credit name's forward CDS spread by option expiry, in years: linear in total variance between quoted expiries, flat beyond them.

Method	Signature
flat	flat(vol: float) — One vol at every expiry.
points	points(self) — The quoted (expiry_years, vol) points, in order.
vol	vol(self, expiry_years: float) — The vol at expiry_years.

helixio.vols.DeltaConvention

How an FX delta is quoted: Spot or Fwd, each plain or premium-adjusted (PaSpot, PaFwd). Every delta_convention parameter takes the member or its string ("spot", "forward_premium"). A member is not its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.FutureOptionVolSurface

A listed bond future's option vol surface over listed expiry dates x strikes per 100 face, pinned per contract: lognormal is a Black-76 price vol, normal a Bachelier price vol in points per year. Sticky-strike: linear in vol between strikes, linear in total variance between expiries, flat beyond every edge; time is day_count (ACT/365F unless stated) from reference.

Method	Signature
flat	`flat(reference: datetime.date, vol: float, vol_convention: VolConvention
day_count	day_count(self) — The day count the vols are quoted per year of.
reference	reference(self) — The date the surface was marked on.
expiries	expiries(self) — The listed expiries; empty on a flat surface.
strikes	strikes(self) — The strikes, per 100; empty on a flat surface.
vol_convention	vol_convention(self) — Whether the vols are normal or lognormal.
vol	vol(self, expiry: datetime.date, strike: float) — The vol at expiry and strike.

helixio.vols.FxVolSmile

One expiry's smile: (quote, vol) nodes, the quote spelled as the market spells it — "25P", "ATM", "25C" — held from the lowest strike's quote to the highest's.

Method	Signature
from_quotes	from_quotes(atm: float, risk_reversal: float, butterfly: float) — The ATM vol and the 25-delta wings from a risk reversal and a butterfly.
quotes	quotes(self) — The node quotes, in smile order: puts, ATM, calls.
vols	vols(self) — The node vols, in smile order.

helixio.vols.FxVolSurface — reference

An FX volatility surface: one smile per expiry.

Method	Signature
expiries	expiries(self) — The expiries the surface has smiles at.
day_count	day_count(self) — The measure the surface's total variance is counted in.
smile	smile(self, expiry: datetime.date) — The smile stored at exactly expiry, not an interpolation.
quotes	quotes(self) — The quotes every smile carries, in smile order: puts, ATM, calls.
vol_at_quote	vol_at_quote(self, expiry: datetime.date, quote: str) — The vol the surface holds for quote at expiry: the node itself at a stored expiry, or its blend in total variance between the stored expiries either side, flat beyond the ends. A node read, before any strike is resolved.
vol_at_strike	vol_at_strike(self, expiry: datetime.date, strike: float, forward: float, df_base: float) — The vol at strike for an option expiring at expiry, given the pair's forward to delivery and the base currency's discount factor df_base: each node placed at the strike its quote resolves to, then linear in log-moneyness between the adjacent node strikes and flat beyond the wings; across expiries linear in total variance.
strike_at_delta	strike_at_delta(self, expiry: datetime.date, delta: float, forward: float, df_base: float) — The strike at which an option expiring at expiry has delta under the smile's own vol at that strike — the strike-vol fixed point a delta-labelled trade resolves to — given the pair's forward and the base currency's discount factor df_base, in the surface's delta convention. A positive delta is a call's, a negative one a put's. vols.strike_from_delta is the same read at one fixed vol.

helixio.vols.RateVolSurface — reference

A rate volatility surface on an expiry x tenor grid, optionally smiled.

Method	Signature
day_count	day_count(self) — The day count the expiry axis is measured on.
smile	`smile(expiries: list[float], tenor_years: float, strikes: list[float], vols: list[list[float]], vol_convention: VolConvention
cube	`cube(expiries: list[float], tenors: list[float], strikes: list[float], vols: list[list[list[float]]], vol_convention: VolConvention
expiries	expiries(self) — The expiries the grid is quoted on, in years.
tenors	tenors(self) — The tenors the grid is quoted on, in years.
strike_axis	strike_axis(self) — What the strike pillars measure: absolute or spread_to_atm.
strikes	strikes(self) — The strikes the smile is quoted on, where the surface carries one.
vol	`vol(self, expiry_years: float, tenor_years: float, strike: float
vol_convention	vol_convention(self) — Whether the vols are normal or lognormal. Spelled the same as the constructor's keyword, so a value read out of one surface passes straight back into another without being renamed in the caller's hands.

helixio.vols.SabrFit

A fitted SABR surface and the diagnostics of each slice that built it.

Method	Signature
surface	surface(self) — The fitted surface, carrying its quote Jacobian.
diagnostics	diagnostics(self) — One row per slice: node, forward, parameters, errors, restarts, and whether it was accepted and passed the butterfly check.

helixio.vols.SabrFormula

The expansion a SABR smile is read under: Hagan's lognormal (HaganLognormal), Hagan's normal (HaganNormal), or the normal beta = 0 form that reads a negative forward (NormalBetaZero). Every formula parameter takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.SabrSpec

How a grid is fitted to SABR: the formula, beta and the shift, all stated, and the acceptance — the RMS vol error as a fraction of a slice's mean quote — with the Halton restarts a slice may spend reaching it.

Method	Signature
formula	formula(self) — The formula's spelling.
beta	beta(self) — The CEV exponent.
shift	shift(self) — The displacement.
accept	accept(self) — The acceptance, as a fraction of a slice's mean quote.
max_restarts	max_restarts(self) — The Halton restarts a slice may spend.

helixio.vols.SabrVolSurface

A SABR rate smile over expiry x tenor: ATM vol, rho and nu at each node, beta and the shift stated once, alpha implied at each read from the ATM vol at the read's own forward. Pinned with with_swaption_vols or with_cap_vols beside a grid.

Method	Signature
expiries	expiries(self) — The expiry pillars, in years.
tenors	tenors(self) — The tenor pillars, in years.
formula	formula(self) — The formula's spelling.
beta	beta(self) — The CEV exponent.
shift	shift(self) — The displacement.
vol_convention	vol_convention(self) — The convention the formula's vols are quoted in.
node_parameters	node_parameters(self, expiry_years: float, tenor_years: float) — (atm_vol, rho, nu) at a point: bilinear between nodes, flat beyond.
vol	vol(self, expiry_years: float, tenor_years: float, forward: float, strike: float) — The smile's vol for strike at forward, in the formula's convention.
is_fitted	is_fitted(self) — Whether the surface was fitted, carrying the quote Jacobian a par vega reads.

helixio.vols.StrikeAxis

What a cube's strikes measure: an Absolute rate, or a SpreadToAtm over the forward. Every strike_axis parameter takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.StripScheme

How caplet vols are stripped from cap quotes: ConstantBetweenQuotes or one vol PerCaplet. The strippers' scheme takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.VolConvention

How a rate volatility is quoted: Normal (basis-point) or Lognormal. Every vol_convention parameter takes the member or its string.

Method	Signature
code	code(self) — The core's canonical code — the string the parser would take.

helixio.vols.YoyVolSurface

A year-on-year inflation optionlet vol surface over expiry x absolute YoY strike, pinned per price index: normal or lognormal, a lognormal one optionally displaced (a displacement of one prices on 1 + rate). Each optionlet reads it at the time from the first of the month of (valuation - lag) to its period end - lag, ACT/365F.

Method	Signature
flat	`flat(vol: float, vol_convention: VolConvention
expiries	expiries(self) — The expiries the grid is quoted on, in years.
strikes	strikes(self) — The strikes the smile is quoted on; None on a flat surface.
vol_convention	vol_convention(self) — Whether the vols are normal or lognormal.
displacement	displacement(self) — The lognormal displacement; zero on a normal or plain Black surface.
vol	vol(self, expiry_years: float, strike: float) — The vol at expiry_years and the absolute YoY strike.