mainsequence 2.0.0__py3-none-any.whl

mainsequence/instruments/instruments/ql_fields.py

@@ -0,0 +1,239 @@
+# src/instruments/ql_fields.py
+from __future__ import annotations
+
+import inspect
+from typing import Optional, Dict, Any
+from typing_extensions import Annotated
+from pydantic import BeforeValidator, PlainSerializer, WithJsonSchema
+import QuantLib as ql
+
+# Reuse your existing codec helpers
+from mainsequence.instruments.instruments.json_codec import (
+    # Period
+    period_to_json, period_from_json,
+    # DayCounter
+    daycount_to_json, daycount_from_json,
+    # Calendar
+    calendar_to_json, calendar_from_json,
+    # BDC
+    bdc_to_json, bdc_from_json,
+    # IborIndex (used only for legacy conversion)
+    ibor_to_json, ibor_from_json,
+    # Schedule
+    schedule_to_json, schedule_from_json,
+)
+
+# ============================================================================
+# Automatic Calendar Factory
+# ============================================================================
+
+def _build_fully_automatic_calendar_factory() -> Dict[str, callable]:
+    """
+    Build a mapping: <calendar display name> -> zero-arg callable that returns ql.Calendar
+    We try both no-arg constructors and Market-enum constructors.
+
+    Examples of keys (display names):
+      - "TARGET"
+      - "Mexican stock exchange"      (ql.Mexico())
+      - "New York stock exchange"     (ql.UnitedStates(ql.UnitedStates.NYSE))
+      - "United States settlement"    (ql.UnitedStates(ql.UnitedStates.Settlement))
+      - "London stock exchange"       (ql.UnitedKingdom(ql.UnitedKingdom.LSE))
+    """
+    factory: Dict[str, callable] = {}
+
+    def _try_register(ctor):
+        try:
+            inst = ctor()
+            name = inst.name()
+            # Keep first seen mapping; if duplicates exist, first one wins.
+            factory.setdefault(name, ctor)
+            return True
+        except Exception:
+            return False
+
+    # Iterate over all QuantLib classes; find Calendar subclasses (excluding base Calendar)
+    for _, cls in inspect.getmembers(ql, predicate=inspect.isclass):
+        try:
+            if not issubclass(cls, ql.Calendar) or cls is ql.Calendar:
+                continue
+        except TypeError:
+            # Some SWIG artifacts aren't proper classes for issubclass; skip them
+            continue
+
+        # Case A: try no-arg constructor (e.g., TARGET, Mexico, Turkey, etc.)
+        _try_register(lambda c=cls: c())
+
+        # Case B: try int-valued attributes on the class (likely Market enums)
+        for attr_name, attr_val in inspect.getmembers(cls):
+            if attr_name.startswith("_"):
+                continue
+            if isinstance(attr_val, int):
+                _try_register(lambda c=cls, e=attr_val: c(e))
+
+        # Case C: nested 'Market' enum classes (common in recent QuantLib builds)
+        for attr_name, attr_val in inspect.getmembers(cls):
+            if not inspect.isclass(attr_val):
+                continue
+            if attr_name.lower().startswith("market"):
+                for mname, mval in inspect.getmembers(attr_val):
+                    if mname.startswith("_"):
+                        continue
+                    if isinstance(mval, int):
+                        _try_register(lambda c=cls, e=mval: c(e))
+
+    return factory
+
+
+# Build once; also a case-insensitive mirror for defensive lookups.
+_CAL_FACTORY: Dict[str, callable] = _build_fully_automatic_calendar_factory()
+_CAL_FACTORY_CI: Dict[str, callable] = {k.casefold(): v for k, v in _CAL_FACTORY.items()}
+
+
+def calendar_from_display_name(name: str) -> ql.Calendar:
+    """
+    Rebuild a QuantLib calendar from its display name (Calendar::name()).
+    Example: "Mexican stock exchange" -> ql.Mexico()
+    """
+    ctor = _CAL_FACTORY.get(name) or _CAL_FACTORY_CI.get(name.casefold())
+    if ctor is None:
+        raise ValueError(f"Unsupported calendar display name {name!r}. "
+                         "Available: " + ", ".join(sorted(_CAL_FACTORY.keys())[:20]) + ("..." if len(_CAL_FACTORY) > 20 else ""))
+    return ctor()
+
+
+# ============================================================================
+# Strict serializers that force the real calendar name via virtual .name()
+# ============================================================================
+
+def _calendar_to_json_actual(cal: ql.Calendar) -> Dict[str, Any]:
+    """
+    Serialize as {'name': cal.name()} using the virtual method.
+    Works even if 'cal' is a base Calendar proxy returned by SWIG.
+    """
+    return {"name": cal.name()}
+
+def _schedule_to_json_actual(s: Optional[ql.Schedule]) -> Optional[Dict[str, Any]]:
+    """
+    Serialize a schedule; ensure its calendar is emitted with the true display name.
+    """
+    if s is None:
+        return None
+    data = schedule_to_json(s)  # keep your canonical fields (dates, BDCs, EOM, rule, etc.)
+    try:
+        data["calendar"] = {"name": s.calendar().name()}
+    except Exception:
+        pass
+    return data
+
+
+# ============================================================================
+# Lenient deserializers that accept {'name': '<display name>'}
+# ============================================================================
+
+def _calendar_from_json_auto(v):
+    """
+    Accept:
+      - ql.Calendar (pass-through)
+      - {'name': '<display name>'}  -> rebuilt via factory
+      - str '<display name>'        -> rebuilt via factory
+      - else -> delegate to existing calendar_from_json
+    """
+    if isinstance(v, ql.Calendar):
+        return v
+    if isinstance(v, dict):
+        nm = v.get("name")
+        if isinstance(nm, str) and nm and nm != "Calendar":
+            return calendar_from_display_name(nm)
+    if isinstance(v, str) and v and v != "Calendar":
+        return calendar_from_display_name(v)
+    # Fallback to your existing helper (may accept other legacy formats)
+    return calendar_from_json(v)
+
+def _schedule_from_json_auto(v):
+    """
+    If schedule JSON contains {'calendar': {'name': '<display name>'}},
+    rebuild a concrete ql.Calendar first, then delegate to schedule_from_json.
+    """
+    if v is None or isinstance(v, ql.Schedule):
+        return v
+    if isinstance(v, dict) and "calendar" in v:
+        cal_spec = v["calendar"]
+        # Rebuild calendar if we have a display name
+        try:
+            v = dict(v)
+            v["calendar"] = _calendar_from_json_auto(cal_spec)
+        except Exception:
+            # Leave as-is; schedule_from_json may still handle it
+            pass
+    return schedule_from_json(v)
+
+
+# ============================================================================
+# Pydantic Annotated field types
+# ============================================================================
+
+# ---------- Period -----------------------------------------------------------
+QuantLibPeriod = Annotated[
+    ql.Period,
+    BeforeValidator(period_from_json),
+    PlainSerializer(period_to_json, return_type=str),
+]
+
+# ---------- DayCounter -------------------------------------------------------
+QuantLibDayCounter = Annotated[
+    ql.DayCounter,
+    BeforeValidator(daycount_from_json),
+    PlainSerializer(daycount_to_json, return_type=str),
+]
+
+# ---------- Calendar ---------------------------------------------------------
+QuantLibCalendar = Annotated[
+    ql.Calendar,
+    BeforeValidator(_calendar_from_json_auto),          # <— use factory-based loader
+    PlainSerializer(_calendar_to_json_actual, return_type=Dict[str, Any]),  # <— always emit true name
+]
+
+# ---------- Business Day Convention (BDC) -----------------------------------
+def _bdc_from_any(v):
+    return bdc_from_json(v)
+
+def _bdc_to_str(v: int) -> str:
+    return str(bdc_to_json(int(v)))
+
+QuantLibBDC = Annotated[
+    int,
+    BeforeValidator(_bdc_from_any),
+    PlainSerializer(_bdc_to_str, return_type=str),
+]
+
+# ---------- Schedule ---------------------------------------------------------
+QuantLibSchedule = Annotated[
+    Optional[ql.Schedule],
+    BeforeValidator(_schedule_from_json_auto),           # <— rebuild calendar from display name first
+    PlainSerializer(_schedule_to_json_actual, return_type=Optional[Dict[str, Any]]),  # <— emit true name
+    WithJsonSchema(
+        {
+            "type": ["object", "null"],
+            "properties": {
+                "dates": {"type": "array", "items": {"type": "string", "pattern": r"^\d{4}-\d{2}-\d{2}$"}},
+                "calendar": {"type": "object"},  # {"name": "<display name from cal.name()>"}
+                "business_day_convention": {"type": ["string", "integer"]},
+                "termination_business_day_convention": {"type": ["string", "integer"]},
+                "end_of_month": {"type": "boolean"},
+                "tenor": {"type": "string"},
+                "rule": {"type": ["string", "integer"]},
+            },
+            "required": ["dates"],
+            "additionalProperties": True,
+        },
+        mode="serialization",
+    ),
+]
+
+__all__ = [
+    "QuantLibPeriod",
+    "QuantLibDayCounter",
+    "QuantLibCalendar",
+    "QuantLibBDC",
+    "QuantLibSchedule",
+]

mainsequence/instruments/instruments/vanilla_fx_option.py

@@ -0,0 +1,107 @@
+import datetime
+from typing import Optional, Literal
+
+import QuantLib as ql
+from pydantic import BaseModel, Field, PrivateAttr
+
+from mainsequence.instruments.pricing_models.fx_option_pricer import create_fx_garman_kohlhagen_model, get_fx_market_data
+from mainsequence.instruments.utils import to_ql_date
+from .base_instrument import InstrumentModel
+
+
+class VanillaFXOption(InstrumentModel):
+    """Vanilla FX option priced with Garman-Kohlhagen model."""
+
+    currency_pair: str = Field(
+        ..., description="Currency pair in format 'EURUSD', 'GBPUSD', etc. (6 characters)."
+    )
+    strike: float = Field(
+        ..., description="Option strike price (domestic currency per unit of foreign currency)."
+    )
+    maturity: datetime.date = Field(
+        ..., description="Option expiration date."
+    )
+    option_type: Literal["call", "put"] = Field(
+        ..., description="Option type: 'call' or 'put'."
+    )
+    notional: float = Field(
+        ..., description="Notional amount in foreign currency units."
+    )
+
+
+    # Allow QuantLib types & keep runtime attrs out of the schema
+    model_config = {"arbitrary_types_allowed": True}
+
+    # Runtime-only QuantLib objects
+    _option: Optional[ql.VanillaOption] = PrivateAttr(default=None)
+    _engine: Optional[ql.PricingEngine] = PrivateAttr(default=None)
+
+    def _setup_pricing_components(self) -> None:
+        """Set up the QuantLib pricing components for the FX option."""
+        # 1) Validate currency pair format
+        if len(self.currency_pair) != 6:
+            raise ValueError("Currency pair must be 6 characters (e.g., 'EURUSD')")
+        
+        # 2) Get FX market data
+        market_data = get_fx_market_data(self.currency_pair, self.valuation_date)
+        spot_fx = market_data["spot_fx_rate"]
+        vol = market_data["volatility"]
+        domestic_rate = market_data["domestic_rate"]
+        foreign_rate = market_data["foreign_rate"]
+
+        # 3) Convert dates to QuantLib format
+        ql_calc = to_ql_date(self.valuation_date)
+        ql_mty = to_ql_date(self.maturity)
+        ql.Settings.instance().evaluationDate = ql_calc
+
+        # 4) Create Garman-Kohlhagen process
+        process = create_fx_garman_kohlhagen_model(
+            ql_calc, spot_fx, vol, domestic_rate, foreign_rate
+        )
+
+        # 5) Create instrument and engine
+        payoff = ql.PlainVanillaPayoff(
+            ql.Option.Call if self.option_type == "call" else ql.Option.Put, 
+            self.strike
+        )
+        exercise = ql.EuropeanExercise(ql_mty)
+        self._option = ql.VanillaOption(payoff, exercise)
+        self._engine = ql.AnalyticEuropeanEngine(process)
+        self._option.setPricingEngine(self._engine)
+
+    def price(self) -> float:
+        """Calculate the option price (NPV)."""
+        if not self._option:
+            self._setup_pricing_components()
+        # Return price multiplied by notional
+        return float(self._option.NPV() * self.notional)
+
+    def get_greeks(self) -> dict:
+        """Calculate the option Greeks."""
+        if not self._option:
+            self._setup_pricing_components()
+            self._option.NPV()  # Ensure calculations are performed
+        
+        return {
+            "delta": self._option.delta() * self.notional,
+            "gamma": self._option.gamma() * self.notional,
+            "vega": self._option.vega() * self.notional / 100.0,  # Convert to 1% vol change
+            "theta": self._option.theta() * self.notional / 365.0,  # Convert to per day
+            "rho_domestic": self._option.rho() * self.notional / 100.0,  # Convert to 1% rate change
+        }
+
+    def get_market_info(self) -> dict:
+        """Get the market data used for pricing."""
+        market_data = get_fx_market_data(self.currency_pair, self.valuation_date)
+        foreign_ccy = self.currency_pair[:3]
+        domestic_ccy = self.currency_pair[3:]
+        
+        return {
+            "currency_pair": self.currency_pair,
+            "foreign_currency": foreign_ccy,
+            "domestic_currency": domestic_ccy,
+            "spot_fx_rate": market_data["spot_fx_rate"],
+            "volatility": market_data["volatility"],
+            "domestic_rate": market_data["domestic_rate"],
+            "foreign_rate": market_data["foreign_rate"]
+        }

mainsequence/instruments/pricing_models/black_scholes.py

@@ -0,0 +1,49 @@
+import QuantLib as ql
+
+
+def create_bsm_model(
+        calculation_date: ql.Date,
+        spot_price: float,
+        volatility: float,
+        risk_free_rate: float,
+        dividend_yield: float
+) -> ql.BlackScholesMertonProcess:
+    """
+    Sets up the Black-Scholes-Merton process in QuantLib.
+
+    Args:
+        calculation_date: The date for which the pricing is being performed.
+        spot_price: The current price of the underlying asset.
+        volatility: The annualized volatility of the underlying asset.
+        risk_free_rate: The annualized risk-free interest rate.
+        dividend_yield: The annualized dividend yield of the underlying asset.
+
+    Returns:
+        A QuantLib BlackScholesMertonProcess object configured with the market data.
+    """
+    # Set the evaluation date in QuantLib
+    ql.Settings.instance().evaluationDate = calculation_date
+
+    # Define underlying asset price and curves
+    underlying_handle = ql.QuoteHandle(ql.SimpleQuote(spot_price))
+
+    day_count = ql.Actual365Fixed()
+
+    flat_ts = ql.YieldTermStructureHandle(
+        ql.FlatForward(calculation_date, risk_free_rate, day_count)
+    )
+
+    dividend_ts = ql.YieldTermStructureHandle(
+        ql.FlatForward(calculation_date, dividend_yield, day_count)
+    )
+
+    flat_vol_ts = ql.BlackVolTermStructureHandle(
+        ql.BlackConstantVol(calculation_date, ql.TARGET(), volatility, day_count)
+    )
+
+    # Create the Black-Scholes-Merton process
+    bsm_process = ql.BlackScholesMertonProcess(
+        underlying_handle, dividend_ts, flat_ts, flat_vol_ts
+    )
+
+    return bsm_process

mainsequence/instruments/pricing_models/bond_pricer.py

@@ -0,0 +1,182 @@
+# mainsequence/instruments/pricing_models/bond_pricer.py
+import QuantLib as ql
+from typing import List, Dict, Any, Optional
+from mainsequence.instruments.data_interface import data_interface
+from mainsequence.instruments.utils import to_ql_date
+import datetime
+import matplotlib.pyplot as plt
+
+
+def _map_daycount(dc: str) -> ql.DayCounter:
+    s = (dc or '').upper()
+    if s.startswith('30/360'):
+        return ql.Thirty360(ql.Thirty360.USA)
+    if s in ('ACT/365', 'ACT/365F', 'ACTUAL/365', 'ACTUAL/365F'):
+        return ql.Actual365Fixed()
+    if s in ('ACT/ACT', 'ACTUAL/ACTUAL'):
+        return ql.ActualActual()
+    return ql.Thirty360(ql.Thirty360.USA)
+
+
+
+
+
+
+def create_fixed_rate_bond(
+        calculation_date: ql.Date,
+        face: float,
+        issue_date: ql.Date,
+        maturity_date: ql.Date,
+        coupon_rate: float,
+        coupon_frequency: ql.Period,
+        day_count: ql.DayCounter,
+        calendar: ql.Calendar = ql.TARGET(),
+        business_day_convention: int = ql.Following,  # enums are ints in the Python wrapper
+        settlement_days: int = 2,
+        discount_curve: Optional[ql.YieldTermStructureHandle] = None,
+        schedule: Optional[ql.Schedule] = None,
+
+) -> ql.FixedRateBond:
+    """Construct and engine-attach."""
+    ql.Settings.instance().evaluationDate = calculation_date
+
+
+
+
+    # --------- Schedule ----------
+    if schedule is None:
+        schedule = ql.Schedule(
+            issue_date, maturity_date, coupon_frequency, calendar,
+            business_day_convention, business_day_convention,
+            ql.DateGeneration.Forward, False
+        )
+    else:
+        asof = ql.Settings.instance().evaluationDate
+        n = len(schedule.dates())
+        # True floater periods exist only if schedule has >=2 dates AND at least one period end > as-of date.
+        has_periods_left = (n >= 2) and any(schedule.dates()[i + 1] > asof for i in range(n - 1))
+        if not has_periods_left:
+            # Redemption-only: price as a zero-coupon bond (par redemption by default).
+            maturity = schedule.dates()[n-1] if n > 0 else maturity_date
+            zcb = ql.ZeroCouponBond(
+                settlement_days,
+                calendar,  # use the same calendar as above
+                face,  # notional
+                maturity,  # maturity date
+                business_day_convention,  # payment convention (for settlement)
+                100.0,  # redemption (% of face)
+                issue_date  # issue date
+            )
+            zcb.setPricingEngine(ql.DiscountingBondEngine(discount_curve))
+            return zcb
+
+
+    bond = ql.FixedRateBond(settlement_days, face, schedule, [coupon_rate], day_count)
+    bond.setPricingEngine(ql.DiscountingBondEngine(discount_curve))
+    return bond
+
+
+def create_floating_rate_bond_with_curve(
+        *,
+        calculation_date: ql.Date,
+        face: float,
+        issue_date: ql.Date,
+        maturity_date: ql.Date,
+        floating_rate_index: ql.IborIndex,
+        spread: float = 0.0,
+        coupon_frequency: ql.Period | None = None,
+        day_count: ql.DayCounter | None = None,
+        calendar: ql.Calendar | None = None,
+        business_day_convention: int = ql.Following,
+        settlement_days: int = 2,
+        curve: ql.YieldTermStructureHandle,
+        seed_past_fixings_from_curve: bool = True,
+        discount_curve: Optional[ql.YieldTermStructureHandle] = None,
+        schedule: Optional[ql.Schedule] = None,
+) -> ql.FloatingRateBond:
+    """
+    Build/prices a floating-rate bond like your swap-with-curve:
+      - clone index to 'curve'
+      - spot-start safeguard
+      - seed past/today fixings from the same curve
+      - discount with the same curve
+    """
+
+    # --- evaluation settings (match swap) ---
+    ql.Settings.instance().evaluationDate = calculation_date
+    ql.Settings.instance().includeReferenceDateEvents = False
+    ql.Settings.instance().enforceTodaysHistoricFixings = False
+
+    if curve is None:
+        raise ValueError("create_floating_rate_bond_with_curve: 'curve' is None")
+    # Probe the handle by attempting a discount on calculation_date.
+    # If the handle is unlinked/invalid this will raise; we convert it to a clear message.
+    try:
+        _ = curve.discount(calculation_date)
+    except Exception as e:
+        raise ValueError(
+            "create_floating_rate_bond_with_curve: provided curve handle "
+            "is not linked or cannot discount on calculation_date"
+        ) from e
+
+    # --- index & calendars ---
+    pricing_index = floating_rate_index.clone(curve)  # forecast on the provided curve
+    cal = calendar or pricing_index.fixingCalendar()
+    freq = coupon_frequency or pricing_index.tenor()
+    dc = day_count or pricing_index.dayCounter()
+
+    eff_start = issue_date
+    eff_end = maturity_date
+
+    # --------- Schedule ----------
+    if schedule is None:
+        schedule = ql.Schedule(
+            eff_start, eff_end, freq, cal,
+            business_day_convention, business_day_convention,
+            ql.DateGeneration.Forward, False
+        )
+    else:
+        asof = ql.Settings.instance().evaluationDate
+        n = len(schedule.dates())
+        # True floater periods exist only if schedule has >=2 dates AND at least one period end > as-of date.
+        has_periods_left = (n >= 2) and any(schedule.dates()[i + 1] > asof for i in range(n - 1))
+        if not has_periods_left:
+            # Redemption-only: price as a zero-coupon bond (par redemption by default).
+            maturity = schedule.dates()[n-1] if n > 0 else eff_end
+            zcb = ql.ZeroCouponBond(
+                settlement_days,
+                cal,  # use the same calendar as above
+                face,  # notional
+                maturity,  # maturity date
+                business_day_convention,  # payment convention (for settlement)
+                100.0,  # redemption (% of face)
+                issue_date  # issue date
+            )
+            zcb.setPricingEngine(ql.DiscountingBondEngine(curve))
+            return zcb
+
+
+    # --------- Instrument ----------
+    try:
+        bond = ql.FloatingRateBond(
+            settlement_days,
+            face,
+            schedule,
+            pricing_index,
+            dc,
+            business_day_convention,
+            pricing_index.fixingDays(),
+            [1.0],  # gearings
+            [spread],  # spreads
+            [], [],  # caps, floors
+            False,  # inArrears
+            100.0,  # redemption
+            issue_date
+        )
+    except Exception as e:
+        raise e
+
+
+
+    return bond
+

mainsequence/instruments/pricing_models/fx_option_pricer.py

@@ -0,0 +1,90 @@
+import QuantLib as ql
+from mainsequence.instruments.data_interface import data_interface, DateInfo
+
+
+def create_fx_garman_kohlhagen_model(
+        calculation_date: ql.Date,
+        spot_fx_rate: float,
+        volatility: float,
+        domestic_rate: float,
+        foreign_rate: float
+) -> ql.BlackScholesMertonProcess:
+    """
+    Sets up the Garman-Kohlhagen process for FX options in QuantLib.
+    
+    The Garman-Kohlhagen model is essentially Black-Scholes where:
+    - The underlying is the FX spot rate
+    - The "dividend yield" is replaced by the foreign risk-free rate
+    - The risk-free rate is the domestic risk-free rate
+
+    Args:
+        calculation_date: The date for which the pricing is being performed.
+        spot_fx_rate: The current FX spot rate (domestic per foreign currency).
+        volatility: The annualized volatility of the FX rate.
+        domestic_rate: The annualized domestic risk-free interest rate.
+        foreign_rate: The annualized foreign risk-free interest rate.
+
+    Returns:
+        A QuantLib BlackScholesMertonProcess object configured for FX options.
+    """
+    # Set the evaluation date in QuantLib
+    ql.Settings.instance().evaluationDate = calculation_date
+
+    # Define FX spot rate handle
+    spot_handle = ql.QuoteHandle(ql.SimpleQuote(spot_fx_rate))
+
+    day_count = ql.Actual365Fixed()
+
+    # Domestic risk-free rate curve
+    domestic_ts = ql.YieldTermStructureHandle(
+        ql.FlatForward(calculation_date, domestic_rate, day_count)
+    )
+
+    # Foreign risk-free rate curve (treated as "dividend yield" in BS framework)
+    foreign_ts = ql.YieldTermStructureHandle(
+        ql.FlatForward(calculation_date, foreign_rate, day_count)
+    )
+
+    # FX volatility surface
+    vol_ts = ql.BlackVolTermStructureHandle(
+        ql.BlackConstantVol(calculation_date, ql.TARGET(), volatility, day_count)
+    )
+
+    # Create the Garman-Kohlhagen process (using BlackScholesMertonProcess)
+    gk_process = ql.BlackScholesMertonProcess(
+        spot_handle, foreign_ts, domestic_ts, vol_ts
+    )
+
+    return gk_process
+
+
+def get_fx_market_data(currency_pair: str, calculation_date) -> dict:
+    """
+    Fetches FX market data for a given currency pair.
+    
+    Args:
+        currency_pair: Currency pair in format "EURUSD", "GBPUSD", etc.
+        calculation_date: The calculation date for market data
+        
+    Returns:
+        Dictionary containing spot rate, volatility, domestic rate, and foreign rate
+    """
+    # Extract domestic and foreign currencies from pair
+    if len(currency_pair) != 6:
+        raise ValueError("Currency pair must be 6 characters (e.g., 'EURUSD')")
+    
+    foreign_ccy = currency_pair[:3]  # First 3 characters
+    domestic_ccy = currency_pair[3:]  # Last 3 characters
+    
+    # Fetch market data using the data interface
+    asset_range_map = {currency_pair: DateInfo(start_date=calculation_date)}
+    market_data = data_interface.get_historical_data("fx_options", asset_range_map)
+    
+    return {
+        "spot_fx_rate": market_data["spot_fx_rate"],
+        "volatility": market_data["volatility"],
+        "domestic_rate": market_data["domestic_rate"],
+        "foreign_rate": market_data["foreign_rate"],
+        "foreign_currency": foreign_ccy,
+        "domestic_currency": domestic_ccy
+    }