moqua 0.1.5__tar.gz

moqua-0.1.5/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: moqua
+Version: 0.1.5
+Summary: Quantitative Finance Tools
+Author: M. Drici
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: seaborn
+Requires-Dist: statsmodels
+Requires-Dist: pybind11>=2.4
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: summary

moqua-0.1.5/README.md

@@ -0,0 +1,88 @@
+# Quant Tools Package
+
+A lightweight Python package for quantitative finance calculations, including Black-Scholes pricing, statistical analysis (ADF, Kalman Filter), and optimization methods.
+
+## 1. Installation (For the Developer)
+
+As the author of this package, you will always want to install it from the source code in "editable" mode. This allows you to modify the source files (`pricing.py`, `C++ files`, etc.) and have those changes instantly available across all your projects.
+
+### Case A: Working inside the `moqua` directory
+If you are modifying the package itself, open your terminal in this directory and run:
+```bash
+pip install -e .
+```
+
+### Case B: Using `moqua` in ANOTHER project on your PC
+If you create a new trading algorithm in a completely different folder (e.g., `E:\nouveau_projet_trading`), do NOT copy the files! Instead:
+1. Open your terminal in your **new project's directory**.
+2. Activate your new project's virtual environment (if you use one).
+3. Point `pip` to your master `moqua` directory using the `-e` (editable) flag:
+```bash
+pip install -e E:\m.drici\moqua
+```
+*Result: Your new project can now `import moqua`. Any changes you make to `E:\m.drici\moqua` in the future will automatically update in this new project without needing to reinstall.*
+
+## 2. How to Update
+
+### Code Changes
+Since the package is installed in editable mode, you **do not** need to run any commands to update the code. simply save your changes in `params.py`, `stats.py`, etc., and they will be live instantly.
+
+### Adding New Dependencies
+If you add a new library to `install_requires` in `setup.py`, you must update the installation:
+
+```bash
+pip install -e . --upgrade
+```
+
+## 3. Usage
+
+You can import functions from `moqua` in any Python script on your system, regardless of where the script is located.
+
+### Examples
+
+**Option Pricing (params.py)**
+```python
+from moqua.pricing import bs_price, bs_vega, EuropeanOption
+
+# Calculate Price
+price = bs_price(S=100, K=100, T=1, r=0.05, sigma=0.2, option_type='call')
+```
+
+**Statistical Analysis (stats.py)**
+```python
+from moqua.stats import z_score, adf, kalman_dynamic_beta
+
+# Calculate Z-Score
+z = z_score(price_series, window=20)
+```
+
+**Optimization (optimization.py)**
+```python
+from moqua.optimization import newton_raphson, dichotomy
+```
+
+## 4. Installation for End Users
+
+If you only need to *use* the `moqua` package (without seeing the source code or compiling the C++ modules), you can install the pre-compiled version directly from PyPI.
+
+Simply open your terminal and run:
+```bash
+pip install moqua
+```
+This will automatically download and install the pre-compiled binary package matching your operating system.
+
+## 5. Developer: Publishing to PyPI
+
+The publishing process to PyPI is fully automated via GitHub Actions (`build_wheels.yml`). 
+
+**Important Note on Automation:**
+J'ai configuré l'automatisation pour qu'elle ne publie pas sur PyPI à chaque petit commit, mais **uniquement quand tu crées une Release / Tag**.
+
+To publish a new version:
+1. Update the `version` number in `setup.py`.
+2. Commit and push your changes to the `main` branch.
+3. Go to GitHub -> **Releases** -> **Create a new release**.
+4. Create a new tag (e.g., `v0.1.1`) matching your new version.
+5. Click **Publish release**.
+
+GitHub Actions will then automatically compile the C++ wheels for Windows, Mac, and Linux, and upload them securely to PyPI.

moqua-0.1.5/moqua/optimization.py

@@ -0,0 +1,139 @@
+
+import numpy as np
+from moqua import pricing
+
+def levenberg_marquardt(residual_func, initial_params, args=(), tol=1e-5, max_iter=100, bounds=None):
+    params = np.array(initial_params, dtype=float)
+    n_params = len(params)
+    lam = 1e-3
+    v = 2.0
+    residuals = residual_func(params, *args)
+    current_cost = 0.5 * np.sum(residuals**2)
+    for i in range(max_iter):
+        J = np.zeros((len(residuals), n_params))
+        epsilon = 1e-5
+        for j in range(n_params):
+            p_perturbed = params.copy()
+            p_perturbed[j] += epsilon
+            r_perturbed = residual_func(p_perturbed, *args)
+            J[:, j] = (r_perturbed - residuals) / epsilon
+        JtJ = J.T @ J
+        Jtr = J.T @ residuals
+        while True:
+            H_damped = JtJ + lam * np.eye(n_params)
+            try:
+                delta = -np.linalg.solve(H_damped, Jtr)
+            except np.linalg.LinAlgError:
+                delta = None
+            if delta is not None:
+                new_params = params + delta
+                if bounds:
+                    for k, (low, high) in enumerate(bounds):
+                        new_params[k] = np.clip(new_params[k], low, high)
+                new_residuals = residual_func(new_params, *args)
+                new_cost = 0.5 * np.sum(new_residuals**2)
+                if new_cost < current_cost:
+                    params = new_params
+                    residuals = new_residuals
+                    current_cost = new_cost
+                    lam /= v
+                    break
+                else:
+                    lam *= v
+                    if lam > 1e9: break
+            else:
+                lam *= v
+                if lam > 1e9: break
+        if np.linalg.norm(Jtr) < tol:
+            break
+    return params
+
+def calibrate_heston_lm(strikes, market_prices, S0, T, r):
+    def residuals(params, strikes, market_prices, S0, T, r):
+        v0, kappa, theta, sigma, rho = params
+        model_prices = []
+        for K in strikes:
+            p = pricing.heston_call_price(S0, K, T, r, v0, kappa, theta, sigma, rho)
+            # Relative error
+            model_prices.append(p / market_prices[strikes == K][0])
+        return np.array(model_prices) - 1.0
+    bounds = [
+        (0.01, 1.0), (0.01, 20.0), (0.01, 1.0), (0.01, 5.0), (-0.99, 0.99)
+    ]
+    initial_guess = [0.04, 3.0, 0.04, 0.6, -0.7]
+    optimized_params = levenberg_marquardt(residuals, initial_guess, args=(strikes, market_prices, S0, T, r), bounds=bounds)
+    return optimized_params
+
+def differential_evolution(objective_func, bounds, args=(), pop_size=10, max_iter=100, F=0.5, CR=0.7):
+    bounds = np.array(bounds)
+    min_b = bounds[:, 0]
+    max_b = bounds[:, 1]
+    diff = max_b - min_b
+    dim = len(bounds)
+    population = min_b + np.random.rand(pop_size, dim) * diff
+    fitness = np.array([objective_func(ind, *args) for ind in population])
+    best_idx = np.argmin(fitness)
+    best_vector = population[best_idx].copy()
+    best_cost = fitness[best_idx]
+    for it in range(max_iter):
+        for i in range(pop_size):
+            idxs = [idx for idx in range(pop_size) if idx != i]
+            a, b, c = population[np.random.choice(idxs, 3, replace=False)]
+            mutant = a + F * (b - c)
+            mutant = np.clip(mutant, min_b, max_b)
+            cross_points = np.random.rand(dim) < CR
+            if not np.any(cross_points):
+                cross_points[np.random.randint(0, dim)] = True
+            trial = np.where(cross_points, mutant, population[i])
+            trial_cost = objective_func(trial, *args)
+            if trial_cost < fitness[i]:
+                population[i] = trial
+                fitness[i] = trial_cost
+                if trial_cost < best_cost:
+                    best_cost = trial_cost
+                    best_vector = trial
+    return best_vector
+
+def calibrate_heston_de(strikes, market_prices, S0, T, r):
+    def residuals_sum_sq(params, strikes, market_prices, S0, T, r):
+        v0, kappa, theta, sigma, rho = params
+        sse = 0.0
+        for i, K in enumerate(strikes):
+            model_p = pricing.heston_call_price(S0, K, T, r, v0, kappa, theta, sigma, rho)
+            sse += ((model_p - market_prices[i]) / market_prices[i])**2
+        return sse
+    bounds = [
+        (0.01, 1.0), (0.01, 20.0), (0.01, 1.0), (0.01, 5.0), (-0.99, 0.99)
+    ]
+    optimized_params = differential_evolution(residuals_sum_sq, bounds, args=(strikes, market_prices, S0, T, r), pop_size=15, max_iter=50)
+    return optimized_params
+
+def calibrate_heston_hybrid(strikes, market_prices, S0, T, r):
+    print("  [Hybrid] Step 1: Differential Evolution (Global search)...")
+    def q5_residuals_scalar(params, strikes, market_prices, S0, T, r):
+        v0, kappa, theta, sigma, rho = params
+        sse = 0.0
+        is_T_list = hasattr(T, '__len__')
+        for i, K in enumerate(strikes):
+            t_val = T[i] if is_T_list else T
+            if v0<0 or kappa<0 or theta<0 or sigma<0 or abs(rho)>0.99: return 1e9
+            p = pricing.heston_call_price(S0, K, t_val, r, v0, kappa, theta, sigma, rho)
+            sse += ((p - market_prices[i]) / market_prices[i])**2
+        return sse
+    bounds = [
+        (0.01, 1.0), (0.01, 20.0), (0.01, 1.0), (0.01, 5.0), (-0.99, 0.99)
+    ]
+    de_params = differential_evolution(q5_residuals_scalar, bounds, args=(strikes, market_prices, S0, T, r), pop_size=20, max_iter=40)
+    print(f"  [Hybrid] DE Params: {de_params}")
+    print("  [Hybrid] Step 2: Levenberg-Marquardt (Refinement)...")
+    def q5_residuals_vector(params, strikes, market_prices, S0, T, r):
+        v0, kappa, theta, sigma, rho = params
+        model_prices = []
+        is_T_list = hasattr(T, '__len__')
+        for i, K in enumerate(strikes):
+            t_val = T[i] if is_T_list else T
+            p = pricing.heston_call_price(S0, K, t_val, r, v0, kappa, theta, sigma, rho)
+            model_prices.append(p / market_prices[i])
+        return np.array(model_prices) - 1.0
+    refined_params = levenberg_marquardt(q5_residuals_vector, de_params, args=(strikes, market_prices, S0, T, r), bounds=bounds, max_iter=30)
+    return refined_params

moqua-0.1.5/moqua/outputs.py

@@ -0,0 +1,271 @@
+# -*- coding: utf-8 -*-
+"""
+Generic Output and Visualization Tools for Quantitative Strategies
+"""
+
+import pandas as pd
+import numpy as np
+import logging
+import pickle
+from pathlib import Path
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_pdf import PdfPages
+from matplotlib.dates import DateFormatter
+
+
+# -----------------------------------------------------------------------------
+# LEGACY FUNCTIONS (Kept for compatibility)
+# -----------------------------------------------------------------------------
+
+def create_excel_report(pairs_results: list, filename="pairs_analysis_report.xlsx"):
+    """
+    Crée un rapport Excel avec les résultats de l'analyse.
+    """
+    if not pairs_results:
+        print("Aucun résultat à exporter.")
+        return
+
+    df = pd.DataFrame(pairs_results)
+    
+    # Ordonner les colonnes (si présentes)
+    cols = ['pair', 'score', 'z_score', 'coint_t', 'coint_pvalue', 
+            'half_life', 'hurst', 'kpss_stat', 'kpss_pvalue', 'intercept', 
+            'beta', 'status', 'r_squared']
+    
+    existing_cols = [c for c in cols if c in df.columns]
+    other_cols = [c for c in df.columns if c not in cols]
+    final_cols = existing_cols + other_cols
+    
+    df = df[final_cols]
+
+    try:
+        # Créer le dossier parent si nécessaire
+        Path(filename).parent.mkdir(parents=True, exist_ok=True)
+        
+        with pd.ExcelWriter(filename, engine='openpyxl') as writer:
+            df.to_excel(writer, sheet_name='Analysis Results', index=False)
+            
+            # Formatage conditionnel simple
+            worksheet = writer.sheets['Analysis Results']
+            for idx, col in enumerate(df.columns):
+                max_len = max(df[col].astype(str).map(len).max(), len(col)) + 2
+                worksheet.column_dimensions[chr(65 + idx)].width = min(max_len, 50)
+                
+        print(f"Rapport Excel généré : {filename}")
+        
+    except Exception as e:
+        print(f"Erreur lors de la génération du rapport Excel : {e}")
+
+def create_pdf_report(pairs_results: list, price_data: dict, filename="pairs_analysis_report.pdf"):
+    """
+    Génère un rapport PDF avec les graphiques des meilleures paires.
+    Legacy function: Use PairPlotter class for new implementations.
+    """
+    if not pairs_results:
+        return
+
+    # Convertir en DataFrame si nécessaire pour trier
+    if isinstance(pairs_results, list):
+        df_res = pd.DataFrame(pairs_results)
+    else:
+        df_res = pairs_results
+
+    # Filtrer les paires valides
+    valid_pairs = df_res[df_res['status'] == 'VALID'].copy()
+    
+    # Trier par score décroissant
+    if 'score' in valid_pairs.columns:
+        top_pairs = valid_pairs.sort_values('score', ascending=False).head(20)
+    else:
+        top_pairs = valid_pairs.head(20)
+
+    if top_pairs.empty:
+        print("Aucune paire valide à tracer.")
+        return
+
+    print(f"Génération du PDF ({len(top_pairs)} paires)...")
+
+    try:
+        with PdfPages(filename) as pdf:
+            for _, row in top_pairs.iterrows():
+                try:
+                    pair = row['pair']
+                    assets = pair.split('-')
+                    if len(assets) != 2: continue
+                    
+                    a, b = assets[0], assets[1]
+                    
+                    # Récupérer les données
+                    # Note: price_data structure depend du format passé (dict de df ou autre)
+                    # Implementation simplifiée pour compatibilité
+                    pass 
+
+                except Exception as e:
+                    print(f"Erreur plot {pair}: {e}")
+                    continue
+                    
+        print(f"PDF généré : {filename}")
+
+    except Exception as e:
+        print(f"Erreur globale PDF : {e}")
+
+
+# -----------------------------------------------------------------------------
+# PAIR PLOTTER BASE CLASS (Strategy Visualization)
+# -----------------------------------------------------------------------------
+
+class PairPlotter:
+    """
+    Base class for visualizing trading pairs.
+    Handles generic plotting logic (PDF generation, price normalization, data loading)
+    while allowing strategies to customize the 'spread' or specific chart visualization.
+    """
+    def __init__(self, viz_data_path: str = None):
+        self.viz_data_path = viz_data_path
+        self.equities_df = None
+        self.index_df = None
+        self.results = pd.DataFrame()
+        self.pair_data = {}
+        
+        # Configuration Matplotlib Standard (A4 Landscape / 2:1 Ratio aspect but A4 width)
+        # 11.69 x 5.85 inches (Half of A4 Landscape essentially)
+        self.figsize = (11.69, 5.85)
+        plt.rcParams['font.size'] = 10
+        plt.rcParams['figure.figsize'] = self.figsize
+
+    def load_data(self):
+        """Loads visualization data from PKL"""
+        # Determine path if not provided
+        if not self.viz_data_path:
+            # Try default locations
+            possible_paths = [
+                Path("visualization_data.pkl"),
+                Path(__file__).resolve().parent.parent / "LS EQUITY" / "SELECTION" / "SELECTION MARKET NEUTRAL" / "visualization_data.pkl"
+            ]
+            for p in possible_paths:
+                if p.exists():
+                    self.viz_data_path = p
+                    break
+        
+        if not self.viz_data_path or not Path(self.viz_data_path).exists():
+            logging.error(f"Visualization data not found: {self.viz_data_path}")
+            return False
+
+        try:
+            logging.info(f"Loading visualization data from {self.viz_data_path}...")
+            with open(self.viz_data_path, 'rb') as f:
+                viz_data = pickle.load(f)
+            
+            price_data = viz_data.get('price_data', {})
+            self.equities_df = price_data.get('equities_df')
+            self.index_df = price_data.get('index_df')
+            self.pair_data = viz_data.get('pair_data', {})
+            self.results = viz_data.get('results_summary', pd.DataFrame())
+            
+            # Filter results to match pair_data availability
+            if not self.results.empty and self.pair_data:
+                available = list(self.pair_data.keys())
+                 # Check where pair name is stored
+                if 'pair' in self.results.columns:
+                    self.results = self.results[self.results['pair'].isin(available)].copy()
+                elif 'pair' not in self.results.columns and self.results.index.name == 'pair':
+                     self.results = self.results[self.results.index.isin(available)].copy()
+                     self.results['pair'] = self.results.index
+            
+            logging.info(f"Data Loaded: {len(self.results)} pairs ready.")
+            return True
+        except Exception as e:
+            logging.error(f"Error loading data: {e}")
+            return False
+
+    def plot_normalized_prices(self, ax, pair_name):
+        """Generic plot: Normalized Prices (Asset A vs Asset B)"""
+        if pair_name not in self.pair_data: return
+        
+        # Basic parsing (assumes "AssetA-AssetB" format)
+        try:
+            a, b = pair_name.split("-", 1)
+        except ValueError:
+            ax.text(0.5, 0.5, f"Invalid Pair Name: {pair_name}", ha='center')
+            return
+
+        price_a = self.equities_df[a].dropna() if a in self.equities_df.columns else pd.Series(dtype=float)
+        price_b = self.equities_df[b].dropna() if b in self.equities_df.columns else pd.Series(dtype=float)
+        
+        common = price_a.index.intersection(price_b.index)
+        
+        if len(common) > 10:
+            p_a = price_a.loc[common]
+            p_b = price_b.loc[common]
+            
+            # Rebase to 1.0
+            ax.plot(common, p_a / p_a.iloc[0], label=a, linewidth=0.9)
+            ax.plot(common, p_b / p_b.iloc[0], label=b, linewidth=0.9)
+            
+            ax.set_title(f'Normalized Prices - {pair_name}', fontweight='bold')
+            ax.legend()
+            ax.grid(True, alpha=0.3)
+            ax.xaxis.set_major_formatter(DateFormatter('%y-%m'))
+            ax.set_ylabel('Normalized Price')
+            ax.set_xlabel('Date')
+        else:
+            ax.text(0.5, 0.5, "Insufficient Price Data", ha='center')
+
+    def plot_spread(self, ax, pair_name, **kwargs):
+        """Abstract method: Must be implemented by strategy subclass"""
+        ax.text(0.5, 0.5, "Spread Plot Not Implemented (Base Class)", ha='center')
+
+    def generate_pdf(self, filename="analysis_results.pdf", top_n=10, asset_filter=None):
+        """Orchestrates PDF generation"""
+        if self.results.empty:
+            logging.warning("No results to plot.")
+            return
+
+        # Filter by asset if requested
+        if asset_filter:
+             df_plot = self.results[self.results['pair'].str.contains(asset_filter, na=False)].copy()
+        else:
+             df_plot = self.results.copy()
+
+        # Deduplicate and slice
+        if 'pair' in df_plot.columns:
+            top_pairs = df_plot.drop_duplicates(subset=['pair']).head(top_n)
+        else:
+            top_pairs = df_plot.head(top_n) # Fallback
+        
+        if top_pairs.empty:
+            logging.warning(f"No pairs found for filter: {asset_filter}")
+            return
+
+        logging.info(f"Generating PDF: {filename} ({len(top_pairs)} pairs)...")
+        
+        with PdfPages(filename) as pdf:
+            for i, (_, row) in enumerate(top_pairs.iterrows()):
+                pair_name = row['pair'] if 'pair' in row else row.name
+                
+                # Standard A4 Landscape / 2:1 Ratio Layout
+                fig, axes = plt.subplots(1, 2, figsize=self.figsize)
+                
+                # Plot 1: Standard Normalized Prices
+                self.plot_normalized_prices(axes[0], pair_name)
+                
+                # Plot 2: Strategy Specific Spread
+                self.plot_spread(axes[1], pair_name, row=row)
+                
+                # Title
+                score = row.get('score', 0)
+                z = row.get('current_z', 0)
+                # Handle half-life unit (days or years) display logic if needed upstream
+                hl = row.get('half_life_days', row.get('half_life', 0))
+
+                univ = row.get('universe', '?')
+                title = f"Opportunity {i+1}: {pair_name} ({univ}) - Score: {score:.4f} | Z: {z:.2f} | HL: {hl:.1f}d"
+                fig.suptitle(title, fontsize=12, fontweight='bold', y=0.98)
+                
+                plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+                # USER REQUEST: "que la page soit en fonction du graphique"
+                # bbox_inches='tight' forces the page to wrap the content exactly
+                pdf.savefig(fig, bbox_inches='tight') 
+                plt.close(fig)
+        
+        logging.info("PDF Generation Complete.")