pyquantlib 0.5.1__tar.gz → 0.7.0__tar.gz

{pyquantlib-0.5.1 → 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:
@@ -101,12 +101,12 @@ jobs:
 
       - name: Run tests with coverage
         run: |
-          pytest --cov=tests --cov-report=xml --cov-report=term-missing
+          pytest --cov=pyquantlib --cov=tests --cov-report=xml --cov-report=term-missing
         env:
           LD_LIBRARY_PATH: /home/runner/quantlib-install/lib
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           files: ./coverage.xml
           fail_ci_if_error: false

{pyquantlib-0.5.1 → 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.5.1 → 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:
@@ -34,6 +34,32 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Pre-cache virtualenv for cibuildwheel
+        shell: bash
+        run: |
+          VER=20.26.6
+          if [ "$RUNNER_OS" = "Windows" ]; then
+            CACHE_DIR="$LOCALAPPDATA/pypa/cibuildwheel/Cache"
+          elif [ "$RUNNER_OS" = "macOS" ]; then
+            CACHE_DIR="$HOME/Library/Caches/cibuildwheel"
+          else
+            CACHE_DIR="$HOME/.cache/cibuildwheel"
+          fi
+          mkdir -p "$CACHE_DIR"
+          DEST="$CACHE_DIR/virtualenv-${VER}.pyz"
+          if [ ! -f "$DEST" ]; then
+            for i in 1 2 3 4 5; do
+              if curl -sL --retry 3 --retry-delay 10 -o "$DEST" \
+                "https://github.com/pypa/get-virtualenv/blob/${VER}/public/virtualenv.pyz?raw=true"; then
+                echo "Downloaded virtualenv-${VER}.pyz (attempt $i)"
+                break
+              fi
+              echo "Attempt $i failed, waiting 30s..."
+              sleep 30
+            done
+          fi
+          ls -la "$DEST"
+
       - name: Build wheels
         uses: pypa/cibuildwheel@v2.21
         env:

{pyquantlib-0.5.1 → 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.5.1 → 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.5.1 → pyquantlib-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyquantlib
-Version: 0.5.1
+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.5.1 → pyquantlib-0.7.0}/docs/api/cashflows.md

@@ -108,6 +108,121 @@ coupon = ql.CmsCoupon(
 )
 ```
 
+## Capped/Floored Coupons
+
+### CappedFlooredCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CappedFlooredCoupon
+```
+
+Wraps a floating-rate coupon with optional cap and/or floor. Use `None` for absent cap or floor.
+
+```python
+underlying = ql.IborCoupon(payment_date, 1e6, start, end, 2, euribor6m)
+cf = ql.CappedFlooredCoupon(underlying, cap=0.05, floor=0.01)
+print(cf.isCapped(), cf.isFloored())  # True True
+print(cf.effectiveCap(), cf.effectiveFloor())
+```
+
+### CappedFlooredIborCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CappedFlooredIborCoupon
+```
+
+Convenience class that builds a capped/floored Ibor coupon in a single constructor.
+
+### CappedFlooredCmsCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CappedFlooredCmsCoupon
+```
+
+Convenience class that builds a capped/floored CMS coupon in a single constructor.
+
+## Digital Coupons
+
+### DigitalCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalCoupon
+```
+
+Floating-rate coupon with embedded digital (binary) call and/or put option.
+
+```python
+dc = ql.DigitalCoupon(underlying, callStrike=0.04, putStrike=0.02)
+print(dc.hasCall(), dc.hasPut(), dc.hasCollar())  # True True True
+```
+
+### DigitalIborCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalIborCoupon
+```
+
+Digital coupon specialized for Ibor underlyings.
+
+### DigitalCmsCoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalCmsCoupon
+```
+
+Digital coupon specialized for CMS underlyings.
+
+### DigitalIborLeg
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalIborLeg
+```
+
+Fluent builder for a leg of digital Ibor coupons.
+
+```python
+leg = ql.DigitalIborLeg(schedule, euribor6m) \
+    .withNotionals(1e6) \
+    .withCallStrikes(0.04) \
+    .withLongCallOption(ql.PositionType.Long) \
+    .withReplication(ql.DigitalReplication()) \
+    .build()
+```
+
+### DigitalCmsLeg
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalCmsLeg
+```
+
+Fluent builder for a leg of digital CMS coupons. Same API as `DigitalIborLeg` but takes a `SwapIndex`.
+
+### ReplicationType
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ReplicationType
+   :members:
+   :undoc-members:
+```
+
+| Value | Description |
+|-------|-------------|
+| `Sub` | Sub-replication (lower bound) |
+| `Central` | Central replication |
+| `Super` | Super-replication (upper bound) |
+
+### DigitalReplication
+
+```{eval-rst}
+.. autoclass:: pyquantlib.DigitalReplication
+```
+
+Configuration for digital option replication strategy.
+
+```python
+repl = ql.DigitalReplication(ql.ReplicationType.Central, gap=1e-4)
+```
+
 ## Coupon Pricers
 
 ### BlackIborCouponPricer
@@ -150,6 +265,101 @@ ql.setCouponPricer(cms_leg, pricer)
    :undoc-members:
 ```
 
+### YieldCurveModel
+
+```{eval-rst}
+.. autoclass:: pyquantlib.YieldCurveModel
+   :members:
+   :undoc-members:
+```
+
+| Value | Description |
+|-------|-------------|
+| `Standard` | Standard yield curve model |
+| `ExactYield` | Exact yield model |
+| `ParallelShifts` | Parallel shifts model |
+| `NonParallelShifts` | Non-parallel shifts model |
+
+### HaganPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.HaganPricer
+```
+
+Abstract base class for Hagan-style CMS coupon pricers using static replication. Inherits from both `CmsCouponPricer` and `MeanRevertingPricer`.
+
+### AnalyticHaganPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AnalyticHaganPricer
+```
+
+Analytic CMS coupon pricer based on the Hagan formula.
+
+```python
+pricer = ql.AnalyticHaganPricer(
+    swaption_vol, ql.YieldCurveModel.Standard, mean_reversion
+)
+ql.setCouponPricer(cms_leg, pricer)
+```
+
+### NumericHaganPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.NumericHaganPricer
+```
+
+Numeric CMS coupon pricer using Hagan integration with configurable limits.
+
+```python
+pricer = ql.NumericHaganPricer(
+    swaption_vol, ql.YieldCurveModel.Standard, mean_reversion,
+    lowerLimit=0.0, upperLimit=1.0, precision=1e-6
+)
+```
+
+### CompoundingOvernightIndexedCouponPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CompoundingOvernightIndexedCouponPricer
+```
+
+Pricer for compounded overnight indexed coupons.
+
+### ArithmeticAveragedOvernightIndexedCouponPricer
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ArithmeticAveragedOvernightIndexedCouponPricer
+```
+
+Pricer for arithmetically averaged overnight indexed coupons with optional convexity adjustment.
+
+```python
+# Default (no convexity adjustment)
+pricer = ql.ArithmeticAveragedOvernightIndexedCouponPricer()
+
+# With convexity adjustment parameters
+pricer = ql.ArithmeticAveragedOvernightIndexedCouponPricer(
+    meanReversion=0.03, volatility=0.01, byApprox=False
+)
+```
+
+### 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}
@@ -216,6 +426,31 @@ leg = ql.CmsLeg(schedule, swap_index) \
     .build()
 ```
 
+## BMA Coupons
+
+### AverageBMACoupon
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AverageBMACoupon
+```
+
+Coupon paying the weighted average of BMA fixings.
+
+### AverageBMALeg
+
+```{eval-rst}
+.. autoclass:: pyquantlib.AverageBMALeg
+```
+
+Builder for a sequence of average BMA coupons.
+
+```python
+bma = ql.BMAIndex(curve)
+leg = ql.AverageBMALeg(schedule, bma) \
+    .withNotionals(1e6) \
+    .leg()
+```
+
 ## Settings
 
 ### IborCouponSettings
@@ -408,5 +643,5 @@ divs = ql.DividendVector(
 | `Modified` | Modified duration |
 
 ```{note}
-Abstract base classes `CashFlow`, `Coupon`, `FloatingRateCouponPricer`, `MeanRevertingPricer`, `CmsCouponPricer`, `InflationCoupon`, and `InflationCouponPricer` are available in `pyquantlib.base` for custom implementations.
+Abstract base classes `CashFlow`, `Coupon`, `FloatingRateCouponPricer`, `MeanRevertingPricer`, `CmsCouponPricer`, `HaganPricer`, `InflationCoupon`, and `InflationCouponPricer` are available in `pyquantlib.base` for `isinstance` checks and custom implementations.
 ```

{pyquantlib-0.5.1 → pyquantlib-0.7.0}/docs/api/core.md

@@ -116,6 +116,17 @@ equivalent = rate.equivalentRate(ql.Continuous, ql.NoFrequency, 1.0)
 | `SimpleThenCompounded` | Simple for $t < 1/n$, then compounded |
 | `CompoundedThenSimple` | Compounded for $t \geq 1/n$, then simple |
 
+### PositionType
+
+```{eval-rst}
+.. autoclass:: pyquantlib.PositionType
+```
+
+| Value | Description |
+|-------|-------------|
+| `Long` | Long position |
+| `Short` | Short position |
+
 ### ProtectionSide
 
 ```{eval-rst}

{pyquantlib-0.5.1 → pyquantlib-0.7.0}/docs/api/indexes.md

@@ -217,6 +217,40 @@ swap_index = ql.EuriborSwapIsdaFixA(ql.Period(5, ql.Years), forwarding_curve)
 swap_index = ql.EuriborSwapIsdaFixA(ql.Period(5, ql.Years), forwarding_curve, discounting_curve)
 ```
 
+## BMA Index
+
+### BMAIndex
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BMAIndex
+```
+
+Bond Market Association index (tax-exempt municipal reference rate). Fixes weekly on Wednesdays.
+
+```python
+bma = ql.BMAIndex()              # without forwarding curve
+bma = ql.BMAIndex(curve)         # with forwarding curve
+sched = bma.fixingSchedule(start, end)
+```
+
+## Swap Spread Index
+
+### SwapSpreadIndex
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SwapSpreadIndex
+```
+
+Spread between two swap rate indexes with configurable gearings.
+
+```python
+idx1 = ql.EuriborSwapIsdaFixA(ql.Period("2Y"), curve)
+idx2 = ql.EuriborSwapIsdaFixA(ql.Period("10Y"), curve)
+spread = ql.SwapSpreadIndex("CMS2s10s", idx1, idx2)
+# Custom gearings: 0.5 * idx1 - 0.5 * idx2
+spread = ql.SwapSpreadIndex("Weighted", idx1, idx2, 0.5, -0.5)
+```
+
 ## Equity Indexes
 
 ### EquityIndex

{pyquantlib-0.5.1 → 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