vaquum-limen 2.5.5__tar.gz

vaquum_limen-2.5.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vaquum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vaquum_limen-2.5.5/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: vaquum_limen
+Version: 2.5.5
+Summary: Bitcoin-first research and trading platform.
+Author: Prasenjit Dey, Arun Raguraman, Jatin Thakur, Soujanyaa Boruah, Ng Wei Da
+Author-email: Mikko Kotila <mailme@mikkokotila.com>
+License: MIT
+Project-URL: Homepage, https://vaquum.fi
+Project-URL: Documentation, https://docs.vaquum.fi/limen/
+Project-URL: Repository, https://github.com/vaquum/limen
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.3.1
+Requires-Dist: polars>=1.0.0
+Requires-Dist: scikit-learn>=1.6.1
+Requires-Dist: tqdm>=4.67.0
+Requires-Dist: xgboost
+Requires-Dist: python-dotenv
+Requires-Dist: scipy
+Requires-Dist: statsmodels
+Requires-Dist: tslearn
+Requires-Dist: lightgbm
+Requires-Dist: pyarrow
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: ta-lib
+Requires-Dist: requests
+Provides-Extra: tabpfn
+Requires-Dist: tabpfn>=6; extra == "tabpfn"
+Dynamic: license-file
+
+<div align="center">
+  <br />
+  <a href="https://github.com/Vaquum"><img src="https://github.com/Vaquum/Home/raw/main/assets/Logo.png" alt="Vaquum" width="150" /></a>
+  <br />
+</div>
+<br />
+<div align="center"><strong>Vaquum Limen turns Bitcoin market data into searchable signals, backtested outcomes, and decoder cohorts.</strong></div>
+
+<div align="center">
+  <a href="#limen">Limen</a> •
+  <a href="#what-limen-is-not">What Limen Is Not</a> •
+  <a href="#capabilities">Capabilities</a> •
+  <a href="#first-experiment">First Experiment</a> •
+  <a href="#learn-more">Learn More</a>
+</div>
+<br />
+<div align="center">
+  <a href="https://www.bestpractices.dev/projects/11898"><img src="https://www.bestpractices.dev/projects/11898/badge" alt="OpenSSF Best Practices" /></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/Vaquum/Limen"><img src="https://img.shields.io/ossf-scorecard/github.com/Vaquum/Limen?label=openssf+scorecard&amp;style=flat" alt="OpenSSF Scorecard" /></a>
+</div>
+
+<hr />
+
+<a id="limen"></a>
+
+# Limen — The Research Engine
+
+*Manifest-driven Bitcoin alpha research engine that turns market data into searchable signals, backtested outcomes, and decoder cohorts.*
+
+Limen unifies parameter search across machine learning and rule-based strategies, with built-in analytics that show not just what works, but why it works. It evolves from Talos, the hyperparameter optimization framework for TensorFlow and Keras cited in over 1,000 scientific papers with zero breaking bugs in six years.
+
+## What Limen Is Not
+
+Limen is not:
+
+- a trade execution system
+- a downstream trade decision engine
+- a generic multi-asset research platform
+
+In the wider Vaquum architecture, Origo sits upstream as the data layer. Nexus, Praxis, and Veritas sit downstream for decisioning, execution, and oversight.
+
+## Capabilities
+
+- Manifest-driven experiment pipelines
+- Search across models, rules, features, targets, and hyperparameters
+- Extensive built-in indicator and feature library for Bitcoin research
+- Support for both machine learning and rule-based strategy research
+- Bitcoin-native transforms, scaling, and target construction
+- Leakage-safe train, validation, and test workflows
+- Built-in backtesting, confusion analytics, and parameter diagnostics
+- Decoder cohort construction and regime-diversified model pooling
+- Reproducible runs with checkpointing, resumption, and retraining
+
+## First Experiment
+
+The fastest first success is a small parameter sweep on the bundled BTC/USDT kline dataset with the built-in logistic-regression decoder.
+
+1. Install the package:
+
+```bash
+pip install vaquum_limen
+```
+
+2. Load data and run a first experiment:
+
+```python
+import limen
+
+historical = limen.HistoricalData()
+data = historical.get_spot_klines(kline_size=7200, n_rows=2000)
+
+uel = limen.UniversalExperimentLoop(data=data, sfd=limen.sfd.logreg_binary)
+
+uel.run(
+    experiment_name="logreg-first",
+    n_permutations=25,
+    prep_each_round=True,
+)
+```
+
+3. Inspect the core outputs:
+
+- `uel.experiment_log` for the parameter sweep results
+- `uel.experiment_confusion_metrics` for confusion analytics
+- `uel.experiment_backtest_results` for backtest results
+
+That path is the simplest way to get a real Limen run on your machine without relying on repo-local fixture files. If you want richer run directories, checkpoints, resumability, and stored round artefacts, continue into the UEL documentation below.
+
+## Learn More
+
+- Start with the full docs hub in [docs/README.md](docs/README.md)
+- Define research units in [docs/Single-File-Decoder.md](docs/Single-File-Decoder.md), [docs/Built-In-SFDs.md](docs/Built-In-SFDs.md), and [docs/Experiment-Manifest.md](docs/Experiment-Manifest.md)
+- Run experiments in [docs/Universal-Experiment-Loop.md](docs/Universal-Experiment-Loop.md) and extend the artifact-rich path through [docs/Advanced-Search.md](docs/Advanced-Search.md) and [docs/Reducers-And-Feedback.md](docs/Reducers-And-Feedback.md)
+- Analyze results in [docs/Log.md](docs/Log.md), [docs/Benchmark.md](docs/Benchmark.md), and [docs/Backtest.md](docs/Backtest.md)
+- Understand the model layer in [docs/Reference-Architecture.md](docs/Reference-Architecture.md) and the helper layer in [docs/Utilities.md](docs/Utilities.md)
+- Promote finished runs into reusable outputs with [docs/Trainer.md](docs/Trainer.md) and [docs/Regime-Diversified-Opinion-Pools.md](docs/Regime-Diversified-Opinion-Pools.md)
+- Contribute through [docs/Developer/README.md](docs/Developer/README.md)
+
+## Contributing
+
+The simplest way to start contributing is by [joining an open discussion](https://github.com/Vaquum/Limen/issues?q=is%3Aissue%20state%3Aopen%20label%3Aquestion%2Fdiscussion), contributing to [the docs](https://github.com/Vaquum/Limen/tree/main/docs), or by [picking up an open issue](https://github.com/Vaquum/Limen/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug%20OR%20label%3Aenhancement%20OR%20label%3A%22good%20first%20issue%22%20OR%20label%3A%22help%20wanted%22%20OR%20label%3APriority%20OR%20label%3Aprocess).
+
+Before contributing, start with [docs/Developer/README.md](docs/Developer/README.md).
+
+## Vulnerabilities
+
+Report vulnerabilities privately through [GitHub Security Advisories](https://github.com/Vaquum/Limen/security/advisories/new).
+
+## Citations
+
+If you use Limen for published work, please cite:
+
+Vaquum Limen [Computer software]. (2026). Retrieved from https://github.com/Vaquum/Limen.
+
+## License
+
+[MIT License](https://github.com/Vaquum/Limen/blob/main/LICENSE).

vaquum_limen-2.5.5/README.md

@@ -0,0 +1,117 @@
+<div align="center">
+  <br />
+  <a href="https://github.com/Vaquum"><img src="https://github.com/Vaquum/Home/raw/main/assets/Logo.png" alt="Vaquum" width="150" /></a>
+  <br />
+</div>
+<br />
+<div align="center"><strong>Vaquum Limen turns Bitcoin market data into searchable signals, backtested outcomes, and decoder cohorts.</strong></div>
+
+<div align="center">
+  <a href="#limen">Limen</a> •
+  <a href="#what-limen-is-not">What Limen Is Not</a> •
+  <a href="#capabilities">Capabilities</a> •
+  <a href="#first-experiment">First Experiment</a> •
+  <a href="#learn-more">Learn More</a>
+</div>
+<br />
+<div align="center">
+  <a href="https://www.bestpractices.dev/projects/11898"><img src="https://www.bestpractices.dev/projects/11898/badge" alt="OpenSSF Best Practices" /></a>
+  <a href="https://scorecard.dev/viewer/?uri=github.com/Vaquum/Limen"><img src="https://img.shields.io/ossf-scorecard/github.com/Vaquum/Limen?label=openssf+scorecard&amp;style=flat" alt="OpenSSF Scorecard" /></a>
+</div>
+
+<hr />
+
+<a id="limen"></a>
+
+# Limen — The Research Engine
+
+*Manifest-driven Bitcoin alpha research engine that turns market data into searchable signals, backtested outcomes, and decoder cohorts.*
+
+Limen unifies parameter search across machine learning and rule-based strategies, with built-in analytics that show not just what works, but why it works. It evolves from Talos, the hyperparameter optimization framework for TensorFlow and Keras cited in over 1,000 scientific papers with zero breaking bugs in six years.
+
+## What Limen Is Not
+
+Limen is not:
+
+- a trade execution system
+- a downstream trade decision engine
+- a generic multi-asset research platform
+
+In the wider Vaquum architecture, Origo sits upstream as the data layer. Nexus, Praxis, and Veritas sit downstream for decisioning, execution, and oversight.
+
+## Capabilities
+
+- Manifest-driven experiment pipelines
+- Search across models, rules, features, targets, and hyperparameters
+- Extensive built-in indicator and feature library for Bitcoin research
+- Support for both machine learning and rule-based strategy research
+- Bitcoin-native transforms, scaling, and target construction
+- Leakage-safe train, validation, and test workflows
+- Built-in backtesting, confusion analytics, and parameter diagnostics
+- Decoder cohort construction and regime-diversified model pooling
+- Reproducible runs with checkpointing, resumption, and retraining
+
+## First Experiment
+
+The fastest first success is a small parameter sweep on the bundled BTC/USDT kline dataset with the built-in logistic-regression decoder.
+
+1. Install the package:
+
+```bash
+pip install vaquum_limen
+```
+
+2. Load data and run a first experiment:
+
+```python
+import limen
+
+historical = limen.HistoricalData()
+data = historical.get_spot_klines(kline_size=7200, n_rows=2000)
+
+uel = limen.UniversalExperimentLoop(data=data, sfd=limen.sfd.logreg_binary)
+
+uel.run(
+    experiment_name="logreg-first",
+    n_permutations=25,
+    prep_each_round=True,
+)
+```
+
+3. Inspect the core outputs:
+
+- `uel.experiment_log` for the parameter sweep results
+- `uel.experiment_confusion_metrics` for confusion analytics
+- `uel.experiment_backtest_results` for backtest results
+
+That path is the simplest way to get a real Limen run on your machine without relying on repo-local fixture files. If you want richer run directories, checkpoints, resumability, and stored round artefacts, continue into the UEL documentation below.
+
+## Learn More
+
+- Start with the full docs hub in [docs/README.md](docs/README.md)
+- Define research units in [docs/Single-File-Decoder.md](docs/Single-File-Decoder.md), [docs/Built-In-SFDs.md](docs/Built-In-SFDs.md), and [docs/Experiment-Manifest.md](docs/Experiment-Manifest.md)
+- Run experiments in [docs/Universal-Experiment-Loop.md](docs/Universal-Experiment-Loop.md) and extend the artifact-rich path through [docs/Advanced-Search.md](docs/Advanced-Search.md) and [docs/Reducers-And-Feedback.md](docs/Reducers-And-Feedback.md)
+- Analyze results in [docs/Log.md](docs/Log.md), [docs/Benchmark.md](docs/Benchmark.md), and [docs/Backtest.md](docs/Backtest.md)
+- Understand the model layer in [docs/Reference-Architecture.md](docs/Reference-Architecture.md) and the helper layer in [docs/Utilities.md](docs/Utilities.md)
+- Promote finished runs into reusable outputs with [docs/Trainer.md](docs/Trainer.md) and [docs/Regime-Diversified-Opinion-Pools.md](docs/Regime-Diversified-Opinion-Pools.md)
+- Contribute through [docs/Developer/README.md](docs/Developer/README.md)
+
+## Contributing
+
+The simplest way to start contributing is by [joining an open discussion](https://github.com/Vaquum/Limen/issues?q=is%3Aissue%20state%3Aopen%20label%3Aquestion%2Fdiscussion), contributing to [the docs](https://github.com/Vaquum/Limen/tree/main/docs), or by [picking up an open issue](https://github.com/Vaquum/Limen/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug%20OR%20label%3Aenhancement%20OR%20label%3A%22good%20first%20issue%22%20OR%20label%3A%22help%20wanted%22%20OR%20label%3APriority%20OR%20label%3Aprocess).
+
+Before contributing, start with [docs/Developer/README.md](docs/Developer/README.md).
+
+## Vulnerabilities
+
+Report vulnerabilities privately through [GitHub Security Advisories](https://github.com/Vaquum/Limen/security/advisories/new).
+
+## Citations
+
+If you use Limen for published work, please cite:
+
+Vaquum Limen [Computer software]. (2026). Retrieved from https://github.com/Vaquum/Limen.
+
+## License
+
+[MIT License](https://github.com/Vaquum/Limen/blob/main/LICENSE).

vaquum_limen-2.5.5/limen/__init__.py

@@ -0,0 +1,42 @@
+from limen.data import HistoricalData
+from limen.log.log import Log
+from limen.trading import Account
+from limen.backtest.backtest_sequential import BacktestSequential
+from limen.experiment import Manifest
+from limen.experiment import ReconstructionError
+from limen.experiment import Sensor
+from limen.experiment import Trainer
+from limen.experiment import UniversalExperimentLoop
+from limen.cohort import Cohort
+from limen.cohort import RegimeDiversifiedOpinionPools
+
+from limen import features
+from limen import indicators
+from limen import metrics
+from limen import sfd
+from limen import scalers
+from limen import transforms
+from limen import utils
+from limen import log
+
+__all__ = [
+    'Account',
+    'BacktestSequential',
+    'Cohort',
+    'HistoricalData',
+    'Log',
+    'Manifest',
+    'ReconstructionError',
+    'RegimeDiversifiedOpinionPools',
+    'Sensor',
+    'Trainer',
+    'UniversalExperimentLoop',
+    'features',
+    'indicators',
+    'log',
+    'metrics',
+    'scalers',
+    'sfd',
+    'transforms',
+    'utils'
+]

vaquum_limen-2.5.5/limen/backtest/backtest_sequential.py

@@ -0,0 +1,116 @@
+import math
+from collections.abc import Sequence
+from limen.trading import Account
+
+class BacktestSequential:
+
+    def __init__(self, start_usdt: float = 30000) -> None:
+
+        self.fee_rate = 0.001
+
+        self.account = Account(start_usdt)
+        self.start_usdt = start_usdt
+        self.trades = []
+        self.equity_curve = []
+
+    def run(self,
+            actual: Sequence[int | float],
+            prediction: Sequence[int | float],
+            price_change: Sequence[float],
+            open_prices: Sequence[float],
+            close_prices: Sequence[float]) -> dict:
+
+        if not all(len(arr) == len(actual) for arr in [prediction, price_change, open_prices, close_prices]):
+            raise ValueError('ERROR: Arrays must have same length')
+
+        for i in range(len(actual)):
+            pred = prediction[i]
+            act = actual[i]
+            open_price = open_prices[i]
+            close_price = close_prices[i]
+
+            if open_price <= 0 or close_price <= 0:
+                continue
+
+            current_usdt = self.account.account['total_usdt'][-1]
+
+            if pred == 1 and current_usdt > 1:
+                buy_fee = current_usdt * self.fee_rate
+                usdt_after_buy_fee = current_usdt - buy_fee
+                if usdt_after_buy_fee <= 0:
+                    continue
+                self.account.update_account('buy', usdt_after_buy_fee, open_price)
+                btc_held = self.account.long_position
+                gross_sell_amount = btc_held * close_price
+                sell_fee = gross_sell_amount * self.fee_rate
+                net_sell_amount = gross_sell_amount - sell_fee
+                self.account.update_account('sell', net_sell_amount, close_price)
+                final_usdt = self.account.account['total_usdt'][-1]
+                profit = final_usdt - current_usdt
+                self.trades.append({'type': 'long', 'hit': act == pred, 'pnl': profit, 'volume': usdt_after_buy_fee})
+                self.equity_curve.append(final_usdt)
+
+        return self._calculate_metrics()
+
+    def _calculate_metrics(self) -> dict:
+
+        if not self.trades:
+            return {
+                'PnL': 0,
+                'win_rate': 0,
+                'max_drawdown': 0,
+                'expected_value': 0,
+                'sharpe_ratio': 0,
+                'net_long_volume': 0,
+                'net_short_volume': 0,
+                'net_trade_volume': 0
+            }
+
+        final_usdt = self.account.account['total_usdt'][-1]
+        pnl = final_usdt - self.start_usdt
+
+        wins = sum(1 for t in self.trades if t['pnl'] > 0)
+        total_trades = len(self.trades)
+        win_rate = wins / total_trades if total_trades > 0 else 0
+
+        max_drawdown = 0
+        if self.equity_curve:
+            peak = self.equity_curve[0]
+            for equity in self.equity_curve:
+                peak = max(peak, equity)
+                drawdown = (peak - equity) / peak
+                max_drawdown = max(max_drawdown, drawdown)
+
+        expected_value = sum(t['pnl'] for t in self.trades) / total_trades if total_trades > 0 else 0
+
+        net_long_volume = sum(t['volume'] for t in self.trades if t['type'] == 'long')
+        net_short_volume = sum(t['volume'] for t in self.trades if t['type'] == 'short')
+        net_trade_volume = net_long_volume + net_short_volume
+
+        returns = []
+        if len(self.equity_curve) > 1:
+            prev_equity = self.start_usdt
+            for equity in self.equity_curve:
+                if prev_equity != 0:
+                    returns.append((equity - prev_equity) / prev_equity)
+                prev_equity = equity
+
+        if len(returns) > 1:
+            mean_return = sum(returns) / len(returns)
+            variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)
+            std_return = math.sqrt(variance)
+            sharpe_ratio = mean_return / std_return if std_return != 0 else 0
+        else:
+            sharpe_ratio = 0
+
+        # NOTE: These must all be rounded to 2 decimal places.
+        return {
+            'PnL': round(pnl, 2),
+            'win_rate': round(win_rate, 2),
+            'max_drawdown': round(max_drawdown, 2),
+            'expected_value': round(expected_value, 2),
+            'sharpe_ratio': round(sharpe_ratio, 2),
+            'net_long_volume': round(net_long_volume, 2),
+            'net_short_volume': round(net_short_volume, 2),
+            'net_trade_volume': round(net_trade_volume, 2)
+        }

vaquum_limen-2.5.5/limen/backtest/backtest_snapshot.py

@@ -0,0 +1,181 @@
+import numpy as np
+import pandas as pd
+
+PRICE_CHANGE_RTOL = 1e-09
+PRICE_CHANGE_ATOL = 1e-12
+
+def backtest_snapshot(df: pd.DataFrame,
+                     *,
+                     pred_col: str = 'predictions',
+                     open_col: str = 'open',
+                     close_col: str = 'close',
+                     price_change_col: str = 'price_change',
+                     execution_lag_bars: int = 1,
+                     fee_bps: float = 5.0,
+                     slip_bps: float = 5.0) -> pd.DataFrame:
+
+    '''
+    Long-only, HOLD-WHILE-1 evaluation using pre-aligned intrabar returns.
+    All percentage fields are in % units (not fractions). Sharpe is per bar (unitless).
+
+    Takes in output of log.permutation_prediction_performance and returns backtest results.
+
+    Logic
+    - Predictions are shifted forward by `execution_lag_bars` onto the execution bar sequence.
+    - Position pos = 1 wherever the lagged predictions==1 on a tradable execution row.
+    - Price columns must be numeric; missing price rows are treated as non-tradable gaps.
+    - Entry bar gross return: r_entry = price_change / open  (≈ close/open - 1).
+    - Continuation bar gross return: r_cont = close_t / close_{t-1} - 1  (holding across bars).
+    - Fee/slippage costs are applied multiplicatively on entry and exit fills.
+    - Trade metrics are computed from compounded consecutive 1-run returns.
+    - Equity compounds over R_net; drawdown is computed from net equity.
+
+    Returns a one-row DataFrame with columns (in order):
+      [
+        'trade_win_rate_pct',
+        'trade_expectancy_pct',
+        'max_drawdown_pct',
+        'total_return_gross_pct',
+        'total_return_net_pct',
+        'trade_return_mean_win_pct',
+        'trade_return_mean_loss_pct',
+        'mean_kelly_pct',
+        'bars_total',
+        'sharpe_per_bar',
+        'bars_in_market_pct',
+        'trades_count',
+        'cost_round_trip_bps',
+      ]
+    '''
+
+    df = df.copy()
+
+    if df.empty:
+        raise ValueError('backtest_snapshot requires at least one row')
+
+    if execution_lag_bars < 0:
+        raise ValueError('execution_lag_bars must be >= 0')
+
+    try:
+        pred = pd.to_numeric(df[pred_col], errors='raise')
+    except (TypeError, ValueError) as exc:
+        raise ValueError('predictions must contain only 0 or 1') from exc
+
+    if pred.isna().any() or (~pred.isin([0, 1])).any():
+        raise ValueError('predictions must contain only 0 or 1')
+
+    pred = pred.astype(int)
+    try:
+        open_px = pd.to_numeric(df[open_col], errors='raise')
+        close_px = pd.to_numeric(df[close_col], errors='raise')
+        dpx = pd.to_numeric(df[price_change_col], errors='raise')
+    except (TypeError, ValueError) as exc:
+        raise ValueError('open, close, and price_change must be numeric') from exc
+
+    price_check_mask = open_px.notna() & close_px.notna() & dpx.notna()
+    expected_dpx = close_px - open_px
+
+    if price_check_mask.any() and not np.isclose(
+        dpx[price_check_mask],
+        expected_dpx[price_check_mask],
+        rtol=PRICE_CHANGE_RTOL,
+        atol=PRICE_CHANGE_ATOL,
+    ).all():
+        raise ValueError('price_change must equal close - open')
+
+    tradable = open_px.notna() & close_px.notna() & dpx.notna() & (open_px != 0)
+    execution_rows = pd.Series(False, index=df.index)
+    if execution_lag_bars < len(df):
+        execution_rows.iloc[execution_lag_bars:] = True
+
+    pred = pred.shift(execution_lag_bars, fill_value=0)
+    eval_mask = execution_rows & tradable
+    pos = (pred == 1) & eval_mask
+
+    bars_total = int(eval_mask.sum())
+    bars_in_market_pct = float((pos.sum() / bars_total) * 100.0) if bars_total else np.nan
+
+    entry_mask = pos & (~pos.shift(1, fill_value=False))
+    cont_mask  = pos & ( pos.shift(1, fill_value=False))
+
+    trades_count = int(entry_mask.sum())
+
+    r_entry = dpx / open_px
+    r_cont  = (close_px / close_px.shift(1)) - 1.0
+
+    R_gross = np.where(entry_mask, r_entry, 0.0) + np.where(cont_mask, r_cont, 0.0)
+    R_gross = pd.Series(R_gross, index=df.index).fillna(0.0)
+
+    fee = fee_bps / 10_000.0
+    slip = slip_bps / 10_000.0
+    entry_mult = (1.0 - fee) / (1.0 + slip)
+    exit_mult = (1.0 - fee) * (1.0 - slip)
+
+    exit_mask = pos & (~pos.shift(-1, fill_value=False))
+    cost_mult = pd.Series(1.0, index=df.index)
+    cost_mult.loc[entry_mask] *= entry_mult
+    cost_mult.loc[exit_mask] *= exit_mult
+
+    R_net = (((1.0 + R_gross) * cost_mult) - 1.0).fillna(0.0)
+    eq_gross = (1.0 + R_gross).cumprod()
+    eq_net = (1.0 + R_net).cumprod()
+
+    peak = eq_net.cummax().clip(lower=1.0)
+    max_drawdown_pct = float((eq_net / peak - 1.0).min() * 100.0)
+
+    total_return_gross_pct = float((eq_gross.iloc[-1] - 1.0) * 100.0)
+    total_return_net_pct = float((eq_net.iloc[-1]   - 1.0) * 100.0)
+
+    run_ids = entry_mask.cumsum()
+    trade_returns = (
+        (1.0 + R_net[pos]).groupby(run_ids[pos]).prod() - 1.0
+    ) if entry_mask.any() else pd.Series(dtype=float)
+
+    if trade_returns.size:
+        wins = trade_returns[trade_returns > 0]
+        losses = trade_returns[trade_returns < 0]
+        trade_win_rate_pct = float((wins.size / trade_returns.size) * 100.0)
+        trade_expectancy_pct = float(trade_returns.mean() * 100.0)
+        trade_return_mean_win_pct = float(wins.mean() * 100.0) if wins.size else np.nan
+        trade_return_mean_loss_pct = float(losses.mean() * 100.0) if losses.size else np.nan
+    else:
+        trade_win_rate_pct = trade_expectancy_pct = np.nan
+        trade_return_mean_win_pct = trade_return_mean_loss_pct = np.nan
+
+    kelly_returns = trade_returns
+
+    kelly_wins = kelly_returns[kelly_returns > 0]
+    kelly_losses = kelly_returns[kelly_returns < 0]
+    if kelly_wins.size and kelly_losses.size:
+        win_rate = float(kelly_wins.size / kelly_returns.size)
+        loss_rate = float(kelly_losses.size / kelly_returns.size)
+        avg_win = float(kelly_wins.mean())
+        avg_loss = abs(float(kelly_losses.mean()))
+        payout_ratio = avg_win / avg_loss if avg_loss > 0 else np.nan
+        mean_kelly_pct = float((win_rate - (loss_rate / payout_ratio)) * 100.0) if payout_ratio > 0 else np.nan
+    else:
+        mean_kelly_pct = np.nan
+
+    eval_returns = R_net[eval_mask]
+    mu = float(eval_returns.mean()) if eval_returns.size else np.nan
+    sd = float(eval_returns.std(ddof=1)) if eval_returns.size > 1 else np.nan
+
+    sharpe_per_bar = float(mu / sd) if sd > 0 else np.nan
+
+    data = pd.DataFrame.from_records([{
+        'trade_win_rate_pct': round(trade_win_rate_pct, 1),
+        'trade_expectancy_pct': round(trade_expectancy_pct, 3),
+        'max_drawdown_pct': round(max_drawdown_pct, 1),
+        'total_return_gross_pct': round(total_return_gross_pct, 1),
+        'total_return_net_pct': round(total_return_net_pct, 1),
+        'trade_return_mean_win_pct': round(trade_return_mean_win_pct, 1),
+        'trade_return_mean_loss_pct': round(trade_return_mean_loss_pct, 1),
+        'mean_kelly_pct': round(mean_kelly_pct, 3),
+        'bars_total': int(bars_total),
+        'sharpe_per_bar': round(sharpe_per_bar, 2),
+        'bars_in_market_pct': round(bars_in_market_pct, 1),
+        'trades_count': int(trades_count),
+        'cost_round_trip_bps': round((1.0 - (entry_mult * exit_mult)) * 10_000),
+    }])
+
+    return data

vaquum_limen-2.5.5/limen/cohort/__init__.py

@@ -0,0 +1,7 @@
+from limen.cohort.cohort import Cohort
+from limen.cohort.regime_pools import RegimeDiversifiedOpinionPools
+
+__all__ = [
+    'Cohort',
+    'RegimeDiversifiedOpinionPools',
+]