pyquantlib 0.3.0__tar.gz → 0.5.1__tar.gz

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyquantlib
-Version: 0.3.0
+Version: 0.5.1
 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>
@@ -94,8 +94,6 @@ Description-Content-Type: text/markdown
 [![Python](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/quantales/pyquantlib/blob/main/CONTRIBUTING.md)
 
-> **Beta Status**: This project is under active development. API may change.
-
 ## Overview
 
 PyQuantLib provides Python bindings for [QuantLib](https://www.quantlib.org/), the open-source library for quantitative finance. Built with [pybind11](https://github.com/pybind/pybind11), it offers a more Pythonic API than existing alternatives.
@@ -248,6 +246,3 @@ BSD 3-Clause License. See [LICENSE](LICENSE) for details.
 - [pybind11](https://github.com/pybind/pybind11) - C++/Python bindings
 - [scikit-build-core](https://github.com/scikit-build/scikit-build-core) - Build system
 
-## Status
-
-PyQuantLib is under active development. For broader QuantLib coverage today, use [QuantLib-SWIG](https://github.com/lballabio/QuantLib-SWIG).

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/README.md

@@ -11,8 +11,6 @@
 [![Python](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/quantales/pyquantlib/blob/main/CONTRIBUTING.md)
 
-> **Beta Status**: This project is under active development. API may change.
-
 ## Overview
 
 PyQuantLib provides Python bindings for [QuantLib](https://www.quantlib.org/), the open-source library for quantitative finance. Built with [pybind11](https://github.com/pybind/pybind11), it offers a more Pythonic API than existing alternatives.
@@ -165,6 +163,3 @@ BSD 3-Clause License. See [LICENSE](LICENSE) for details.
 - [pybind11](https://github.com/pybind/pybind11) - C++/Python bindings
 - [scikit-build-core](https://github.com/scikit-build/scikit-build-core) - Build system
 
-## Status
-
-PyQuantLib is under active development. For broader QuantLib coverage today, use [QuantLib-SWIG](https://github.com/lballabio/QuantLib-SWIG).

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/_static/custom.css

@@ -1,5 +1,18 @@
 /* PyQuantLib documentation custom styles */
 
+/* Lower Furo's right sidebar breakpoint from 82em (1312px) to 72em (1152px) */
+@media (min-width: 72em) and (max-width: 82em) {
+    .toc-drawer {
+        position: static !important;
+        right: auto !important;
+        height: auto !important;
+        border-left: none;
+    }
+    .toc-content-icon {
+        display: none !important;
+    }
+}
+
 /* Headline sizes and spacing */
 h1 { 
     font-size: 2rem;

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/api/cashflows.md

@@ -348,6 +348,51 @@ pricer = ql.BlackYoYInflationCouponPricer(yoy_vol_handle)
 ql.setCouponPricer(yoy_leg, pricer)
 ```
 
+## Dividends
+
+### FixedDividend
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FixedDividend
+```
+
+Fixed cash dividend.
+
+```python
+div = ql.FixedDividend(2.50, ql.Date(15, 6, 2026))
+print(div.amount())  # 2.5
+print(div.date())    # June 15th, 2026
+```
+
+### FractionalDividend
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FractionalDividend
+```
+
+Fractional (proportional) dividend: amount = rate * nominal.
+
+```python
+div = ql.FractionalDividend(0.03, 100.0, ql.Date(15, 6, 2026))
+print(div.rate())     # 0.03
+print(div.nominal())  # 100.0
+```
+
+### DividendVector
+
+```{eval-rst}
+.. autofunction:: pyquantlib.DividendVector
+```
+
+Builds a sequence of fixed dividends from dates and amounts.
+
+```python
+divs = ql.DividendVector(
+    [ql.Date(15, 6, 2026), ql.Date(15, 12, 2026)],
+    [2.50, 2.50],
+)
+```
+
 ## Duration
 
 ### DurationType

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/api/experimental.md

@@ -47,6 +47,69 @@ print(smile.volatility(110.0))  # OTM call vol
 call_price = smile.optionPrice(110.0, ql.OptionType.Call)
 ```
 
+## Callable Bonds
+
+### CallableBondVolatilityStructure
+
+```{eval-rst}
+.. autoclass:: pyquantlib.base.CallableBondVolatilityStructure
+```
+
+Abstract base class for callable-bond volatility term structures.
+
+### CallableBondConstantVolatility
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CallableBondConstantVolatility
+```
+
+```python
+vol = ql.CallableBondConstantVolatility(today, 0.10, ql.Actual365Fixed())
+# or with a Quote
+vol = ql.CallableBondConstantVolatility(today, ql.SimpleQuote(0.10),
+                                         ql.Actual365Fixed())
+```
+
+### TreeCallableFixedRateBondEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.TreeCallableFixedRateBondEngine
+```
+
+### TreeCallableZeroCouponBondEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.TreeCallableZeroCouponBondEngine
+```
+
+```python
+hw_model = ql.HullWhite(curve_handle, 0.03, 0.01)
+engine = ql.TreeCallableFixedRateBondEngine(hw_model, 100)
+bond.setPricingEngine(engine)
+print(bond.cleanPrice())
+```
+
+### BlackCallableFixedRateBondEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BlackCallableFixedRateBondEngine
+```
+
+### BlackCallableZeroCouponBondEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BlackCallableZeroCouponBondEngine
+```
+
+```python
+# Black engine requires exactly one call/put date
+vol = ql.CallableBondConstantVolatility(today, 0.10, dc)
+engine = ql.BlackCallableFixedRateBondEngine(vol, discount_curve)
+bond.setPricingEngine(engine)
+print(bond.cleanPrice())
+print(bond.impliedVolatility(target_price, curve, 1e-8, 200, 0.001, 0.50))
+```
+
 ## Credit
 
 ### CdsOption

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/api/index.md

@@ -20,6 +20,7 @@ PyQuantLib organizes QuantLib classes into logical groups:
 - **Term Structures**: Yield curves, volatility surfaces
 - **Processes**: Stochastic processes (Black-Scholes, Heston)
 - **Models**: Pricing models (Heston, etc.)
+- **Methods**: Monte Carlo paths, Brownian bridges, generators
 - **Instruments**: Financial instruments (options, etc.)
 - **Pricing Engines**: Analytic, Monte Carlo, finite difference
 - **Experimental**: Experimental QuantLib features (SVI, etc.)
@@ -69,6 +70,7 @@ indexes
 termstructures
 processes
 models
+methods
 instruments
 pricingengines
 experimental

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

@@ -217,6 +217,25 @@ swap_index = ql.EuriborSwapIsdaFixA(ql.Period(5, ql.Years), forwarding_curve)
 swap_index = ql.EuriborSwapIsdaFixA(ql.Period(5, ql.Years), forwarding_curve, discounting_curve)
 ```
 
+## Equity Indexes
+
+### EquityIndex
+
+```{eval-rst}
+.. autoclass:: pyquantlib.EquityIndex
+```
+
+Equity index for total return swap pricing. Supports interest rate and dividend curves.
+
+```python
+eq_index = ql.EquityIndex("SPX", ql.UnitedStates(ql.UnitedStates.NYSE),
+                           ql.USDCurrency())
+
+# With term structures
+eq_index = ql.EquityIndex("SPX", ql.UnitedStates(ql.UnitedStates.NYSE),
+                           ql.USDCurrency(), interest_ts, dividend_ts, spot)
+```
+
 ## Regions
 
 Regions identify the geographic area for inflation indexes.

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/api/instruments.md

@@ -98,6 +98,143 @@ bond = ql.CPIBond(2, 100.0, 315.0, ql.Period(3, ql.Months),
                    ql.Actual365Fixed())
 ```
 
+## Callable Bonds
+
+### Callability
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Callability
+```
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CallabilityType
+   :members:
+   :undoc-members:
+```
+
+| Value | Description |
+|-------|-------------|
+| `Call` | Issuer can call (redeem early) |
+| `Put` | Holder can put (sell back early) |
+
+```python
+call_price = ql.BondPrice(100.0, ql.BondPriceType.Clean)
+call = ql.Callability(call_price, ql.CallabilityType.Call,
+                       ql.Date(15, ql.June, 2030))
+```
+
+### CallableFixedRateBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CallableFixedRateBond
+```
+
+```python
+call_schedule = [
+    ql.Callability(ql.BondPrice(100.0, ql.BondPriceType.Clean),
+                    ql.CallabilityType.Call, call_date)
+    for call_date in call_dates
+]
+bond = ql.CallableFixedRateBond(2, 100.0, schedule, [0.05],
+                                 ql.Actual365Fixed(),
+                                 putCallSchedule=call_schedule)
+bond.setPricingEngine(ql.TreeCallableFixedRateBondEngine(hw_model, 100))
+print(bond.cleanPrice())
+print(bond.OAS(clean_price, curve, dc, ql.Continuous, ql.Annual))
+```
+
+### CallableZeroCouponBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CallableZeroCouponBond
+```
+
+## Convertible Bonds
+
+### SoftCallability
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SoftCallability
+```
+
+Callability with a trigger level for soft-call provisions.
+
+```python
+soft_call = ql.SoftCallability(
+    ql.BondPrice(110.0, ql.BondPriceType.Clean),
+    call_date, 1.20,
+)
+```
+
+### ConvertibleBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ConvertibleBond
+   :members:
+```
+
+Base class for convertible bonds (not directly constructible).
+
+### ConvertibleZeroCouponBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ConvertibleZeroCouponBond
+```
+
+```python
+exercise = ql.AmericanExercise(today, maturity)
+bond = ql.ConvertibleZeroCouponBond(
+    exercise, 1.0, [], issue_date, 2,
+    ql.Actual365Fixed(), schedule,
+)
+bond.setPricingEngine(ql.BinomialConvertibleEngine(process, "crr", 801))
+print(bond.NPV())
+```
+
+### ConvertibleFixedCouponBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ConvertibleFixedCouponBond
+```
+
+```python
+bond = ql.ConvertibleFixedCouponBond(
+    exercise, 1.0, call_schedule, issue_date, 2,
+    [0.05], ql.Thirty360(ql.Thirty360.BondBasis), schedule,
+)
+```
+
+### ConvertibleFloatingRateBond
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ConvertibleFloatingRateBond
+```
+
+```python
+bond = ql.ConvertibleFloatingRateBond(
+    exercise, 1.0, [], issue_date, 2,
+    euribor6m, 2, [0.005], ql.Actual360(), schedule,
+)
+```
+
+### EquityTotalReturnSwap
+
+```{eval-rst}
+.. autoclass:: pyquantlib.EquityTotalReturnSwap
+```
+
+Equity total return swap: equity leg vs interest rate leg.
+
+```python
+trs = ql.EquityTotalReturnSwap(
+    ql.SwapType.Payer, 1_000_000.0, schedule,
+    equity_index, ibor_index, ql.Actual360(), 0.005,
+)
+trs.setPricingEngine(ql.DiscountingSwapEngine(curve))
+print(trs.NPV())
+print(trs.fairMargin())
+```
+
 ## Swaps
 
 ### VanillaSwap
@@ -508,8 +645,190 @@ asian_arith = ql.DiscreteAveragingAsianOption(
 asian_arith.setPricingEngine(ql.TurnbullWakemanAsianEngine(process))
 ```
 
+## Lookback Options
+
+### ContinuousFloatingLookbackOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ContinuousFloatingLookbackOption
+```
+
+Continuous floating-strike lookback option. The strike is determined at expiry as the minimum (call) or maximum (put) of the asset price over the option's life.
+
+```python
+payoff = ql.FloatingTypePayoff(ql.Call)
+exercise = ql.EuropeanExercise(expiry)
+option = ql.ContinuousFloatingLookbackOption(100.0, payoff, exercise)
+```
+
+### ContinuousFixedLookbackOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ContinuousFixedLookbackOption
+```
+
+Continuous fixed-strike lookback option. The payoff is based on the maximum (call) or minimum (put) of the asset price over the option's life.
+
+```python
+payoff = ql.PlainVanillaPayoff(ql.Call, 100.0)
+exercise = ql.EuropeanExercise(expiry)
+option = ql.ContinuousFixedLookbackOption(100.0, payoff, exercise)
+```
+
+### ContinuousPartialFloatingLookbackOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ContinuousPartialFloatingLookbackOption
+```
+
+Partial floating-strike lookback option with a lookback period ending before expiry.
+
+```python
+option = ql.ContinuousPartialFloatingLookbackOption(
+    100.0, 1.0, lookback_end, payoff, exercise,
+)
+```
+
+### ContinuousPartialFixedLookbackOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ContinuousPartialFixedLookbackOption
+```
+
+Partial fixed-strike lookback option with a lookback period starting after inception.
+
+```python
+option = ql.ContinuousPartialFixedLookbackOption(
+    lookback_start, payoff, exercise,
+)
+```
+
+## Cliquet Options
+
+### CliquetOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CliquetOption
+```
+
+Cliquet (ratchet) option with periodic resets. The strike resets at each reset date to the then-current spot price.
+
+```python
+payoff = ql.PercentageStrikePayoff(ql.Call, 1.0)
+exercise = ql.EuropeanExercise(expiry)
+reset_dates = [today + ql.Period(f"{i}M") for i in range(3, 12, 3)]
+option = ql.CliquetOption(payoff, exercise, reset_dates)
+```
+
+## Compound Options
+
+### CompoundOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.CompoundOption
+```
+
+Compound option (option on an option). The mother option gives the right to buy/sell the daughter option.
+
+```python
+mother_payoff = ql.PlainVanillaPayoff(ql.Call, 5.0)
+mother_exercise = ql.EuropeanExercise(today + ql.Period("6M"))
+daughter_payoff = ql.PlainVanillaPayoff(ql.Call, 100.0)
+daughter_exercise = ql.EuropeanExercise(expiry)
+option = ql.CompoundOption(
+    mother_payoff, mother_exercise, daughter_payoff, daughter_exercise,
+)
+```
+
+## Chooser Options
+
+### SimpleChooserOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SimpleChooserOption
+```
+
+Simple chooser option. The holder chooses at a future date whether the option is a call or put.
+
+```python
+option = ql.SimpleChooserOption(choosing_date, 100.0, exercise)
+```
+
+### ComplexChooserOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ComplexChooserOption
+```
+
+Complex chooser option with different strikes and exercise dates for the call and put legs.
+
+```python
+option = ql.ComplexChooserOption(
+    choosing_date, call_strike, put_strike, call_exercise, put_exercise,
+)
+```
+
+## Margrabe Options
+
+### MargrabeOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MargrabeOption
+```
+
+Margrabe option (exchange option): the right to exchange one asset for another.
+
+```python
+option = ql.MargrabeOption(1, 1, exercise)
+option.setPricingEngine(engine)
+print(option.delta1(), option.delta2())
+print(option.gamma1(), option.gamma2())
+```
+
+## Forward-Start Options
+
+### ForwardVanillaOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ForwardVanillaOption
+```
+
+Forward-start vanilla option. The strike is set at a future reset date based on a moneyness ratio.
+
+```python
+option = ql.ForwardVanillaOption(1.0, reset_date, payoff, exercise)
+```
+
+## Quanto Options
+
+### QuantoVanillaOption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.QuantoVanillaOption
+```
+
+Quanto vanilla option with currency adjustment. Provides quanto-specific greeks: `qvega()`, `qrho()`, `qlambda()`.
+
+```python
+option = ql.QuantoVanillaOption(payoff, exercise)
+option.setPricingEngine(engine)
+print(option.qvega(), option.qrho(), option.qlambda())
+```
+
 ## Payoffs
 
+### FloatingTypePayoff
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FloatingTypePayoff
+```
+
+Floating-strike payoff for lookback options.
+
+```python
+payoff = ql.FloatingTypePayoff(ql.Call)
+```
+
 ### PlainVanillaPayoff
 
 ```{eval-rst}
@@ -659,6 +978,38 @@ payoff = ql.SuperSharePayoff(90.0, 110.0, 5.0)
 .. autoclass:: pyquantlib.FloatFloatSwap
 ```
 
+### NonstandardSwaption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.NonstandardSwaption
+```
+
+### FloatFloatSwaption
+
+```{eval-rst}
+.. autoclass:: pyquantlib.FloatFloatSwaption
+```
+
+## Bond Forwards
+
+### Forward
+
+```{eval-rst}
+.. autoclass:: pyquantlib.base.Forward
+```
+
+### ForwardTypePayoff
+
+```{eval-rst}
+.. autoclass:: pyquantlib.ForwardTypePayoff
+```
+
+### BondForward
+
+```{eval-rst}
+.. autoclass:: pyquantlib.BondForward
+```
+
 ## Exercise Types
 
 ### EuropeanExercise

{pyquantlib-0.3.0 → pyquantlib-0.5.1}/docs/api/math.md

@@ -150,6 +150,52 @@ Monotonicity-preserving cubic spline that prevents oscillations.
 The abstract base class `Interpolation` is available in `pyquantlib.base` for type checking.
 ```
 
+## Statistics
+
+### Statistics
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Statistics
+```
+
+General statistics accumulator with empirical-distribution risk measures, Gaussian-assumption analytics, and percentile/VaR/ES methods.
+
+```python
+stats = ql.Statistics()
+stats.addSequence([1.0, 2.0, 3.0, 4.0, 5.0])
+print(stats.mean(), stats.standardDeviation(), stats.skewness())
+```
+
+### IncrementalStatistics
+
+```{eval-rst}
+.. autoclass:: pyquantlib.IncrementalStatistics
+```
+
+Online (streaming) statistics via boost accumulators. Supports weighted observations.
+
+```python
+stats = ql.IncrementalStatistics()
+stats.add(1.0, 1.0)
+stats.add(2.0, 1.0)
+print(stats.mean(), stats.weightSum())
+```
+
+### SequenceStatistics
+
+```{eval-rst}
+.. autoclass:: pyquantlib.SequenceStatistics
+```
+
+N-dimensional statistics with covariance and correlation matrices.
+
+```python
+stats = ql.SequenceStatistics(2)
+stats.add([1.0, 2.0])
+stats.add([3.0, 4.0])
+print(stats.mean(), stats.covariance())
+```
+
 ## Optimization
 
 ### EndCriteria