Install it, run it on your own data, decide for yourself.

Part one · The operating system

Install

Two runtime dependencies, numpy and scipy, both already present in a research environment. Importing the package makes no network call and needs no account.

pip install alphaengine

# factor decomposition and cointegration need statsmodels
pip install 'alphaengine[factors]'

Your first sweep

The library does not backtest anything. It runs your backtest once per combination in a grid, then measures the result against the size of the search that produced it.

from alphaengine import sweep

r = sweep(
    my_backtest,                                    # YOUR function
    {"fast": [5, 10, 20], "slow": [50, 100, 200]},  # the search
    data=prices,                                    # passed through untouched
)

r.n_trials
# 9

That number is why the API is shaped this way. The correction that makes a Sharpe ratio honest needs to know how many variants you tested. Ask a person for it and you get the number that flatters them — not from dishonesty, but because nobody counts what they threw away. Running the grid makes the count len(grid), so the question never has to be asked.

Reading the surface

Before any verdict, look at the neighbourhood. A result sitting on a broad plateau is robust. A single spike surrounded by failures is a result fitted to its own parameters.

r.surface()
# {
#   'shape': 'knife_edge',
#   'n_ok': 9,
#   'n_failed': 0,
#   'best_sharpe': 1.9143,
#   'median_sharpe': 0.221,
#   'share_within_20pct_of_best': 0.1111,
#   'plateau_centre': None,
#   'reading': 'One configuration performs and its neighbours do not. '
#              'Usually a fitted result.',
# }

shape

plateau, ridge or knife_edge. Set by what share of the grid lands within 20% of the best result: 30% or more is a plateau, 10% or more a ridge, below that a knife edge.

share_within_20pct_of_best

The number behind the shape, so you are free to disagree with the thresholds.

plateau_centre

Per parameter, where the robust region sits and how wide it is. The actionable half: it tells you where to re-centre, not merely that your number was flattered.

reading

The shape in one sentence. The same string every time, so it can be quoted.

Reading the verdict

The verdict deflates the best result for the search that actually produced it, and reports what it needed in order to say so.

v = r.verdict()

v["n_trials"]                 # 9
v["n_trials_source"]          # 'derived_from_grid'
v["deflated_sharpe"]          # 0.3106
v["verdict"]                  # 'inconclusive'
v["data_hash"]                # a content hash of what it ran on
v["min_track_record_length"]  # how long this record must run to beat luck

n_trials_source travels with the figure on purpose. A count that was asserted and a count that was counted are different claims, and every deflated number downstream rests on which one it is. When this package produces the figure the source is always derived_from_grid, because there is no other way to produce it here.

Probability of backtest overfitting is reported alongside, and is deliberately not the gate:

v["selection"]
# {
#   'question': 'was the choice among configurations informative?',
#   'not_a_verdict_on_the_edge': True,
#   'pbo': 0.48, ...
# }

The study file

A study is a JSON artifact holding what was tried, what came back, and a content hash of the data it ran on. Readable in a text editor, diffable, and versioned so it still parses in two years.

r.save("study.json")
# PosixPath('study.json')

from alphaengine import load
s = load("study.json")

s.schema_version   # load() refuses an unknown MAJOR version
s.data_hash        # a label can be changed to escape a history; an array cannot
s.n_trials_source  # 'derived_from_grid'

The version rule here is stricter than semver: a bump is required whenever a computed valuechanges, even when the signature is untouched. Once the numbers are published they are a contract, and somebody’s saved study has to reproduce.

Wiring your own backtest

Your function is called once per combination and must return a sequence of per-period returns. It is called as backtest_fn(data=data, **params) when data is given, and backtest_fn(**params) when it is not.

def my_backtest(*, data, fast, slow):
    fast_ma = data.close.rolling(fast).mean()
    slow_ma = data.close.rolling(slow).mean()
    signal = (fast_ma > slow_ma).shift(1)
    return (signal * data.close.pct_change()).dropna().to_numpy()

r = sweep(my_backtest, {"fast": [5, 10, 20], "slow": [50, 100, 200]}, data=px)

data

Passed through untouched. Only hashed — never inspected, never stored.

store_params

OFF by default. Hashes are always kept, so runs stay comparable without the parameter values leaving your machine. The grid is often bigger intellectual property than the return series.

on_error

'record' (the default) marks a failing combination and continues, because one bad corner of a grid should not lose the other ninety-nine results. 'raise' propagates.

The result holds the full trial matrix, which is what PBO needs and what a single-point run structurally cannot produce. That is the argument for running a grid rather than calling a calculator on one number.

What is in the core

Everything below is a pure function — no clock read, no environment read, no data-layer import. That is guaranteed by a test that scans the module tree without importing it.

from alphaengine.core import (
    deflated_sharpe,             # corrected for the size of the search
    probabilistic_sharpe_ratio,
    expected_max_sharpe,         # what the best of N looks like under no edge
    min_track_record_length,     # how long before it beats luck
    pbo_cscv,                    # probability of backtest overfitting
    cpcv_score,                  # combinatorial purged cross-validation
    performance_report,
    compute_var_cvar,
    run_backtest,
    score_backtest,
    technical_features,
)

VaR and CVaR

Always POSITIVE loss magnitudes, with CVaR at least VaR. Sign conventions are the most common source of a wrong risk number, so this one is fixed everywhere.

Calmar

Geometric. Annualised return compounds rather than averaging.

Sortino

The denominator is target semideviation over all N periods, not the standard deviation of the negative subset.

Factor decomposition and cointegration live behind the factors extra, so statsmodels is not a hard dependency of the core.

What never leaves the machine

The package makes no network call. In the paid platform the same rule is enforced rather than promised: a market series is the feed and is never stored, while a price you transacted at is your record and is yours to keep.

Your market data

Never stored. Supplied per call, computed, discarded.

Your model

Never ingested. We do not take your alpha logic.

Your parameter grid

Hashed by default; values kept only if you ask for it.

Your judgment

Stored — theses, decisions, limits, your record. Scoped to you, encrypted, exportable, deletable.

The full line, item by item, is on the Trust page.