openquant.adapters

Pure Python. Signatures are as written in the source; descriptions are the docstrings. All Python modules.

Classes

SignalStreamBuffer

class SignalStreamBuffer

Incremental buffer for streaming signal updates in research notebooks.

SignalStreamBuffer.__init__

__init__() -> None

SignalStreamBuffer.append

append(
    timestamps: Sequence[str],
    signal: Sequence[float],
    side: Sequence[float] | None = None,
    symbol: str | None = None,
) -> None

Append one batch of signal rows.

The batch is converted with to_polars_signal_frame immediately, so length errors surface here. Use the same optional columns (side, symbol) in every batch: frame concatenates batches vertically and fails if their columns differ.

Parameters

timestamps : Sequence[str]

Timestamp strings, one per signal value.

signal : Sequence[float]

Signal values.

side : Sequence[float] or None, default None

Optional side per row.

symbol : str or None, default None

Optional symbol, repeated on every row of the batch.

Raises

ValueError

If signal or side differs in length from timestamps.

SignalStreamBuffer.frame

frame() -> pl.DataFrame

Return all buffered batches as one frame, in append order.

Returns

polars.DataFrame

The vertical concatenation of every appended batch (columns as in to_polars_signal_frame). With nothing buffered, an empty frame with columns ts and signal.

SignalStreamBuffer.clear

clear() -> None

Discard all buffered batches.

Functions

to_pandas

to_pandas(df: pl.DataFrame) -> Any

Optional pandas conversion for downstream tooling.

to_polars_backtest_frame

to_polars_backtest_frame(
    timestamps: Sequence[str],
    equity_curve: Sequence[float],
    returns: Sequence[float] | None = None,
    positions: Sequence[float] | None = None,
) -> pl.DataFrame

Build a backtest frame from parallel timestamp and equity-curve lists.

ts strings are parsed to Datetime the same way as in to_polars_signal_frame; unparseable strings become null.

Parameters

timestamps : Sequence[str]

Timestamp strings, one per equity value.

equity_curve : Sequence[float]

Equity value per timestamp.

returns : Sequence[float] or None, default None

Optional per-bar strategy return.

positions : Sequence[float] or None, default None

Optional position per bar.

Returns

polars.DataFrame

Columns ts (Datetime) and equity, then returns and position if given.

Raises

ValueError

If equity_curve, returns or positions differs in length from timestamps.

to_polars_event_frame

to_polars_event_frame(
    starts: Sequence[str],
    ends: Sequence[str],
    probs: Sequence[float],
    sides: Sequence[float] | None = None,
    labels: Sequence[int] | None = None,
) -> pl.DataFrame

Build an event frame from parallel start/end timestamp and probability lists.

start_ts and end_ts strings are parsed to Datetime the same way as in to_polars_signal_frame; unparseable strings become null.

Parameters

starts : Sequence[str]

Event start timestamps.

ends : Sequence[str]

Event end timestamps.

probs : Sequence[float]

Predicted probability per event.

sides : Sequence[float] or None, default None

Optional side per event.

labels : Sequence[int] or None, default None

Optional label per event.

Returns

polars.DataFrame

Columns start_ts and end_ts (Datetime) and prob, then side and label if given, in input order.

Raises

ValueError

If ends, probs, sides or labels differs in length from starts.

to_polars_frontier_frame

to_polars_frontier_frame(
    volatility: Sequence[float],
    returns: Sequence[float],
    sharpe: Sequence[float] | None = None,
    point_ids: Sequence[str] | None = None,
) -> pl.DataFrame

Build an efficient-frontier frame from parallel volatility and return lists.

Parameters

volatility : Sequence[float]

Volatility of each frontier point.

returns : Sequence[float]

Expected return of each frontier point.

sharpe : Sequence[float] or None, default None

Optional Sharpe ratio per point.

point_ids : Sequence[str] or None, default None

Optional identifier per point; defaults to p0, p1, ...

Returns

polars.DataFrame

Columns volatility, return, sharpe (only if given) and point_id.

Raises

ValueError

If returns, sharpe or point_ids differs in length from volatility.

to_polars_indicator_matrix

to_polars_indicator_matrix(
    ind_mat: Sequence[Sequence[int]],
    bar_index: Sequence[int] | None = None,
    label_names: Sequence[str] | None = None,
) -> pl.DataFrame

Convert a row-major indicator matrix into a wide frame, one column per label.

Typically the bar-by-label indicator matrix of AFML section 4.5 (Snippet 4.3), where entry [t][i] is 1 when bar t falls inside label i's span. Values are cast to int.

Parameters

ind_mat : Sequence[Sequence[int]]

Rectangular matrix, one row per bar and one column per label.

bar_index : Sequence[int] or None, default None

Index for each row; defaults to 0..len(ind_mat) - 1.

label_names : Sequence[str] or None, default None

Column names for the labels; defaults to label_0, label_1, ...

Returns

polars.DataFrame

Column bar_index followed by one integer column per label. An empty ind_mat gives a frame with only an empty bar_index column.

Raises

ValueError

If ind_mat is not rectangular, or label_names or bar_index has the wrong length.

to_polars_signal_frame

to_polars_signal_frame(
    timestamps: Sequence[str],
    signal: Sequence[float],
    side: Sequence[float] | None = None,
    symbol: str | None = None,
) -> pl.DataFrame

Build a signal frame from parallel timestamp and signal lists.

ts strings are parsed to Datetime: "%Y-%m-%d %H:%M:%S" with an optional fractional second is parsed exactly, anything else falls back to polars' format inference, and a string that parses under neither becomes null (no error is raised).

Parameters

timestamps : Sequence[str]

Timestamp strings, one per signal value.

signal : Sequence[float]

Signal values.

side : Sequence[float] or None, default None

Optional side (for example +1/-1) per row.

symbol : str or None, default None

Optional symbol, repeated on every row.

Returns

polars.DataFrame

Columns ts (Datetime) and signal, then side if given and symbol if given, in input order.

Raises

ValueError

If signal or side differs in length from timestamps.

to_polars_weights_frame

to_polars_weights_frame(
    asset_names: Sequence[str],
    weights: Sequence[float],
    as_of: str | None = None,
) -> pl.DataFrame

Build a portfolio weights frame from parallel asset name and weight lists.

Parameters

asset_names : Sequence[str]

Asset names.

weights : Sequence[float]

Weight per asset.

as_of : str or None, default None

Optional timestamp string, repeated on every row and parsed to Datetime (null if it does not parse).

Returns

polars.DataFrame

Columns asset and weight, plus as_of (Datetime) if given.

Raises

ValueError

If weights differs in length from asset_names.