pyquantlib 0.6.0__tar.gz → 0.7.0__tar.gz

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/.github/workflows/linux.yml

@@ -29,7 +29,7 @@ on:
       - ".github/workflows/linux.yml"
 
 env:
-  QUANTLIB_VERSION: "1.40"
+  QUANTLIB_VERSION: "1.41"
 
 jobs:
   build:

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/.github/workflows/macos.yml

@@ -29,7 +29,7 @@ on:
       - ".github/workflows/macos.yml"
 
 env:
-  QUANTLIB_VERSION: "1.40"
+  QUANTLIB_VERSION: "1.41"
 
 jobs:
   build:

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/.github/workflows/wheels.yml

@@ -19,7 +19,7 @@ on:
     types: [published]
 
 env:
-  QUANTLIB_VERSION: "1.40"
+  QUANTLIB_VERSION: "1.41"
   BOOST_VERSION: "1.86.0"
 
 jobs:

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/.github/workflows/windows.yml

@@ -29,7 +29,7 @@ on:
       - ".github/workflows/windows.yml"
 
 env:
-  QUANTLIB_VERSION: "1.40"
+  QUANTLIB_VERSION: "1.41"
   BOOST_VERSION: "1.86.0"
   BOOST_VERSION_UNDERSCORE: "1_86_0"
 

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/CMakeLists.txt

@@ -39,7 +39,7 @@ option(PYQUANTLIB_DETAILED_ERRORS "Enable detailed pybind11 error messages" ON)
 # ==============================================================================
 
 file(READ "${CMAKE_SOURCE_DIR}/pyquantlib/version.py" VERSION_PY_CONTENTS)
-string(REGEX MATCH "__version__ *= *\"([0-9]+\\.[0-9]+\\.[0-9]+)\"" _ "${VERSION_PY_CONTENTS}")
+string(REGEX MATCH "__version__ *= *\"([0-9]+\\.[0-9]+\\.[0-9]+[^\"]*)\"" _ "${VERSION_PY_CONTENTS}")
 set(PYQUANTLIB_VERSION "${CMAKE_MATCH_1}")
 
 if(NOT PYQUANTLIB_VERSION)
@@ -113,9 +113,8 @@ endif()
 # QuantLib discovery order:
 # 1. CMake argument: -DQuantLib_ROOT=/path/to/quantlib
 # 2. Environment variable: QuantLib_ROOT or QL_DIR
-# 3. vcpkg toolchain (automatic if CMAKE_TOOLCHAIN_FILE is set)
-# 4. System paths (brew on macOS, apt/dnf packages on Linux)
-# 5. Manual fallback for source builds without CMake config
+# 3. CMake config from source build (including preset build directories)
+# 4. Manual fallback for source builds without CMake config
 
 # Support legacy QL_DIR environment variable
 if(NOT DEFINED QuantLib_ROOT)
@@ -126,7 +125,20 @@ if(NOT DEFINED QuantLib_ROOT)
     endif()
 endif()
 
-# First, try standard CMake find_package (works for vcpkg, brew, system packages)
+# If QuantLib_ROOT points to a source tree, locate any CMake config files
+# generated in build subdirectories (e.g. build/windows-msvc-release/cmake/)
+# so that find_package(CONFIG) can discover them automatically.
+if(QuantLib_ROOT)
+    file(GLOB_RECURSE _ql_config_files
+        "${QuantLib_ROOT}/build/*/QuantLibConfig.cmake"
+    )
+    foreach(_config_file ${_ql_config_files})
+        get_filename_component(_config_dir "${_config_file}" DIRECTORY)
+        list(APPEND CMAKE_PREFIX_PATH "${_config_dir}")
+    endforeach()
+endif()
+
+# Try CMake find_package (source builds with CMake config)
 find_package(QuantLib 1.30 QUIET CONFIG)
 
 if(QuantLib_FOUND)
@@ -175,14 +187,23 @@ else()
         set(_ql_lib_names QuantLib)
     endif()
     
+    # Collect search paths: fixed well-known locations + any preset build dirs
+    set(_ql_lib_paths
+        "${QuantLib_ROOT}/lib"
+        "${QuantLib_ROOT}/lib64"
+        "${QuantLib_ROOT}/lib/x86_64-linux-gnu"
+        "${QuantLib_ROOT}/build/ql"
+        "${QuantLib_ROOT}/build/ql/Release"
+    )
+    # CMake preset builds place output under build/<preset-name>/ql/[Release/]
+    file(GLOB _ql_preset_dirs "${QuantLib_ROOT}/build/*/ql")
+    foreach(_dir ${_ql_preset_dirs})
+        list(APPEND _ql_lib_paths "${_dir}" "${_dir}/Release" "${_dir}/Debug")
+    endforeach()
+
     find_library(QuantLib_LIBRARY
         NAMES ${_ql_lib_names}
-        PATHS 
-            "${QuantLib_ROOT}/lib"
-            "${QuantLib_ROOT}/lib64"
-            "${QuantLib_ROOT}/lib/x86_64-linux-gnu"
-            "${QuantLib_ROOT}/build/ql"
-            "${QuantLib_ROOT}/build/ql/Release"
+        PATHS ${_ql_lib_paths}
         NO_DEFAULT_PATH
     )
     
@@ -190,7 +211,7 @@ else()
         message(FATAL_ERROR
             "QuantLib library not found.\n"
             "Searched for: ${_ql_lib_names}\n"
-            "In paths: ${QuantLib_ROOT}/lib, ${QuantLib_ROOT}/build/ql"
+            "In paths: ${_ql_lib_paths}"
         )
     endif()
     

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyquantlib
-Version: 0.6.0
+Version: 0.7.0
 Summary: Python bindings for QuantLib
 Keywords: quantlib,quantitative-finance,derivatives,pricing,risk,fixed-income,options,finance,pybind11
 Author-Email: Yassine Idyiahia <yassine.id@gmail.com>

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/api/cashflows.md

@@ -344,6 +344,22 @@ pricer = ql.ArithmeticAveragedOvernightIndexedCouponPricer(
 )
 ```
 
+### BlackCompoundingOvernightIndexedCouponPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BlackCompoundingOvernightIndexedCouponPricer
+```
+
+Black pricer for capped/floored compounded overnight coupons.
+
+### BlackAveragingOvernightIndexedCouponPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BlackAveragingOvernightIndexedCouponPricer
+```
+
+Black pricer for capped/floored averaged overnight coupons. Requires `RateAveraging.Type.Simple`.
+
 ### setCouponPricer
 
 ```{eval-rst}

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/api/instruments.md

@@ -613,6 +613,48 @@ option.setPricingEngine(ql.AnalyticDoubleBarrierEngine(process))
 print(option.NPV())
 ```
 
+### PartialTimeBarrierOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.PartialTimeBarrierOption
+```
+
+Barrier monitored over a partial time window (start or end of option life).
+
+```python
+option = ql.PartialTimeBarrierOption(
+    ql.BarrierType.DownOut, ql.PartialBarrierRange.Start,
+    80.0, 0.0, cover_date, payoff, exercise,
+)
+option.setPricingEngine(ql.AnalyticPartialTimeBarrierOptionEngine(process))
+```
+
+### SoftBarrierOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SoftBarrierOption
+```
+
+Soft barrier option with proportional knock-in/out over a barrier range.
+
+```python
+option = ql.SoftBarrierOption(ql.BarrierType.DownOut, 70.0, 80.0, payoff, exercise)
+option.setPricingEngine(ql.AnalyticSoftBarrierEngine(process))
+```
+
+### TwoAssetBarrierOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.TwoAssetBarrierOption
+```
+
+Barrier option where barrier monitoring is on a second (correlated) asset.
+
+```python
+option = ql.TwoAssetBarrierOption(ql.BarrierType.DownOut, 80.0, payoff, exercise)
+option.setPricingEngine(ql.AnalyticTwoAssetBarrierEngine(process1, process2, rho))
+```
+
 ## Asian Options
 
 ### ContinuousAveragingAsianOption

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/api/pricingengines.md

@@ -436,6 +436,27 @@ engine = ql.QdFpAmericanEngine(process)
 .. autoclass:: pyquantlib.AnalyticDividendEuropeanEngine
 ```
 
+### CashDividendEuropeanEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CashDividendEuropeanEngine
+```
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CashDividendModel
+   :members:
+   :undoc-members:
+```
+
+Semi-analytic European engine with cash dividends (Healy, 2021).
+Supports Spot and Escrowed dividend models.
+
+```python
+dividends = [ql.FixedDividend(2.0, ex_date)]
+engine = ql.CashDividendEuropeanEngine(
+    process, dividends, ql.CashDividendModel.Spot)
+```
+
 ### AnalyticBSMHullWhiteEngine
 
 ```{eval-rst}
@@ -468,6 +489,44 @@ engine = ql.QdFpAmericanEngine(process)
 .. autoclass:: pyquantlib.StulzEngine
 ```
 
+### ChoiBasketEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ChoiBasketEngine
+```
+
+Choi (2018) analytic engine for average and spread basket options.
+
+### SingleFactorBsmBasketEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SingleFactorBsmBasketEngine
+```
+
+Single-factor BSM approximation for average basket options.
+
+### MCAmericanBasketEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.MCAmericanBasketEngine
+```
+
+Monte Carlo American basket engine using Longstaff-Schwartz regression.
+
+### FdndimBlackScholesVanillaEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FdndimBlackScholesVanillaEngine
+```
+
+N-dimensional finite-difference Black-Scholes basket engine.
+
+### MCLDEuropeanBasketEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MCLDEuropeanBasketEngine
+```
+
 ## Swaption Engines
 
 ### BlackSwaptionEngine
@@ -702,6 +761,75 @@ engine = ql.MCDoubleBarrierEngine(
 )
 ```
 
+### AnalyticBinaryBarrierEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticBinaryBarrierEngine
+```
+
+Analytic binary (one-touch) barrier option engine.
+
+### BinomialBarrierEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.BinomialBarrierEngine
+```
+
+Binomial tree barrier engine with configurable tree type and discretization.
+
+```python
+engine = ql.BinomialBarrierEngine(process, "crr", 200)
+engine = ql.BinomialBarrierEngine(process, "crr", 200, discretization="dermankani")
+```
+
+### FdHestonBarrierEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FdHestonBarrierEngine
+```
+
+Finite-difference Heston barrier option engine.
+
+### FdHestonDoubleBarrierEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FdHestonDoubleBarrierEngine
+```
+
+Finite-difference Heston double barrier option engine.
+
+### FdHestonRebateEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FdHestonRebateEngine
+```
+
+Finite-difference Heston rebate engine for barrier options.
+
+### AnalyticPartialTimeBarrierOptionEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticPartialTimeBarrierOptionEngine
+```
+
+Analytic engine for partial-time barrier options (Heynen-Kat).
+
+### AnalyticSoftBarrierEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticSoftBarrierEngine
+```
+
+Analytic engine for soft barrier options.
+
+### AnalyticTwoAssetBarrierEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticTwoAssetBarrierEngine
+```
+
+Analytic engine for two-asset barrier options.
+
 ## Asian Engines
 
 ### AnalyticContinuousGeometricAveragePriceAsianEngine
@@ -742,6 +870,68 @@ engine = ql.MCDiscreteArithmeticAPEngine(
 )
 ```
 
+### ChoiAsianEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ChoiAsianEngine
+```
+
+Choi (2018) analytic discrete arithmetic Asian engine.
+
+### AnalyticDiscreteGeometricAverageStrikeAsianEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticDiscreteGeometricAverageStrikeAsianEngine
+```
+
+### ContinuousArithmeticAsianLevyEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ContinuousArithmeticAsianLevyEngine
+```
+
+Levy (1992) continuous arithmetic average price Asian engine.
+
+### FdBlackScholesAsianEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FdBlackScholesAsianEngine
+```
+
+Finite-difference Black-Scholes engine for discrete Asian options.
+
+### MCDiscreteArithmeticASEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.MCDiscreteArithmeticASEngine
+```
+
+Monte Carlo discrete arithmetic average strike Asian engine.
+
+### MCDiscreteGeometricAPEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.MCDiscreteGeometricAPEngine
+```
+
+Monte Carlo discrete geometric average price Asian engine.
+
+### MCDiscreteArithmeticAPHestonEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.MCDiscreteArithmeticAPHestonEngine
+```
+
+Monte Carlo discrete arithmetic Asian engine under Heston dynamics.
+
+### MCDiscreteGeometricAPHestonEngine
+
+```{eval-rst}
+.. autofunction:: pyquantlib.MCDiscreteGeometricAPHestonEngine
+```
+
+Monte Carlo discrete geometric Asian engine under Heston dynamics.
+
 ## Lookback Engines
 
 ### AnalyticContinuousFloatingLookbackEngine

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/api/termstructures.md

@@ -339,6 +339,87 @@ print(curve.discount(1.0))
 print(curve.nodes())
 ```
 
+## Global Bootstrap Piecewise Curves
+
+Piecewise yield curves using `GlobalBootstrap`, which solves for all nodes
+simultaneously via global optimization instead of iterative bootstrapping.
+Useful when instruments depend on each other or when the standard bootstrap
+fails to converge.
+
+### PiecewiseLogLinearDiscountGlobal
+
+```{eval-rst}
+.. autoclass:: pyquantlib.PiecewiseLogLinearDiscountGlobal
+```
+
+### PiecewiseLinearZeroGlobal
+
+```{eval-rst}
+.. autoclass:: pyquantlib.PiecewiseLinearZeroGlobal
+```
+
+### PiecewiseBackwardFlatForwardGlobal
+
+```{eval-rst}
+.. autoclass:: pyquantlib.PiecewiseBackwardFlatForwardGlobal
+```
+
+```python
+curve = ql.PiecewiseLogLinearDiscountGlobal(
+    today, helpers, ql.Actual365Fixed(), accuracy=1e-12)
+
+# With instrument weights
+weights = [1.0] * len(helpers)
+curve = ql.PiecewiseLogLinearDiscountGlobal(
+    today, helpers, ql.Actual365Fixed(),
+    accuracy=1e-12, instrumentWeights=weights)
+
+# Settlement days constructor
+curve = ql.PiecewiseLogLinearDiscountGlobal(
+    2, ql.TARGET(), helpers, ql.Actual365Fixed(), accuracy=1e-12)
+```
+
+## MultiCurve
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MultiCurve
+```
+
+Manages a set of yield curves that form a dependency cycle, bootstrapping
+them simultaneously. Curves added with `addBootstrappedCurve` are solved
+together; curves added with `addNonBootstrappedCurve` are relinked but not
+bootstrapped (e.g. spreaded curves derived from bootstrapped ones).
+
+```python
+accuracy = 1e-10
+
+# Internal relinkable handles for the dependency cycle
+int_3m = ql.RelinkableYieldTermStructureHandle()
+int_6m = ql.RelinkableYieldTermStructureHandle()
+
+euribor3m = ql.Euribor3M(int_3m)
+euribor6m = ql.Euribor6M(int_6m)
+
+# Build helpers referencing each other's curves
+helpers_3m = [ql.FraRateHelper(q, i, euribor3m) for i in range(1, 10)]
+helpers_6m = [ql.SwapRateHelper(q, ql.Period(i, ql.Years), ...)
+              for i in range(2, 11)]
+
+# Create GlobalBootstrap curves
+curve_3m = ql.PiecewiseLogLinearDiscountGlobal(
+    today, helpers_3m, ql.Actual360(), accuracy=accuracy)
+curve_6m = ql.PiecewiseLogLinearDiscountGlobal(
+    today, helpers_6m, ql.Actual360(), accuracy=accuracy)
+
+# Solve the cycle
+mc = ql.MultiCurve(accuracy)
+ext_3m = mc.addBootstrappedCurve(int_3m, curve_3m)
+ext_6m = mc.addBootstrappedCurve(int_6m, curve_6m)
+
+# Use external handles for pricing
+print(ext_3m.currentLink().discount(1.0))
+```
+
 ## Fitted Bond Discount Curves
 
 ### FittedBondDiscountCurve

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/building.md

@@ -95,18 +95,20 @@ cmake .. \
 
 ## Building QuantLib
 
+See the version compatibility table in {doc}`installation` for which QuantLib version to use with each PyQuantLib release.
+
 ### Download
 
 ```bash
-# Download release
-wget https://github.com/lballabio/QuantLib/releases/download/v1.40/QuantLib-1.40.tar.gz
-tar xzf QuantLib-1.40.tar.gz
-cd QuantLib-1.40
+# Download release (replace 1.41 with the version matching your PyQuantLib release)
+wget https://github.com/lballabio/QuantLib/releases/download/v1.41/QuantLib-1.41.tar.gz
+tar xzf QuantLib-1.41.tar.gz
+cd QuantLib-1.41
 
 # Or clone
 git clone https://github.com/lballabio/QuantLib.git
 cd QuantLib
-git checkout v1.40
+git checkout v1.41
 ```
 
 ### Windows

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/changelog.md

@@ -11,6 +11,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-03-14
+
+### Changed
+- Upgraded QuantLib dependency from 1.40 to 1.41
+- `FdBlackScholesVanillaEngine` gains optional `cashDividendModel` parameter (`CashDividendModel.Spot` or `.Escrowed`)
+
+### Added
+
+#### Pricing Engines
+- `CashDividendEuropeanEngine` semi-analytic European engine with cash dividends (Healy, 2021), `CashDividendModel` enum (`Spot`, `Escrowed`)
+- `ChoiAsianEngine` Choi (2018) analytic discrete arithmetic Asian engine
+- `AnalyticDiscreteGeometricAverageStrikeAsianEngine` analytic discrete geometric average strike Asian engine
+- `ContinuousArithmeticAsianLevyEngine` Levy (1992) continuous arithmetic Asian engine
+- `FdBlackScholesAsianEngine` finite-difference Black-Scholes discrete Asian engine
+- `MCDiscreteArithmeticASEngine` Monte Carlo discrete arithmetic average strike Asian engine
+- `MCDiscreteGeometricAPEngine` Monte Carlo discrete geometric average price Asian engine
+- `MCDiscreteArithmeticAPHestonEngine` Monte Carlo discrete arithmetic Asian engine under Heston dynamics
+- `MCDiscreteGeometricAPHestonEngine` Monte Carlo discrete geometric Asian engine under Heston dynamics
+- `AnalyticBinaryBarrierEngine` analytic binary (one-touch) barrier option engine
+- `BinomialBarrierEngine` binomial tree barrier engine with configurable tree type and discretization (Derman-Kani)
+- `FdHestonBarrierEngine` finite-difference Heston barrier option engine
+- `FdHestonDoubleBarrierEngine` finite-difference Heston double barrier option engine
+- `FdHestonRebateEngine` finite-difference Heston rebate engine for barrier options
+- `AnalyticPartialTimeBarrierOptionEngine` analytic engine for partial-time barrier options (Heynen-Kat)
+- `AnalyticSoftBarrierEngine` analytic engine for soft barrier options
+- `AnalyticTwoAssetBarrierEngine` analytic engine for two-asset barrier options
+- `ChoiBasketEngine` Choi (2018) analytic engine for average and spread basket options
+- `SingleFactorBsmBasketEngine` single-factor BSM approximation for average basket options
+- `MCAmericanBasketEngine` Monte Carlo American basket engine (Longstaff-Schwartz)
+- `FdndimBlackScholesVanillaEngine` N-dimensional finite-difference Black-Scholes basket engine
+
+#### Cash Flows
+- `BlackCompoundingOvernightIndexedCouponPricer` Black pricer for capped/floored compounded overnight coupons
+- `BlackAveragingOvernightIndexedCouponPricer` Black pricer for capped/floored averaged overnight coupons
+
+#### Instruments
+- `ContinuousAveragingAsianOption` seasoned constructor with `startDate` parameter
+- `PartialTimeBarrierOption` partial-time barrier option with `PartialBarrierRange` enum
+- `SoftBarrierOption` soft barrier option with proportional knock-in/out over barrier range
+- `TwoAssetBarrierOption` barrier option monitored on a second correlated asset
+
+#### Core
+- `AmericanExercise` `payoffAtExpiry` parameter
+
+#### Term Structures
+- `MultiCurve` for simultaneous multi-curve bootstrap with dependency cycles (accuracy and optimizer constructors, `addBootstrappedCurve`, `addNonBootstrappedCurve`)
+- `PiecewiseLogLinearDiscountGlobal`, `PiecewiseLinearZeroGlobal`, `PiecewiseBackwardFlatForwardGlobal` piecewise yield curves using `GlobalBootstrap` (reference-date and settlement-days constructors, instrument weights)
+
 ## [0.6.0] - 2026-03-07
 
 ### Added
@@ -589,7 +637,10 @@ Initial release targeting QuantLib 1.40.
 - API is subject to change during beta period
 - `QdFpAmericanEngine` has a known issue on Windows (access violation during `calculate()`)
 
-[Unreleased]: https://github.com/quantales/pyquantlib/compare/v0.5.0...HEAD
+[Unreleased]: https://github.com/quantales/pyquantlib/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/quantales/pyquantlib/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/quantales/pyquantlib/compare/v0.5.1...v0.6.0
+[0.5.1]: https://github.com/quantales/pyquantlib/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/quantales/pyquantlib/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/quantales/pyquantlib/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/quantales/pyquantlib/compare/v0.2.0...v0.3.0

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/docs/installation.md

@@ -3,10 +3,15 @@
 ## Compatibility
 
 - **Python**: 3.10, 3.11, 3.12, 3.13
-- **QuantLib**: 1.40+
+- **QuantLib**: 1.41+
 - **Platforms**: Windows, macOS, Linux
 
-PyQuantLib provides bindings for a subset of QuantLib. Foundational components are available: time handling, term structures, common instruments, and pricing engines. Coverage is actively growing. See the {doc}`api/index` for what's available.
+| PyQuantLib | QuantLib | Notes |
+|---|---|---|
+| 0.1.0 -- 0.6.0 | 1.40, 1.41 | Built and tested against 1.40; verified compatible with 1.41 |
+| 0.7.0+ | 1.41+ | Requires 1.41 (uses MultiCurve/GlobalBootstrap API) |
+
+PyQuantLib provides comprehensive bindings for QuantLib, covering time handling, term structures, instruments, pricing engines, stochastic processes, models, finite-difference methods, Monte Carlo infrastructure, and more. See the {doc}`api/index` for the full list.
 
 ```{note}
 Check versions at runtime: `ql.__version__` (PyQuantLib) and `ql.QL_VERSION` (QuantLib).

{pyquantlib-0.6.0 → pyquantlib-0.7.0}/include/pyquantlib/pyquantlib.h

@@ -317,6 +317,8 @@ namespace ql_termstructures {
     void andreasenhugevolatilityadapter(py::module_&);
     void andreasenhugelocalvoladapter(py::module_&);
     void compositezeroyieldstructure(py::module_&);
+    void multicurve(py::module_&);
+    void globalbootstrap(py::module_&);
 }
 
 namespace ql_processes {
@@ -436,6 +438,9 @@ namespace ql_instruments {
     void quantoforwardvanillaoption(py::module_&);
     void holderextensibleoption(py::module_&);
     void writerextensibleoption(py::module_&);
+    void partialtimebarrieroption(py::module_&);
+    void softbarrieroption(py::module_&);
+    void twoassetbarrieroption(py::module_&);
 }
 
 namespace ql_pricingengines {
@@ -522,6 +527,7 @@ namespace ql_pricingengines {
     void analyticdigitalamericanengine(py::module_&);
     void mcdigitalengine(py::module_&);
     void analyticdividendeuropeanengine(py::module_&);
+    void cashdividendeuropeanengine(py::module_&);
     void analyticbsmhullwhiteengine(py::module_&);
     void analyticcapfloorengine(py::module_&);
     void treecapfloorengine(py::module_&);
@@ -539,6 +545,29 @@ namespace ql_pricingengines {
     void mcforwardeuropeanbsengine(py::module_&);
     void mcforwardeuropeanhestonengine(py::module_&);
     void mceuropeanhestonengine(py::module_&);
+    // Asian engines
+    void choiasianengine(py::module_&);
+    void analyticdiscretegeometricaveragestrikeengine(py::module_&);
+    void continuousarithmeticasianlevyengine(py::module_&);
+    void fdblackscholesasianengine(py::module_&);
+    void mcdiscretearithmeticaphestonengine(py::module_&);
+    void mcdiscretegeometricaphestonengine(py::module_&);
+    void mcdiscretearithmeticasengine(py::module_&);
+    void mcdiscretegeometricapengine(py::module_&);
+    // Barrier engines
+    void analyticbinarybarrierengine(py::module_&);
+    void binomialbarrierengine(py::module_&);
+    void fdhestonbarrierengine(py::module_&);
+    void fdhestondoublebarrierengine(py::module_&);
+    void fdhestonrebateengine(py::module_&);
+    void analyticpartialtimebarrieroptionengine(py::module_&);
+    void analyticsoftbarrierengine(py::module_&);
+    void analytictwoassetbarrierengine(py::module_&);
+    // Basket engines
+    void choibasketengine(py::module_&);
+    void singlefactorbsmbasketengine(py::module_&);
+    void mcamericanbasketengine(py::module_&);
+    void fdndimblackscholesvanillaengine(py::module_&);
 }
 
 namespace ql_methods {