Metadata-Version: 2.4
Name: deriweave-python
Version: 0.3.0
Summary: Composable derivatives pricing with the native DeriWeave C++20 engine
Keywords: derivatives,monte-carlo,quantitative-finance,pricing
Author: DeriWeave contributors
License-Expression: MIT
License-File: LICENSE
Requires-Python: >=3.10
Provides-Extra: numpy
Requires-Dist: numpy>=1.23; extra == "numpy"
Provides-Extra: test
Requires-Dist: pytest>=8; extra == "test"
Requires-Dist: numpy>=1.23; extra == "test"
Requires-Dist: build>=1.2; extra == "test"
Requires-Dist: scikit-build-core>=1.0; extra == "test"
Requires-Dist: pybind11<4,>=3.0; extra == "test"
Provides-Extra: release
Requires-Dist: build>=1.2; extra == "release"
Requires-Dist: twine>=6; extra == "release"
Description-Content-Type: text/markdown

# DeriWeavePython 0.3.0

Contrats financiers composables en Python, avec **DeriWeave C++20** pour la
simulation, les cashflows, les statistiques et Longstaff-Schwartz.
Les descriptions Python sont réutilisables ; aucun callback Python ne s'exécute
dans les boucles Monte Carlo.

Six modèles, expressions imbriquées, barrières discrètes, autocalls avec mémoire
et politiques LSM sont disponibles. La documentation détaillée accompagne
l'archive source : `docs/guide.md`, `docs/coverage.md` et `docs/AUDIT.md`.

## Installation avec pip

~~~bash
python -m pip install deriweave-python
~~~

La wheel prête à l'emploi cible **CPython 3.12, Windows x64**. Pour les autres
configurations, pip construit depuis les sources : un compilateur C++20 et
CMake sont alors nécessaires. La construction Linux/GCC est vérifiée sur Python 3.12.
NumPy est facultatif pour le pricing ; pour les matrices et diagnostics de chemin :

~~~bash
python -m pip install "deriweave-python[numpy]"
~~~

## Installer la wheel Windows fournie

Pour **CPython 3.12, Windows x64**, la wheel de `dist/` s'installe sans
compilateur C++. Dans un environnement virtuel activé :

~~~bat
python -m pip install dist\deriweave_python-0.3.0-cp312-cp312-win_amd64.whl
python examples\demo.py
~~~

Le nom du paquet est `deriweave-python`, l'import est `deriweave_py`.
La wheel et les sources permettent aussi une installation à partir d'un fichier
local. Les instructions de maintenance et de publication figurent dans
`docs/release.md`, inclus dans l'archive source.

## Compiler et installer sous Windows

Prérequis : Python 64 bits 3.10+, MSVC C++20 et CMake 3.20+.
Validation sur Python 3.12.3, MSVC 19.51 et pybind11 3.1.0.
Ouvrir une **x64 Native Tools Command Prompt** de Visual Studio :

~~~bat
python -m venv .venv
.venv\Scripts\activate
python -m pip install .
~~~

Réutiliser le .venv existant sans le recréer si souhaité.
Le moteur et les en-têtes Eigen sont inclus dans les sources et conservés par
les règles Git du projet : un checkout complet suffit pour `pip install .`.
CMake n'a pas besoin du réseau ; pip peut télécharger le backend de construction.
Pour une copie privée de ses dépendances, `python prepare_windows.py` récupère
uniquement les sources manquantes, sur Windows ou Linux. Il réutilise les sources
existantes et ne compile pas Eigen. Les corrections vérifiées par empreintes sont
appliquées avant d'installer une nouvelle copie du moteur.

Avec NumPy et les tests :

~~~bat
python -m pip install ".[test]"
python tools\build_local.py --tests
python -m pytest -q
~~~

`tools/build_local.py` installe le binaire qu'il construit avant de lancer les
tests natifs ; les appels Python suivants utilisent donc cette compilation.
INSTALL_WINDOWS.bat automatise préparation, installation, tests et exemples.

## Installation Linux

Avec Python, venv, les en-têtes de développement Python, un compilateur C++20 et
CMake installés :

~~~bash
python3 -m venv .venv
. .venv/bin/activate
python -m pip install .
~~~

Un Eigen 3.4+ installé est prioritaire ; les en-têtes inclus servent de repli.
La validation Linux/GCC et ses limites figurent dans le rapport d'audit.

## Premier prix

~~~python
import deriweave_py as dw

asset = dw.Asset("AAPL")
product = dw.Product(dw.Call(dw.Spot(asset, 1.0), 100), payment_date=1.05)
market = dw.Market({"AAPL": 100}, rate=0.03, dividend_yields={"AAPL": 0.02})
model = dw.BlackScholes(0.20)
settings = dw.SimulationSettings(n_simulations=20_000, seed=42, antithetic=True)
result = dw.price(product, market=market, model=model, settings=settings)
print(result.price, result.standard_error, result.confidence_interval_95)
~~~

L'observation à 1.0 et le paiement à 1.05 restent distincts.
20 000 observations antithétiques produisent 40 000 trajectoires.

## Produits composables

~~~python
import deriweave_py as dw

observations = [
    dw.Basket([dw.Spot("A", t), dw.Spot("B", t)], [0.5, 0.5])
    for t in [0.25, 0.5, 0.75, 1.0]
]
product = dw.Product(dw.Call(dw.Average(observations), 105), payment_date=1.0)
result = dw.price(product, market=dw.Market({"A": 100, "B": 110}, 0.03),
                  model=dw.BlackScholes([0.20, 0.25], [[1, 0.4], [0.4, 1]]))
print(result.price)
~~~

Un call sur panier diffère d'un panier de calls. Les moyennes imbriquées
conservent leur ordre et leurs observations répétées.

## Exercice anticipé

~~~python
import deriweave_py as dw

t = dw.ExerciseTime
contract = dw.American(
    payoff=dw.Put(dw.Spot("A", t), 100),
    states=[dw.Spot("A", t)], start=0, maturity=1,
)
market = dw.Market({"A": 100}, 0.03)
model = dw.BlackScholes(0.20)
policy = dw.train_longstaff_schwartz(
    contract, market=market, model=model,
    settings=dw.LsmSettings(training_paths=4000, seed=7919,
                            max_exercise_time_step=1/12),
)
result = dw.price(policy, market=market, model=model,
                  settings=dw.SimulationSettings(n_simulations=6000, seed=42))
print(result.price, policy.exercise_dates)
~~~

L'entraînement reste séparé de l'évaluation. Sous Heston, utiliser au minimum
spot et variance comme états pour une vanille. L'intervalle de confiance est
conditionnel à la politique apprise.

## Vérifier une distribution

Après installation de `.[test,release]` et construction de la référence C++ avec
`python tools/build_local.py --tests` :

~~~bash
python tools/check_distribution.py --tests
~~~

Cette commande construit la wheel depuis l'archive source, contrôle ses contenus
et installe la wheel dans un venv neuf. Elle vérifie d'abord le pricing sans
NumPy, puis exécute tous les tests Python et les cinq exemples.
`--no-isolation` réutilise les dépendances de construction déjà installées.

## Exemples et OpenMP

~~~bash
python examples/demo.py
python examples/composition_demo.py
python examples/models_demo.py
python examples/structured_demo.py
python examples/exercise_demo.py
python tools/memory_check.py
~~~

OpenMP est désactivé par défaut. Pour l'activer :

~~~bash
python -m pip install . -Ccmake.define.DERIWEAVE_ENABLE_OPENMP=ON
~~~

Utiliser ensuite SimulationSettings(use_openmp=True, num_threads=4).
dw.build_info() indique les capacités réelles du binaire.
Le runtime du compilateur est requis : vcomp140.dll sous MSVC, libgomp avec GCC.
La wheel séquentielle évite cette dépendance.

Les fonctions historiques european, asian et basket restent disponibles.
Base : [DeriWeave 0.1.0](https://github.com/AmineFendi94/DeriWeave),
commit 8e54378b0800c936e22c2abca0afaca751c73888, avec les corrections de portabilité
documentées dans l'audit. Licence MIT ; Eigen conserve ses licences.
