portlab 0.1.0__tar.gz

portlab-0.1.0/CITATION.cff

@@ -0,0 +1,11 @@
+cff-version: 1.2.0
+message: "If you use portlab in research, please cite it as below."
+title: "portlab: Portfolio risk and optimization library"
+version: 0.1.0
+date-released: 2026-10-12
+license: MIT
+url: "https://github.com/Realosunboy6/portlab"
+authors:
+  - family-names: "Oyeyinka"
+    given-names: "Ibrahim"
+    affiliation: "Northern Illinois University"

portlab-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ibrahim Oyeyinka
+
+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.

portlab-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE README.md VALIDATION.md CITATION.cff
+recursive-include tests *.py

portlab-0.1.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: portlab
+Version: 0.1.0
+Summary: Portfolio risk and optimization library — VaR/ES estimation, VaR backtesting, tail diagnostics, and portfolio optimization with a documented validation record.
+Author: Ibrahim Oyeyinka
+License: MIT
+Project-URL: Homepage, https://github.com/Realosunboy6/portlab
+Keywords: portfolio,risk,var,backtesting,optimization,finance
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-learn>=1.3
+Provides-Extra: opt
+Requires-Dist: cvxpy>=1.4; extra == "opt"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: arch; extra == "test"
+Dynamic: license-file
+
+# portlab
+
+A portfolio risk and optimization library for Python, built around one
+principle: **a risk number you cannot backtest is an opinion.** Every
+estimator here is cross-checked against an independent implementation
+and ships with the tests that pin its conventions down — see
+[VALIDATION.md](VALIDATION.md) for the verification record, including
+the defects that process found and fixed.
+
+## What's inside
+
+| Area | Modules | Highlights |
+|---|---|---|
+| Metrics | `portlab.metrics`, `portlab.returns` | CAGR, vol, Sharpe/Sortino/Calmar, drawdowns, rolling stats |
+| VaR / ES | `portlab.risk.var` | Historical, parametric (normal / Student-t / Cornish–Fisher), EWMA, GARCH(1,1)-filtered VaR and Expected Shortfall, with explicit mean conventions (`mean="zero" \| "constant"`) |
+| VaR backtesting | `portlab.risk.backtest` | Exception series with a nullable-boolean contract (unscored days are `<NA>`, never silently passed), Kupiec POF, Christoffersen independence (gap-aware: transitions never join across data holes), joint conditional-coverage test, Basel traffic light |
+| Tail diagnostics | `portlab.risk.tail` | Jarque–Bera, Hill tail index, GPD extreme VaR/TVaR |
+| Regime | `portlab.risk.regime` | HMM-style regime detection, EWMA vol, regime-conditional VaR |
+| Optimization | `portlab.optimize` | Max-Sharpe / GMV / target-return frontiers, min-CVaR and min-CDaR (LP), Black–Litterman, HRP, risk parity, resampled efficiency, robust (box-uncertainty) weights, constraint attribution |
+| Covariance | `portlab.covariance` | Sample, Ledoit–Wolf shrinkage, semicovariance |
+| Backtesting | `portlab.backtest` | Portfolio backtests with rebalancing, rolling backtests, historical-episode stress |
+| Attribution | `portlab.attribution` | Brinson allocation/selection/interaction |
+
+## Conventions (read this before trusting a number)
+
+- Inputs are **simple returns** (positive = gain). VaR/ES are reported
+  as **positive numbers = losses**. An exception is `returns < -VaR`.
+- **`alpha` means two things, by module family** — in `portlab.risk.*`
+  it is the *tail probability* (`0.05` = 95% VaR); in
+  `portlab.metrics.*` and the CVaR optimizer it is the *confidence
+  level* (`0.95`). Every docstring states which.
+- Rolling estimators use **forecast alignment**: the value stamped at
+  day *t* is built only from data strictly before *t*. Backtests score
+  exactly the stamped days — no look-ahead, no warmup padding.
+- `exceptions()` returns a nullable-boolean Series. Days that cannot
+  be scored (VaR warmup, missing returns, gaps) are `<NA>`; Kupiec
+  counts only scored days and Christoffersen counts only transitions
+  between genuinely adjacent scored days.
+
+## Install
+
+```bash
+pip install git+https://github.com/Realosunboy6/portlab.git
+```
+
+Core dependencies: numpy, pandas, scipy, scikit-learn. The CVaR/CDaR
+LP solvers use scipy; optional solver backends (cvxpy, OSQP, Gurobi)
+are imported lazily when requested.
+
+## Quick start
+
+```python
+import pandas as pd
+from portlab.risk import var, backtest
+
+rets = pd.Series(...)                      # daily simple returns
+v = var.historical_var(rets, alpha=0.05, window=250)
+exc = backtest.exceptions(rets, v)         # nullable boolean Series
+print(backtest.kupiec_pof(exc.dropna().astype(bool), alpha=0.05))
+print(backtest.christoffersen_ind(exc))    # gap-aware; do not dropna
+```
+
+## Scope
+
+This is the public core of a larger private toolkit. Not included:
+live portfolio monitoring, broker integrations, tax-lot optimization,
+and forecasting/indicator tooling. The algorithms here are standard
+textbook methods (Kupiec 1995; Christoffersen 1998; Rockafellar &
+Uryasev 2000; Black & Litterman 1992) — the contribution is the
+implementation discipline and the validation suite.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Author
+
+Ibrahim Oyeyinka — PhD candidate, Industrial & Systems Engineering,
+Northern Illinois University.

portlab-0.1.0/README.md

@@ -0,0 +1,79 @@
+# portlab
+
+A portfolio risk and optimization library for Python, built around one
+principle: **a risk number you cannot backtest is an opinion.** Every
+estimator here is cross-checked against an independent implementation
+and ships with the tests that pin its conventions down — see
+[VALIDATION.md](VALIDATION.md) for the verification record, including
+the defects that process found and fixed.
+
+## What's inside
+
+| Area | Modules | Highlights |
+|---|---|---|
+| Metrics | `portlab.metrics`, `portlab.returns` | CAGR, vol, Sharpe/Sortino/Calmar, drawdowns, rolling stats |
+| VaR / ES | `portlab.risk.var` | Historical, parametric (normal / Student-t / Cornish–Fisher), EWMA, GARCH(1,1)-filtered VaR and Expected Shortfall, with explicit mean conventions (`mean="zero" \| "constant"`) |
+| VaR backtesting | `portlab.risk.backtest` | Exception series with a nullable-boolean contract (unscored days are `<NA>`, never silently passed), Kupiec POF, Christoffersen independence (gap-aware: transitions never join across data holes), joint conditional-coverage test, Basel traffic light |
+| Tail diagnostics | `portlab.risk.tail` | Jarque–Bera, Hill tail index, GPD extreme VaR/TVaR |
+| Regime | `portlab.risk.regime` | HMM-style regime detection, EWMA vol, regime-conditional VaR |
+| Optimization | `portlab.optimize` | Max-Sharpe / GMV / target-return frontiers, min-CVaR and min-CDaR (LP), Black–Litterman, HRP, risk parity, resampled efficiency, robust (box-uncertainty) weights, constraint attribution |
+| Covariance | `portlab.covariance` | Sample, Ledoit–Wolf shrinkage, semicovariance |
+| Backtesting | `portlab.backtest` | Portfolio backtests with rebalancing, rolling backtests, historical-episode stress |
+| Attribution | `portlab.attribution` | Brinson allocation/selection/interaction |
+
+## Conventions (read this before trusting a number)
+
+- Inputs are **simple returns** (positive = gain). VaR/ES are reported
+  as **positive numbers = losses**. An exception is `returns < -VaR`.
+- **`alpha` means two things, by module family** — in `portlab.risk.*`
+  it is the *tail probability* (`0.05` = 95% VaR); in
+  `portlab.metrics.*` and the CVaR optimizer it is the *confidence
+  level* (`0.95`). Every docstring states which.
+- Rolling estimators use **forecast alignment**: the value stamped at
+  day *t* is built only from data strictly before *t*. Backtests score
+  exactly the stamped days — no look-ahead, no warmup padding.
+- `exceptions()` returns a nullable-boolean Series. Days that cannot
+  be scored (VaR warmup, missing returns, gaps) are `<NA>`; Kupiec
+  counts only scored days and Christoffersen counts only transitions
+  between genuinely adjacent scored days.
+
+## Install
+
+```bash
+pip install git+https://github.com/Realosunboy6/portlab.git
+```
+
+Core dependencies: numpy, pandas, scipy, scikit-learn. The CVaR/CDaR
+LP solvers use scipy; optional solver backends (cvxpy, OSQP, Gurobi)
+are imported lazily when requested.
+
+## Quick start
+
+```python
+import pandas as pd
+from portlab.risk import var, backtest
+
+rets = pd.Series(...)                      # daily simple returns
+v = var.historical_var(rets, alpha=0.05, window=250)
+exc = backtest.exceptions(rets, v)         # nullable boolean Series
+print(backtest.kupiec_pof(exc.dropna().astype(bool), alpha=0.05))
+print(backtest.christoffersen_ind(exc))    # gap-aware; do not dropna
+```
+
+## Scope
+
+This is the public core of a larger private toolkit. Not included:
+live portfolio monitoring, broker integrations, tax-lot optimization,
+and forecasting/indicator tooling. The algorithms here are standard
+textbook methods (Kupiec 1995; Christoffersen 1998; Rockafellar &
+Uryasev 2000; Black & Litterman 1992) — the contribution is the
+implementation discipline and the validation suite.
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## Author
+
+Ibrahim Oyeyinka — PhD candidate, Industrial & Systems Engineering,
+Northern Illinois University.

portlab-0.1.0/VALIDATION.md

@@ -0,0 +1,118 @@
+# Validation record
+
+How the numbers in this library were checked, what the checking found,
+and what remains known-but-unfixed. All results below are from an
+audit run in October 2026 on real market data (12 tickers, 1,954
+trading days, 2019-01-02 → 2026-10-09), followed by five rounds of
+independent adversarial verification of the VaR backtest stack.
+
+## Method
+
+- **Reference implementations:** PyPortfolioOpt and Riskfolio-Lib
+  (optimization, CVaR), `arch` (GARCH), statsmodels (ARIMA, factor
+  regressions), scikit-learn (Ledoit–Wolf), hmmlearn (regimes).
+- **Independent reimplementation:** the backtest statistics were
+  re-derived from the primary sources (Kupiec 1995; Christoffersen
+  1998) and compared numerically, including an exhaustive sweep and
+  randomized differential testing (below).
+- **Tests in this repo are synthetic by design** (seeded, no network).
+  The real-data anchors in this document are the regression targets
+  the synthetic suite's conventions were validated against.
+
+## Defects found by verification — and fixed
+
+1. **Kupiec warmup padding.** Exception counting once treated
+   NaN-warmup days (before the first VaR exists) as non-exceptions,
+   inflating *n* and biasing the test toward rejection: SPY LR 2.104
+   instead of 0.018. Measured exactly, the false-rejection rate at a
+   nominal 5% level was **26.9% padded vs 5.2% fixed**.
+2. **One-observation look-ahead in rolling VaR.** The rolling helper
+   stamped each window's VaR on the window's last day, putting day
+   *t*'s own return inside its estimation window. Rolling estimators
+   now stamp forecasts: the value at *t* uses only data before *t*.
+3. **Wrong restricted MLE in Christoffersen independence.** The
+   restricted π was computed as the exception rate over days instead
+   of over transition pairs, (n01 + n11) / total_pairs. On SPY this
+   moved LR_ind from 10.589804 to the correct **10.589773** — small
+   there, wrong in general.
+4. **Silent passes on empty input.** Kupiec/Christoffersen once
+   returned LR = 0, p = 1.0 ("perfect pass") for a backtest with zero
+   scored days. They now raise (Kupiec) or return NaN with an
+   explanatory note (independence/joint, when exceptions exist but
+   their transitions are unidentified).
+5. **Transitions joined across data holes.** Christoffersen counting
+   treated scored days separated by unscored gaps as adjacent. The
+   exception series is now nullable-boolean end-to-end; transitions
+   are counted only between genuinely adjacent scored pairs.
+
+## Differential-testing evidence
+
+- **Exhaustive sweep:** all 29,523 sequences over {0, 1, NA} of length
+  ≤ 9 were run through both this implementation and an independent
+  one: **0 mismatches** in transition counts or in the
+  defined/undefined classification; maximum LR difference 1.6e-11.
+  The undefined-independence condition removes exactly the 3,008
+  zero-information sequences (all had LR exactly 0 under the old
+  formula).
+- **Randomized check:** the pair-based restricted MLE matches
+  independent numerical maximization of the restricted likelihood to
+  9.1e-10 over 2,000 gapped random series.
+- **Edge values:** Kupiec LR at n = 100: x = 0 → 10.2587;
+  x = 100 → 599.1465 (reference values, matched to 4 dp).
+
+## Real-data anchors (SPY, rolling-250 historical VaR, α = 0.05)
+
+| Quantity | Value |
+|---|---|
+| Scored days | 1,703 |
+| Exceptions | 86 |
+| Kupiec LR (p) | 0.0089 (passes) |
+| Christoffersen counts (n00, n01, n10, n11) | 1542, 74, 74, 12 |
+| Independence LR (p) | 10.589773 (0.00114 — **fails**) |
+| Joint LR, df 2 | 10.5987 |
+
+The failure is reported, not tuned away: SPY's exceptions cluster in
+Feb–Apr 2020, so the model passes coverage and fails independence.
+"Passes the backtest" claims for this configuration should cite
+conditional coverage, not Kupiec alone.
+
+## Parity results (audit)
+
+- Max-Sharpe weights vs PyPortfolioOpt: agreement to 5.7e-5.
+- GARCH(1,1) one-step σ forecasts vs `arch` (zero-mean, variance-
+  targeted): within the test tolerance across the audit set; a
+  residual VaR gap vs `arch`'s constant-mean default decomposed as
+  ≈79% the mean term in the reference VaR, ≈15% a one-day dating
+  offset in the comparison harness, ≈6% fit-mean specification,
+  ≈0% variance targeting/initialization. Same-window estimators
+  differ by 0.0002 pp — no estimation defect. This is why
+  `garch_var` and `parametric_var` now expose an explicit
+  `mean="zero" | "constant"` argument instead of disagreeing silently.
+
+## Known limitations
+
+- **GARCH with normal innovations under-covers.** On SPY (rolling
+  250-day windows, 1,703 forecasts), exception rates were ≈6.0%
+  (zero-mean) and ≈6.4% (mean-relative) against a 5% target. Prefer
+  `dist="t"`.
+- **250-day historical VaR is slow to adapt** — see the independence
+  failure above; it is a property of the estimator, surfaced by the
+  backtest rather than hidden by it.
+- Public tests use seeded synthetic data. Figures quoted here come
+  from the October 2026 real-data audit; the harness is reproducible
+  from the anchors and conventions documented above.
+
+## Extraction notes (what is not in this repo, and why)
+
+This package is a curated snapshot of a larger private toolkit,
+published with fresh history under MIT. Held back, with their tests:
+live monitoring (`risk.monitor`, `risk.rebalance` — the daily watcher
+over a real portfolio), tax-lot optimization, multi-period
+optimization (`mpo`), factor/indicator/forecast tooling, tear-sheet
+reporting (`report`), and market data access. Two tests are skipped
+in this repo because they exercise held-back modules (`mpo`,
+`report`); the skips and their reasons are declared in
+`tests/conftest.py`, and the
+VaR/backtest tests were extracted verbatim from the private suite's
+risk test file (the monitor/rebalance tests stayed private with
+their modules).

portlab-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "portlab"
+version = "0.1.0"
+description = "Portfolio risk and optimization library — VaR/ES estimation, VaR backtesting, tail diagnostics, and portfolio optimization with a documented validation record."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Ibrahim Oyeyinka" }]
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "scipy>=1.10",
+    "scikit-learn>=1.3",
+]
+keywords = ["portfolio", "risk", "var", "backtesting", "optimization", "finance"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+
+[project.optional-dependencies]
+opt = ["cvxpy>=1.4"]
+test = ["pytest>=7", "arch"]
+
+[project.urls]
+Homepage = "https://github.com/Realosunboy6/portlab"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

portlab-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

portlab-0.1.0/src/portlab/__init__.py

@@ -0,0 +1,24 @@
+"""portlab — portfolio risk and optimization library.
+
+Public core: performance/risk metrics, VaR/ES estimation with VaR
+backtesting (Kupiec, Christoffersen), tail diagnostics, regime
+detection, portfolio optimization (mean-variance, CVaR, Black-
+Litterman, HRP, risk parity, robust), portfolio backtesting, and
+Brinson attribution. See VALIDATION.md for the verification record.
+
+Conventions: inputs are *simple returns* (positive = gain); VaR/ES
+are reported as *positive numbers = losses*. In ``portlab.risk``,
+``alpha`` is the tail probability (0.05 = 95% VaR); in
+``portlab.metrics`` and the CVaR optimizer, ``alpha`` is the
+confidence level (0.95). Each module's docstring states which.
+"""
+
+__version__ = "0.1.0"
+
+from . import (attribution, backtest, covariance, metrics, optimize,
+               rebalance, returns, risk)
+
+__all__ = [
+    "attribution", "backtest", "covariance", "metrics", "optimize",
+    "rebalance", "returns", "risk", "__version__",
+]

portlab-0.1.0/src/portlab/attribution.py

@@ -0,0 +1,111 @@
+"""Performance attribution: Brinson-Hood-Beebower (1986).
+
+Decomposes a portfolio's excess return over a benchmark into *why* it
+happened — allocation bets vs. stock selection — per segment (sector,
+asset class, region, ...). For segment *i* with portfolio weight ``w_p``,
+benchmark weight ``w_b``, portfolio return ``r_p`` and benchmark return
+``r_b``::
+
+    allocation_i  = (w_p,i - w_b,i) * r_b,i
+    selection_i   = w_b,i * (r_p,i - r_b,i)
+    interaction_i = (w_p,i - w_b,i) * (r_p,i - r_b,i)
+
+The identity ``sum(allocation + selection + interaction) == R_p - R_b`` holds
+algebraically whenever both weight vectors sum to 1; :func:`brinson` checks
+it and raises if it fails to close (a non-closing identity means an input
+bug, never a rounding choice).
+
+``method="fachler"`` switches allocation to the Brinson-Fachler variant,
+``(w_p,i - w_b,i) * (r_b,i - R_b)``, which scores an overweight only when the
+segment beat the overall benchmark. The identity is unaffected.
+
+Reference: Brinson, Hood & Beebower (1986), "Determinants of Portfolio
+Performance," *Financial Analysts Journal* 42(4), 39-44.
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+__all__ = ["brinson"]
+
+_METHODS = ("bhb", "fachler")
+_IDENTITY_TOL = 1e-9
+
+
+def _as_frame(segments) -> pd.DataFrame:
+    if isinstance(segments, pd.DataFrame):
+        df = segments.copy()
+    else:
+        df = pd.DataFrame(list(segments))
+    need = {"segment", "w_p", "w_b", "r_p", "r_b"}
+    missing = need - set(df.columns)
+    if missing:
+        raise ValueError(f"segments need columns {sorted(need)}; missing {sorted(missing)}")
+    return df
+
+
+def brinson(segments, method: str = "bhb") -> dict:
+    """Single-period Brinson attribution.
+
+    ``segments``: DataFrame (or list of dicts) with columns
+    segment/w_p/w_b/r_p/r_b. Weights must each sum to 1 (within 1e-8);
+    all values must be finite.
+
+    Returns dict with ``table`` (per-segment allocation/selection/
+    interaction/total), ``portfolio_return``, ``benchmark_return``,
+    ``excess_return``, and the three effect totals.
+    """
+    method = str(method).lower()
+    if method not in _METHODS:
+        raise ValueError(f"method must be one of {_METHODS}, got {method!r}")
+    df = _as_frame(segments)
+    if df.empty:
+        raise ValueError("brinson() needs at least one segment")
+    for col in ("w_p", "w_b", "r_p", "r_b"):
+        vals = pd.to_numeric(df[col], errors="raise").to_numpy(dtype=float)
+        if not all(pd.notna(vals)) or not all(abs(v) != float("inf") for v in vals):
+            raise ValueError(f"column {col!r} must be finite")
+        df[col] = vals
+    for col, name in (("w_p", "portfolio"), ("w_b", "benchmark")):
+        s = float(df[col].sum())
+        if abs(s - 1.0) > 1e-8:
+            raise ValueError(f"{name} weights sum to {s}, not 1")
+
+    w_p = df["w_p"].to_numpy()
+    w_b = df["w_b"].to_numpy()
+    r_p = df["r_p"].to_numpy()
+    r_b = df["r_b"].to_numpy()
+
+    r_p_total = float((w_p * r_p).sum())
+    r_b_total = float((w_b * r_b).sum())
+    excess = r_p_total - r_b_total
+
+    active_w = w_p - w_b
+    active_r = r_p - r_b
+    if method == "fachler":
+        allocation = active_w * (r_b - r_b_total)
+    else:
+        allocation = active_w * r_b
+    selection = w_b * active_r
+    interaction = active_w * active_r
+
+    a, s, i = float(allocation.sum()), float(selection.sum()), float(interaction.sum())
+    if abs((a + s + i) - excess) > _IDENTITY_TOL:
+        raise ValueError(
+            f"attribution identity failed to close: {a + s + i} != {excess} "
+            "(check the weight/return inputs)")
+
+    table = pd.DataFrame({
+        "segment": df["segment"].astype(str).to_numpy(),
+        "allocation": allocation,
+        "selection": selection,
+        "interaction": interaction,
+    })
+    table["total"] = table[["allocation", "selection", "interaction"]].sum(axis=1)
+    return {"table": table.set_index("segment"),
+            "portfolio_return": r_p_total,
+            "benchmark_return": r_b_total,
+            "excess_return": excess,
+            "allocation": a, "selection": s, "interaction": i,
+            "method": method}

portlab-0.1.0/src/portlab/backtest/__init__.py

@@ -0,0 +1,11 @@
+from .portfolio import (BacktestResult, backtest_dynamic,
+                        backtest_portfolio, compare_portfolios, glide_path)
+from .rolling import RollingBacktest, equal_weight
+from .stress import (HISTORICAL_EPISODES, episode_returns, shock_scenario,
+                     worst_windows)
+
+__all__ = [
+    "BacktestResult", "backtest_dynamic", "backtest_portfolio", "compare_portfolios", "glide_path",
+    "RollingBacktest", "equal_weight", "HISTORICAL_EPISODES",
+    "episode_returns", "shock_scenario", "worst_windows",
+]