dal-python 2026.8.11__cp310-cp310-win_amd64.whl

dal/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+# Import the C extension first to avoid circular imports when dal.py
+# executes "from . import _dal" during package initialization.
+from . import _dal  # noqa: F401
+from .dal import *
+from .api import *
+
+__author__ = 'The Derivatives Algorithms Group'
+__email__ = 'wegamekinglc@hotmail.com'
+__version__ = "2026.8.11"

dal/api.py

@@ -0,0 +1,119 @@
+from . import dal as _bindings
+
+
+def Product_New(events_dates: list, events: list[str]):
+    wrapped = [d if isinstance(d, _bindings.Cell_) else _bindings.Cell_(d) for d in events_dates]
+    return _bindings.Product_New(wrapped, events)
+
+
+# Settings whose target fields expect DAL value types — plain Python str
+# must be wrapped before setattr so pybind11 can convert them correctly.
+# DAL objects (String_, CollateralType_ etc.) pass through as-is.
+_DAL_TYPE_CONVERTERS = {
+    'curve_name': lambda v: _bindings.String_(v) if isinstance(v, str) else v,
+    'target_collateral': lambda v: _bindings.CollateralType_(v) if isinstance(v, str) else v,
+    'target_tenor': lambda v: _bindings.PeriodLength_(v) if isinstance(v, str) else v,
+    'libor_basis': lambda v: _bindings.DayBasis_(v) if isinstance(v, str) else v,
+}
+
+_OPTIONAL_SETTING_ATTRS = {
+    'curve_name': 'curveName_',
+    'target_collateral': 'targetCollateral_',
+    'target_tenor': 'targetTenor_',
+    'calibrate_discount': 'calibrateDiscountCurve_',
+    'libor_basis': 'liborBasis_',
+    'smoothing_weight': 'smoothingWeight_',
+    'tolerance': 'tolerance_',
+    'fit_tolerance': 'fitTolerance_',
+    'max_evaluations': 'maxEvaluations_',
+    'max_restarts': 'maxRestarts_',
+    'initial_guess': 'initialGuess_',
+    'solve_mode': 'solveMode_',
+    'parameterization': 'parameterization_',
+    'log_df_scheme': 'logDfScheme_',
+}
+
+
+def _apply_optional_setting(spec, name, value):
+    """Apply a single optional setting to a spec builder if the value is not None."""
+    if name not in _OPTIONAL_SETTING_ATTRS:
+        valid = ', '.join(sorted(_OPTIONAL_SETTING_ATTRS))
+        raise ValueError(f"Unknown calibration setting {name!r}. Supported settings: {valid}")
+    if value is None:
+        return
+    attr = _OPTIONAL_SETTING_ATTRS[name]
+    convert = _DAL_TYPE_CONVERTERS.get(name)
+    setattr(spec, attr, convert(value) if convert else value)
+
+
+def _build_calibration_spec(today, ccy, instruments, knot_dates, settings, base_curve=None):
+    """Build a CurveCalibrationSpec_ with sensible defaults and optional overrides."""
+    spec = _bindings.CurveCalibrationSpecBuilder_()
+    spec.today_ = today
+    spec.ccy_ = ccy if isinstance(ccy, _bindings.String_) else _bindings.String_(ccy)
+
+    spec.curveName_ = _bindings.String_("calibrated")
+    spec.calibrateDiscountCurve_ = True
+    spec.smoothingWeight_ = 1.0
+    spec.tolerance_ = 1e-8
+    spec.fitTolerance_ = 1e-6
+    spec.maxEvaluations_ = 200
+    spec.maxRestarts_ = 20
+    spec.initialGuess_ = 0.05
+
+    spec.instruments_ = instruments
+    spec.knotDates_ = knot_dates
+    if base_curve is not None:
+        spec.baseCurve_ = base_curve
+
+    if settings:
+        for key, value in settings.items():
+            _apply_optional_setting(spec, key, value)
+
+    return spec
+
+
+def calibrate_curve(
+    today,
+    ccy,
+    instruments,
+    knot_dates,
+    settings=None,
+    jacobian_mode=None,
+    base_curve=None,
+):
+    """High-level single-curve calibration with sensible defaults.
+
+    Only discount-curve calibration (calibrate_discount=True) is supported here;
+    forward-curve calibration needs a preloaded discount curve, so build a
+    CurveCalibrationSpecBuilder_ directly (set discountCurves_) and call
+    dal.CalibrateSingleCurve.
+
+    Args:
+        today: Date_ for the calibration date
+        ccy: Currency string (e.g. "USD")
+        instruments: List of YCInstrument_ handles
+        knot_dates: List of Date_ knot points
+        settings: Optional dict of override settings. Supported keys:
+            curve_name, target_collateral, target_tenor, calibrate_discount
+            (must be True), libor_basis, smoothing_weight, tolerance,
+            fit_tolerance, max_evaluations, max_restarts, initial_guess,
+            solve_mode, parameterization, log_df_scheme
+        jacobian_mode: CurveJacobianMode enum (None = default without Jacobian)
+        base_curve: Optional discount curve multiplied into the calibrated curve.
+
+    Returns:
+        CalibrationResult_ with curve_ and diagnostics_
+    """
+    if settings and settings.get("calibrate_discount") is False:
+        raise ValueError(
+            "calibrate_curve() only supports discount-curve calibration "
+            "(calibrate_discount=True). For forward-curve calibration, build a "
+            "CurveCalibrationSpecBuilder_ with discountCurves_ and call "
+            "dal.CalibrateSingleCurve directly."
+        )
+    spec = _build_calibration_spec(today, ccy, instruments, knot_dates, settings, base_curve)
+    if jacobian_mode is not None:
+        return _bindings.CalibrateSingleCurve(spec.Build(), jacobian_mode)
+    else:
+        return _bindings.CalibrateSingleCurve(spec.Build())

dal/dal.py

@@ -0,0 +1,2 @@
+# Auto-generated pybind11 shim -- re-exports all symbols from _dal
+from ._dal import *

dal_python-2026.8.11.dist-info/METADATA

@@ -0,0 +1,629 @@
+Metadata-Version: 2.4
+Name: dal-python
+Version: 2026.8.11
+Summary: Python bindings for the DAL quantitative finance library
+Author-Email: The Derivatives Algorithms Group <wegamekinglc@hotmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Project-URL: Documentation, https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/tree/master/dal-python
+Project-URL: Repository, https://github.com/wegamekinglc/Derivatives-Algorithms-Lib
+Requires-Python: <3.14,>=3.10
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: numpy>=1.24; extra == "test"
+Description-Content-Type: text/markdown
+
+# dal-python
+
+Python bindings for the Derivatives Algorithms Library (DAL) — a high-performance C++17 quantitative finance library with Automatic Adjoint Differentiation (AAD) support.
+
+## Features
+
+- **Black-Scholes and Dupire models** for equity derivatives pricing
+- **Monte Carlo simulation** with pseudo-random and Sobol sequence generators
+- **AAD Greeks** — compute pathwise sensitivities (delta, vega, rho, etc.) in a single simulation
+- **Script engine** — define exotic payoffs using a domain-specific language
+- **Curve calibration** — single-curve, multi-curve, staged XCCY, and joint domestic/foreign/basis calibration with resettable and MTM instruments plus AAD analytic Jacobians
+- **Type-safe wrappers** for `Date_`, `Matrix_`, `Cell_`, and vector types
+
+## Prerequisites
+
+- **CPython 3.10-3.13** with development headers
+- **uv** — fast Python package manager ([install guide](https://docs.astral.sh/uv/getting-started/installation/))
+- **pybind11 2.11.1** — installed automatically for isolated package builds;
+  repository builds fall back to the pinned `dal-cpp/externals/pybind11`
+  submodule, so run `git submodule update --init --recursive` on fresh clones
+- **CMake 3.21+** and a C++17 compiler (GCC 13+, Clang 18+, or MSVC 2022)
+- **DAL C++ staged install** — build core/public first; the canonical workflow is
+  in the [installation guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/installation.md#python-bindings)
+
+### Building the C++ Library
+
+The Python bindings depend on a compiled DAL C++ staging prefix. Build it first:
+
+```bash
+cd /path/to/Derivatives-Algorithms-Lib
+./build_linux.sh
+```
+
+This produces `build/stage/Release-linux/`, containing the installed core/public
+libraries, headers, and CMake package metadata.
+
+## Installation
+
+### Development Install (Recommended)
+
+Clone the repository and install in editable mode:
+
+```bash
+cd Derivatives-Algorithms-Lib/dal-python
+
+# Create a virtual environment with uv
+uv venv --python ">=3.10,<3.14"
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install dependencies and build the extension
+uv pip install -e ".[test]" "--config-settings=cmake.define.DAL_INSTALL_PREFIX=/absolute/path/to/Derivatives-Algorithms-Lib/build/stage/<platform-preset>"
+```
+
+Use an absolute staged-prefix path and replace `<platform-preset>` with the
+preset that built DAL, such as `Release-linux` or `Release-windows`. Standalone
+`dal-python` reads the installed CMake packages and automatically applies their
+configuration-aware MSVC runtime contract to `_dal`.
+
+### Workspace Build and Test
+
+To provision Python test dependencies and run the bindings through the workspace
+CTest integration:
+
+```bash
+bash ../build_linux.sh --full
+```
+
+The workspace script creates or reuses `dal-python/.venv`, builds the extension,
+and runs the configured C++/public/Python tests.
+
+## Building Distribution Packages
+
+For production deployment, you can build pre-compiled binary wheels or source distributions.
+Official PyPI releases contain precompiled wheels only.
+
+### Building a Binary Wheel
+
+Binary wheels contain the compiled C++ extension and can be installed without requiring compilation:
+
+```bash
+DAL_INSTALL_PREFIX=/absolute/path/to/build/stage/Release-linux ./build_wheel.sh
+DAL_INSTALL_PREFIX=/absolute/path/to/build/stage/Release-linux ./build_wheel.sh --clean
+```
+
+The platform- and interpreter-tagged wheel is created under `dist/`.
+
+Install the wheel:
+```bash
+uv pip install dist/dal_python-*.whl
+```
+
+**Note:** Binary wheels are platform-specific. DAL keeps native-CPU tuning off by
+default so distributable builds use the compiler's portable baseline. Do not set
+`DAL_ENABLE_NATIVE_ARCH=ON` for a wheel that must run on unknown machines.
+
+### Building a Source Distribution
+
+Source distributions allow users to build from source on any platform:
+
+```bash
+./build_sdist.sh         # Build source distribution
+./build_sdist.sh --clean # Clean build artifacts before building
+```
+
+The source archive is created under `dist/`.
+
+Install from source (requires C++ build tools):
+```bash
+pip install dist/dal_python-2026.8.11.tar.gz \
+  "--config-settings=cmake.define.DAL_INSTALL_PREFIX=/absolute/path/to/Derivatives-Algorithms-Lib/build/stage/<platform-preset>"
+# or
+uv pip install dist/dal_python-2026.8.11.tar.gz \
+  "--config-settings=cmake.define.DAL_INSTALL_PREFIX=/absolute/path/to/Derivatives-Algorithms-Lib/build/stage/<platform-preset>"
+```
+
+**Requirements for building from source:**
+- C++17 compiler (GCC 13+, Clang 18+, or MSVC 2022)
+- CMake 3.21+
+- pybind11 2.11.1 (declared as an isolated build requirement and installed
+  automatically; repository builds may use the pinned vendored submodule)
+- CPython 3.10-3.13 development headers
+- DAL staged install containing the `dal-public`/`dal-cpp` CMake packages and
+  platform libraries
+
+## PyPI Binary Release
+
+The repository release workflow builds and tests this wheel matrix:
+
+| Operating system | Architecture | Wheel platform tag          | CPython versions |
+|------------------|--------------|-----------------------------|------------------|
+| Linux            | x86-64       | `manylinux_2_28_x86_64`     | 3.10-3.13        |
+| Windows          | x86-64       | `win_amd64`                 | 3.10-3.13        |
+
+The Linux tag requires glibc 2.28 or newer. macOS, Linux ARM, musllinux, PyPy,
+free-threaded CPython, source distributions, and CPython 3.14 are not part of the
+current PyPI release contract.
+
+### One-time PyPI setup
+
+Configure a Trusted Publisher on the existing `dal-python` PyPI project with:
+
+| Field                | Value                              |
+|----------------------|------------------------------------|
+| PyPI project         | `dal-python`                       |
+| GitHub owner         | `wegamekinglc`                     |
+| GitHub repository    | `Derivatives-Algorithms-Lib`       |
+| Workflow filename    | `dal-python-release.yml`           |
+| GitHub environment   | `pypi`                             |
+
+Create the matching `pypi` environment in the GitHub repository and require a
+manual deployment approval if the repository plan supports it. The workflow uses
+OIDC short-lived credentials; do not add a long-lived PyPI API token.
+
+### Release procedure
+
+1. Choose a new PEP 440 version that does not exist on PyPI. Update both
+   `pyproject.toml` and `src/dal/__init__.py`.
+2. Build and test the workspace with `bash ./build_linux.sh --full` from the
+   repository root. Review and merge the version and release-note changes to
+   `master` only after the exact PR head is green.
+3. Run the `dal-python wheels and PyPI release` workflow manually from `master`.
+   This is a build-only rehearsal. Confirm that eight wheels and the SHA-256
+   release manifest are present.
+4. Tag that reviewed `master` commit and push only the tag:
+
+   ```bash
+   git tag -a dal-python-v<version> -m "Release dal-python <version>"
+   git push origin dal-python-v<version>
+   ```
+
+5. The tag run rebuilds and tests every wheel, validates the combined manifest,
+   checks that the version is unused on PyPI, then publishes the exact artifacts
+   from the build jobs through the `pypi` environment.
+6. Verify the PyPI file list contains all eight wheels. In fresh Windows and Linux
+   environments, install `dal-python==<version>`, import `dal`, and confirm
+   `dal.__version__` equals `<version>`.
+
+PyPI versions and files are immutable. Never use a skip-existing option to repair
+an incomplete release; correct the issue, increment the version, and run the full
+process again. Local `build_wheel.*` scripts are for diagnostics and private
+deployment only; their output is not a PyPI release artifact.
+
+## Usage
+
+### Basic Pricing Example
+
+```python
+import dal
+
+# Set evaluation date
+dal.EvaluationDate_Set(dal.Date_(2022, 9, 25))
+
+# Define model parameters
+spot, vol, rate, div = 100.0, 0.2, 0.05, 0.02
+model = dal.BSModelData_New(spot=spot, vol=vol, rate=rate, div=div)
+
+# Define a European call option
+strike = 100.0
+maturity = dal.Date_(2023, 9, 25)
+product = dal.Product_New(
+    ["STRIKE", dal.Cell_(maturity)],
+    [str(strike), "call pays MAX(spot() - STRIKE, 0.0)"]
+)
+
+# Price using Monte Carlo (65,536 paths, Sobol sequences)
+result = dal.MonteCarlo_Value(product, model, 2**16, "sobol")
+print(f"Call PV: {result['PV']:.4f}")
+# Output: Call PV: 9.2259
+```
+
+### Computing AAD Greeks
+
+Enable AAD to compute pathwise sensitivities in a single simulation:
+
+```python
+result = dal.MonteCarlo_Value(
+    product, model,
+    2**14,        # num_paths
+    "sobol",      # method
+    False,        # use_bb
+    True          # enable_aad
+)
+
+print(f"PV: {result['PV']:.6f}")
+for key in sorted(result.keys()):
+    if key.startswith('d_'):
+        print(f"  {key}: {result[key]:.6f}")
+```
+
+Output:
+```
+PV: 9.223019
+  d_STRIKE: -0.494542
+  d_div: -58.677195
+  d_rate: 49.454176
+  d_spot: 0.586772
+  d_vol: 37.873346
+```
+
+### Working with Dates
+
+```python
+import dal
+
+# Create dates
+d = dal.Date_(2022, 9, 25)
+print(d)  # 2022-09-25
+
+# Date arithmetic
+d2 = d.AddDays(30)
+print(f"Year: {dal.Year(d)}, Month: {dal.Month(d)}, Day: {dal.Day(d)}")
+
+# Date comparisons
+d3 = dal.Date_(2022, 10, 25)
+print(d < d3)  # True
+```
+
+### Random Number Generation
+
+```python
+# Pseudo-random generator (MRG32k32a algorithm)
+pseudo = dal.PseudoRSG_New(42, 3)  # seed=42, ndim=3
+uniform_samples = dal.PseudoRSG_Get_Uniform(pseudo, 1000)  # Returns DoubleMatrix_
+normal_samples = dal.PseudoRSG_Get_Normal(pseudo, 1000)
+
+# Sobol quasi-random sequences (better convergence for MC)
+sobol = dal.SobolRSG_New(0, 3)  # i_path=0, ndim=3
+sobol_samples = dal.SobolRSG_Get_Uniform(sobol, 1000)
+precise_sobol = dal.SobolRSG_New(
+    0, 3, precise=True, polish=True
+)  # opt in to the precise-CDF Newton correction
+```
+
+### Dupire Local Volatility Model
+
+```python
+# Define a local volatility surface with flat 20% vol
+spots = [80.0, 90.0, 100.0, 110.0, 120.0]
+times = [0.5, 1.0, 2.0]
+vols = dal.DoubleMatrix_(len(spots), len(times), 0.2)  # Fill with 20% vol
+
+dupire_model = dal.DupireModelData_New(
+    spot=100.0,
+    rate=0.05,
+    repo=0.01,
+    spots=spots,
+    times=times,
+    vols=vols
+)
+```
+
+`DoubleMatrix_` also accepts rectangular nested sequences and supports mutable
+`matrix[i, j]` access, so non-flat surfaces can be populated directly.
+
+## API Reference
+
+### Core Types
+
+- `dal.Date_(year, month, day)` — Date object with arithmetic operations
+- `dal.String_(value)` — String wrapper
+- `dal.Cell_(value)` — Polymorphic value container (bool, double, Date, String)
+- `dal.DoubleVector()` — Vector of doubles
+- `dal.DoubleMatrix_(rows, cols, fill=0.0)` or `dal.DoubleMatrix_(nested_rows)` — mutable 2D matrix of doubles
+
+### Models
+
+- `dal.BSModelData_New(spot, vol, rate, div)` — Black-Scholes model
+- `dal.DupireModelData_New(spot, rate, repo, spots, times, vols)` — Dupire local vol model
+
+### Products
+
+- `dal.Product_New(dates, events)` — Create a script product from event dates and payoff definitions
+- `dal.Product_Debug(product)` — Print human-readable product structure
+
+### Valuation
+
+- `dal.MonteCarlo_Value(product, modelData, num_path, method="sobol", use_bb=False, enable_aad=False, smooth=0.01, compiled=None)` — Monte Carlo pricing with optional AAD Greeks
+
+**Parameters:**
+- `product` — Script product (from `Product_New`)
+- `modelData` — Model data (from `BSModelData_New` or `DupireModelData_New`)
+- `num_path` — Positive number of simulation paths (powers of 2 are customary for Sobol)
+- `method` — Random generator: `"sobol"` (default) or `"mrg32"`
+- `use_bb` — Use Brownian bridge construction (default `False`)
+- `enable_aad` — Enable AAD for pathwise Greeks (default `False`)
+- `smooth` — Fuzzy logic smoothing parameter for discontinuous payoffs (default `0.01`)
+- `compiled` — `True` selects the compiled evaluator; `None`/`False` uses tree-walk
+
+**Returns:** Dictionary with keys:
+- `"PV"` — Present value
+- `"d_spot"`, `"d_vol"`, `"d_rate"`, `"d_div"`, `"d_STRIKE"` — AAD Greeks (only if `enable_aad=True`)
+
+### Random Generators
+
+- `dal.PseudoRSG_New(seed, ndim=1)` — Pseudo-random generator (MRG32k32a)
+- `dal.SobolRSG_New(i_path, ndim=1, precise=False, polish=False)` — Sobol
+  quasi-random generator; `polish` enables the Newton correction and `precise`
+  selects its CDF, so the precise-CDF correction requires both flags to be `True`
+- `dal.PseudoRSG_Get_Uniform(rsg, num_paths)` — Uniform samples [0, 1]
+- `dal.PseudoRSG_Get_Normal(rsg, num_paths)` — Standard normal samples
+- `dal.SobolRSG_Get_Uniform(rsg, num_paths)` — Sobol uniform samples
+- `dal.SobolRSG_Get_Normal(rsg, num_paths)` — Sobol normal samples
+
+### Global State
+
+- `dal.EvaluationDate_Set(date)` — Set the process-wide evaluation date; waits
+  for an in-progress native valuation or scoped override
+- `dal.EvaluationDate_Get()` — Read the stable process-wide evaluation date;
+  remains available while valuation runs
+
+Both bindings release the GIL before entering native synchronization.
+
+## Testing
+
+Build and run the full workspace suite:
+
+```bash
+bash ../build_linux.sh --full
+```
+
+After an editable install, run focused Python tests directly:
+
+```bash
+python -m pytest tests -k "test_date" -v
+```
+
+Tests are located in `tests/` and cover:
+
+- Date arithmetic and comparisons
+- Vector and matrix operations
+- Model construction (BS, Dupire)
+- Monte Carlo pricing accuracy vs Black-Scholes analytical formulas
+- AAD Greek computation and validation
+- Random number generator properties
+- Curve construction plus single and staged multi-curve calibration
+- Staged XCCY basis calibration, sensitivity matrices, axes, and availability metadata
+- Resettable/MTM XCCY construction with immutable fixing snapshots
+- Joint domestic/foreign/basis XCCY calibration, including matrix and named-range contracts
+
+## Project Structure
+
+```
+dal-python/
+├── CMakeLists.txt          # Build configuration
+├── pyproject.toml          # Python package metadata (scikit-build-core)
+├── run_tests.sh            # Standalone binding test helper
+├── src/
+│   ├── bindings/
+│   │   ├── module.cpp        # pybind11 module definition
+│   │   ├── bindings.h        # shared binding helpers
+│   │   ├── core.cpp          # core types (Date_, String_, Cell_, vectors, DoubleMatrix_)
+│   │   ├── global.cpp         # Handle_<T> opaque types, EvaluationDate_Get/Set
+│   │   ├── models.cpp         # model types (BSModelData_, etc.)
+│   │   ├── random.cpp          # random number generators
+│   │   ├── script.cpp          # scripting engine bindings
+│   │   ├── calendar.cpp        # holiday calendars and business-day conventions
+│   │   ├── curve.cpp           # curve calibration, instruments, and interpolation
+│   │   └── value.cpp           # Monte Carlo valuation (MonteCarlo_Value)
+│   └── dal/
+│       ├── __init__.py     # Package initialization
+│       └── api.py          # High-level Python API wrappers
+├── tests/
+│   ├── conftest.py        # Pytest fixtures
+│   └── test_*.py          # Test modules
+```
+
+## Architecture
+
+The Python bindings are generated by pybind11 from domain-organized binding files. The build process:
+
+1. **CMake** configures the build and locates the DAL C++ libraries plus either
+   the isolated pybind11 build requirement or the pinned repository fallback
+2. **C++ compiler** builds `_dal.cpython-*.so` extension module from the domain-organized `src/bindings/*.cpp` files
+3. **scikit-build-core** packages everything into an installable wheel
+
+When consuming an installed DAL package under MSVC, CMake applies the package's
+`DAL_CPP_MSVC_RUNTIME_LIBRARY` value to `_dal` through
+`dal_cpp_apply_msvc_runtime`. The helper is a no-op on other toolchains.
+
+The hand-written Python code in `src/dal/` provides:
+- `__init__.py` — Re-exports all pybind11-generated symbols
+- `api.py` — Convenience wrappers (e.g., `Product_New` with automatic type conversion, `calibrate_curve(...)` for curve calibration)
+
+## Curve Calibration
+
+The `curve` bindings (`dal-python/src/bindings/curve.cpp`) expose the supported Python
+curve-construction and calibration workflows:
+
+- **Instrument builders** — `Deposit_New`, `FRA_New`, `Future_New`, `Swap_New`, `OISSwap_New`, `BasisSwap_New`, `CrossCurrencySwap_New`
+- **Curve factories** — `DiscountPWLF_New`, `DiscountZeroRate_New`
+- **Calibration entry points** — `CalibrateSingleCurve`, `CalibrateMultiCurveBundle`, `CalibrateXccyMarket`, `CalibrateJointXccyMarket`
+- **Enums** — `CurveParameterization` (`PIECEWISE_LINEAR_FWD`, `PIECEWISE_CONSTANT_FWD`, `ZERO_RATE`, `LOG_DISCOUNT`), `CurveSolveMode` (`EXACT`, `APPROXIMATE`), `CurveJacobianMode` (`ANALYTIC`, `BUMPED`), `LogDfScheme` (`LOG_LINEAR`, `LOG_CUBIC_NATURAL`, `MIXED`), `XccyNotionalMode` (`FIXED`, `RESETTABLE`, `MARK_TO_MARKET`)
+- **Spec builders** — `CurveCalibrationSpecBuilder_`, `CrossCurrencyCalibrationSpecBuilder_`, and `JointXccyCalibrationSpecBuilder_`
+
+The `dal.calibrate_curve(...)` helper in `api.py` wraps the common single-curve path with Python-friendly defaults. The underlying C++ methodology is documented in the [yield-curve guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/methodology/yield_curve.md) and [Jacobian guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/methodology/yield_curve_jacobian.md).
+
+### Continuously Compounded Zero-Rate Curves
+
+Build a persistent zero-rate curve directly with future-only nodes:
+
+```python
+today = dal.Date_(2026, 1, 2)
+node_dates = [dal.Date_(2027, 1, 2), dal.Date_(2028, 1, 2)]
+
+curve = dal.DiscountZeroRate_New(
+    "usd_zero",
+    "USD",
+    today,
+    node_dates,
+    [0.02, 0.025],
+    day_count=dal.DayBasis_("ACT_365F"),
+    log_df_scheme=dal.LogDfScheme.LOG_LINEAR,
+)
+```
+
+Each continuously compounded decimal rate $z_i$ is mapped to
+`logDF_i = -z_i * YearFrac(today, node_date_i)`. The anchor log DF is fixed at zero
+and has no zero-rate parameter. `LOG_LINEAR`, `LOG_CUBIC_NATURAL`, and `MIXED` all
+interpolate the mapped log DFs. Before the anchor, `LOG_LINEAR` and `MIXED` clamp the
+log DF to zero, while `LOG_CUBIC_NATURAL` extends its first cubic segment. Beyond the
+last node, every scheme uses the last two mapped log-DF nodes as a secant. The returned
+`DiscountZeroRate_` exposes read-only `anchor_date`, `node_dates`, `zero_rates`,
+`day_count`, and `log_df_scheme` properties.
+
+For calibration, select `CurveParameterization.ZERO_RATE` and supply strictly-future
+knots. `initialGuess_` is a decimal continuously compounded zero rate copied to every
+node. Both low-level `CalibrateSingleCurve` and the convenience helper use the analytic
+AAD Jacobian when the normal single-discount-curve eligibility gates are met:
+
+```python
+result = dal.calibrate_curve(
+    today,
+    "USD",
+    instruments,
+    node_dates,
+    settings={
+        "parameterization": dal.CurveParameterization.ZERO_RATE,
+        "log_df_scheme": dal.LogDfScheme.LOG_CUBIC_NATURAL,
+        "initial_guess": 0.02,
+    },
+    jacobian_mode=dal.CurveJacobianMode.ANALYTIC,
+    base_curve=base_curve,  # optional: zero rates are spread coordinates over this base
+)
+```
+
+Python exposes single, staged multi-curve, staged XCCY basis, and simultaneous
+joint XCCY calibration. A base curve is multiplied into the calibrated component;
+it is not a replacement for the pricing discount curve required by a forward-curve stage.
+Staged XCCY supports both the backward-compatible
+`CalibrateXccyMarket(spec)` call and `CalibrateXccyMarket(spec, options)`.
+`CrossCurrencyCalibrationOptions_` defaults to `ANALYTIC` with
+`compute_forward_jacobian = True` and
+`compute_eff_jacobian_inverse = True`; trailing-underscore property names are
+available alongside the snake-case names.
+
+The matrices remain on `result.diagnostics`. `diagnostics.jacobian` has
+instrument rows and basis-parameter columns;
+`diagnostics.eff_jacobian_inverse` has the reversed axes.
+`instrument_names` follows input order and may contain duplicate labels.
+`parameter_knot_dates` follows the spec's knot order and labels the
+piecewise-constant basis curve's right-forward parameters. The diagnostics also
+publish `residual_tolerance`, `jacobian_scaling == "unscaled"`,
+`eff_jacobian_inverse_scaling == "solver_scaled"`, and independent
+`jacobian_availability` / `eff_jacobian_inverse_availability` values:
+`available`, `not_requested`, or `not_available_for_mode`.
+
+For a raw decimal quote-bump vector `dq`, the solver-scaled effective inverse
+`E` maps parameters as `dx = E * dq / residual_tolerance`. An unavailable
+matrix is empty; inspect its availability property to distinguish an explicit
+opt-out from a mode limitation.
+
+### Resettable and Joint XCCY Calibration
+
+Use `CrossCurrencySwapConfigBuilder_` to set the currency pair, notionals, leg
+conventions, `notional_mode`, `fx_reset`, and explicit `domestic_rate_fixing` /
+`foreign_rate_fixing` identities. `MarketFixingSnapshot_New` takes a nested
+dictionary whose keys are index names and whose values map `DateTime_` objects to
+observations. One immutable snapshot can hold domestic rate, foreign rate, and FX
+fixings for an already-started swap:
+
+```python
+snapshot = dal.MarketFixingSnapshot_New({
+    "USD-JOINT-3M": {historical_fixing: 0.040},
+    "EUR-JOINT-3M": {historical_fixing: 0.030},
+    "FX[EUR/USD]": {historical_fixing: 1.20},
+})
+```
+
+`JointCurrencyCurveSpec_` holds the ordered domestic or foreign
+`JointCurveDeclaration_` objects. `XccyBasisCurveDeclaration_` holds configured
+XCCY instruments and basis knots. Assemble those groups with
+`JointXccyCalibrationSpecBuilder_`, then call
+`CalibrateJointXccyMarket(builder.build())`. The result exposes the domestic and
+foreign curve blocks, `fx_forward_curve`, basis curve, retained snapshot, group
+diagnostics, full market/model/residual vectors, analytic Jacobian, effective
+inverse, and named `parameter_ranges` / `residual_ranges`. Pass
+`JointXccyCalibrationOptions_` to select `ANALYTIC` or `BUMPED` and to disable
+either diagnostic matrix. The `eff_jacobian_inverse` matrix has shape
+`totalParameters x totalResiduals` and is the weighted inverse of the solver's
+tolerance-scaled Jacobian. Transforming a raw decimal quote bump therefore
+requires division by the spec's `tolerance_`; see the
+[Jacobian methodology](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/methodology/yield_curve_jacobian.md#joint-xccy-jacobian-layout).
+
+The runnable [joint XCCY calibration example](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/dal-python/examples/007.xccy_joint_calibration.py)
+uses an explicit fixing snapshot for a started MTM trade. It prints convergence,
+the maximum absolute residual, Jacobian dimensions, named parameter and residual
+half-open ranges, and every FX-forward date and value. With the `dal` package
+installed in the active environment, run it from the repository root:
+
+```bash
+python dal-python/examples/007.xccy_joint_calibration.py
+```
+
+## Troubleshooting
+
+### "Cannot find DAL::public" during build
+
+Ensure `DAL_INSTALL_PREFIX` points to the correct staged DAL installation:
+
+```text
+<stage>/lib/cmake/dal-public/dal-publicConfig.cmake
+<stage>/lib/cmake/dal-cpp/dal-cppConfig.cmake
+<stage>/include/dal/
+```
+
+The library files beside the package metadata use the platform's native suffix,
+such as `.a` on Linux or `.lib` on Windows; do not diagnose the prefix by
+assuming one suffix.
+
+### "ImportError: No module named _dal"
+
+The extension module failed to build. Check the build logs:
+
+```bash
+uv pip install --reinstall -e . -v "--config-settings=cmake.define.DAL_INSTALL_PREFIX=/absolute/path/to/build/stage/<platform-preset>"
+```
+
+Replace `<platform-preset>` with the stage produced by the active compiler and
+configuration.
+
+### Tests fail with "ModuleNotFoundError"
+
+Ensure you're using the virtual environment:
+
+```bash
+uv run --no-sync python -c "import dal; print(dal.__version__)"
+```
+
+## License
+
+MIT License. See the repository [LICENSE](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/LICENSE).
+
+## Contributing
+
+Follow the repository [contributor guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/CONTRIBUTING.md). Binding changes
+should include Python tests and updates to the
+[public API guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/public-api.md) when the supported surface changes.
+
+## See Also
+
+- [DAL C++ Library](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib) — Workspace overview
+- [Installation guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/installation.md) — Canonical setup commands
+- [Public API guide](https://github.com/wegamekinglc/Derivatives-Algorithms-Lib/blob/master/docs/public-api.md) — C++, Python, and Excel entry points
+- [pybind11 Documentation](https://pybind11.readthedocs.io/) — pybind11 binding syntax

dal_python-2026.8.11.dist-info/RECORD

@@ -0,0 +1,7 @@
+dal/__init__.py,sha256=WahSHmuo12V66E-zTiUia6uILSHa8JjE68IfON0Avwo,342
+dal/_dal.cp310-win_amd64.pyd,sha256=4vgpJ19ePS3ACgVp63JeCdhThvzeNOUnNHTYGwCX2SI,6262784
+dal/api.py,sha256=Q6Sg8q5_7zar8q__d5wEB35bLj3wJO-tPQl3jem4j0U,4706
+dal/dal.py,sha256=b0-41lZPe9kLS9tlVBJJkYQEzp83e5PXxnrrJ8_23hc,89
+dal_python-2026.8.11.dist-info/METADATA,sha256=pbGEa7XO_SyMSexEaXUrfG6-ARSV8dr_2ShJZ0IURjI,26256
+dal_python-2026.8.11.dist-info/WHEEL,sha256=dLsqnLqoa03X-KKRvIZetJerE-pAfZT9U_wzO7zFOgQ,105
+dal_python-2026.8.11.dist-info/RECORD,,

dal_python-2026.8.11.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.0.3
+Root-Is-Purelib: false
+Tag: cp310-cp310-win_amd64
+