edtechre/pybroker

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

This notebook explains how to create and integrate custom stock indicators in **PyBroker**.  Indicators in **PyBroker** are written using [NumPy](https://numpy.org/), a powerful library for numerical computing. To optimize performance, we'l

The following code shows an indicator function that calculates close prices minus a moving average (CMMA), which can be used for a [mean reversion](https://en.wikipedia.org/wiki/Mean_reversion_(finance)) strategy:

The ```cmma``` function takes two arguments: ```bar_data```, which is an instance of the [BarData](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.BarData) class that holds OHLCV data and custom fields, and

The ```vec_cmma``` function is JIT-compiled by Numba and nested inside ```cmma```. This is necessary since a Numba compiled function supports a NumPy array as an argument but not an instance of a Python class like ```BarData```. Note the co

Here, we are giving the name ```cmma_20``` to the indicator function and specifying the ```lookback``` parameter as ```20``` bars. Any arguments in the indicator function that come after ```bar_data``` will be passed as user-defined argumen

The following is an example of how to use the registered ```Indicator``` in **PyBroker** with some data downloaded from [Yahoo Finance](https://finance.yahoo.com):

As you can see, the ```Indicator``` instance is a ```Callable```. Once called, the resulting computed indicator values are returned as a [Pandas Series](https://pandas.pydata.org/docs/reference/api/pandas.Series.html).

The ```Indicator``` class also provides functions for measuring its information content. For example, you can compute the [interquartile range (IQR)](https://en.wikipedia.org/wiki/Interquartile_range):

Or compute the relative [entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)):

The indicator values are retrieved by calling [ctx.indicator](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.indicator) on the [ExecContext](https://www.pybroker.com/en/latest/reference/pybro

Here, the ```buy_cmma_cross``` function is added to the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) along with the ```cmma_20``` indicator. We can enable caching of the computed

**PyBroker** computes indicator values before the backtest runs. By default, these calculations occur serially. See [Configuring Parallelization](https://www.pybroker.com/en/latest/notebooks/11.%20Configuring%20Parallelization.html) for det

**PyBroker** provides vectorized helper functions to make the process of computing indicators easier. One of these helper functions is [highv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.highv), which calcu

The [pybroker.vect](https://www.pybroker.com/en/latest/reference/pybroker.vect.html) module also includes other vectorized helpers such as [lowv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.lowv), [sumv](ht

Additionally, **PyBroker** includes convenient wrappers for [highest](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.highest) and [lowest](https://www.pybroker.com/en/latest/reference/pybroker.indica

Use an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) to calculate multiple indicators. Add the `cmma_20` and `hhv_5` indicators to the `IndicatorSet` to compute them tog

[TA-Lib](https://github.com/TA-Lib/ta-lib-python) is a widely used technical analysis library that implements many financial indicators. You can install it with `pip install ta-lib`.

**PyBroker** also includes built-in indicators that are available in the [indicator module](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html). **PyBroker** reimplements these standard indicators with volatility normaliza

[In the next tutorial, you will learn how to train a model using custom indicators in PyBroker](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html).

**PyBroker** uses [Joblib](https://joblib.readthedocs.io/) to compute indicators, train models, and optimize parameters in parallel.

[set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) updates the global Joblib configuration. The [n_jobs](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pyb

Indicators are computed **per symbol**: all indicators for a given symbol are grouped into a single task, and one task is dispatched per symbol. Passing `parallel_indicators=True` to [backtest](https://www.pybroker.com/en/latest/reference/p

Standalone indicator computation with an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) accepts the same `parallel_indicators` flag:

Model training runs serially by default. Passing `parallel_models=True` to [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) or [walkforward](https://www.pybroker.com/en/late

This example adapts the linear regression model from [Training a Model](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html):

[Ray](https://www.ray.io/) can distribute the same work across many cores or an entire cluster. Install it with `pip install ray` and then register it with Joblib via [register_ray](https://docs.ray.io/en/latest/ray-more-libs/joblib.html) (

After registering Ray, pass `backend="ray"` to [set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) to make it available as a backend:

**PyBroker** will now use the Ray backend for all parallel tasks. For example, calling [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) with `parallel_indicators=True`:

We will explore [parameter optimization](https://www.pybroker.com/en/latest/notebooks/12.%20Parameter%20Optimization.html) in the next notebook, which can also be parallelized in certain scenarios.

Your chosen interval must always be longer than the bars being compressed. For example, if you fetch daily bars from [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance), then `"weekly"` and `"m

The [compress_bars](https://www.pybroker.com/en/latest/reference/pybroker.interval.html#pybroker.interval.compress_bars) function converts OHLCV data (either a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame

*   **Volume:** The sum of the volumes. *   **VWAP:** The volume-weighted average. *   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance

*   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance)'s `adj_close`).

Let's compress AMD into calendar weeks and view the result as a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) with [bars_to_df](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybro

To use higher timeframes in your backtest, pass the `intervals` parameter to [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution). Your execution function can then acc

To prevent look-ahead bias, [ctx.interval](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.interval) only ever exposes *completed* bars. For example, the week or month that is currently formin

To compute an indicator on compressed bars, bind it to one or more intervals with [Indicator.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator.intervals).

**PyBroker** automatically combines bound intervals with those in the execution's `intervals` parameter. Here, the `"weekly"` interval is made accessible via [ctx.interval("weekly")](https://www.pybroker.com/en/latest/reference/pybroker.con

Note that the binding will override also computing the indicator on the base timeframe of the data source. To also compute the indicator on the base timeframe of the data source, pass `"base"` to [Indicator.intervals()](https://www.pybroker

You can bind models in the same way with [ModelSource.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource.intervals). **PyBroker** will then train models for each interval using the in

This example trains a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model to predict the next weekly return from the weekly close:

During [Walkforward Analysis](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward), the `lookahead` between an interval model's train and test data is enforced using the compressed bar 

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

In the [last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we learned how to write stock indicators in **PyBroker**. Indicators are a good starting point for developing a trading strategy. But to cr

One of the main features of **PyBroker** is the ability to train and backtest machine learning models. These models can utilize indicators as features to make more accurate predictions about market movements. Once trained, these models can 

As with [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource) and [Indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator) data, **PyBrok

In [the last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we implemented an indicator that calculates the close-minus-moving-average (CMMA) using [NumPy](https://www.numpy.org) and [Numba](https://

Next, we want to build a model that predicts the next day's return using the 20-day CMMA. Using [simple linear regression](https://en.wikipedia.org/wiki/Simple_linear_regression) is a good approach to begin experimenting with as a baseline 

Below we import a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model from [scikit-learn](https://scikit-learn.org/stable/):

After fitting the model, the function uses the testing data to evaluate the model's accuracy, specifically by computing the [R-squared](https://en.wikipedia.org/wiki/Coefficient_of_determination) score. The R-squared score provides a measur

Once the function to train the model has been defined, it needs to be registered with **PyBroker**. This is done by creating a new [ModelSource](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource)  i

To create a trading strategy that uses the trained model, create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) object using the [YFinance](https://www.pybroker.com/en/latest

The [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) method is then called on the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#py

The last step is to run the backtest by calling the [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) method on the `Strategy` object. Set the `train_size` to `0.5` to specif

**PyBroker** employs a powerful algorithm known as [Walkforward Analysis](https://www.youtube.com/watch?v=WBZ_Vv-iMv4) to perform backtesting. The algorithm partitions the backtest data into a fixed number of time windows, each containing a

![Walkforward Diagram](https://github.com/edtechre/pybroker/blob/master/docs/_static/walkforward.gif?raw=true)

Let's consider a trading strategy that generates buy and sell signals from the [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model that we trained earlier. The strategy is i

The [ctx.preds('slr')](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) method is used to access the predictions made by the ```'slr'``` model for the current stock symbol being executed

Run the backtest by calling the [walkforward](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward) method on the `Strategy` object, passing the desired number of time windows and the tr

Beyond linear regression, **PyBroker** can train other model types such as gradient boosted machines, neural networks, or any other architecture that we choose. To help support these models, **PyBroker** offers extensive customization optio

Additionally, **PyBroker v2** now supports training [time series models](https://www.pybroker.com/en/latest/notebooks/16.%20Time%20Series%20Models.html) and [multi-symbol models](https://www.pybroker.com/en/latest/notebooks/17.%20Multi-Symb

To show how this works, we will backtest two different strategies. The first relies on a volatility forecast from a [GARCH(1,1)](https://en.wikipedia.org/wiki/Autoregressive_conditional_heteroskedasticity) model built with the [arch](https:

GARCH will model the volatility of a return series, so we start by defining an [indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.indicator) for log returns:

By default, **PyBroker** passes all test window data to the model in a single call to make a make a prediction. While this vectorized approach is efficient, it fails for autoregressive models since they rely on the previous step's output to

The strategy then uses the volatility forecast from [ctx.preds](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) as a regime filter. It enters a long position when forecast volatility is

The second strategy trains a [RandomForestRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html) to predict the next bar's return from lagged returns:

The training function receives `lag_train` and `lag_test` parameters built from configuring the model with the desired number of [lags](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.model). Each parameter i

Registering the model with [lags](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.model) set to `3` will include the past three lagged values for each column declared in [lag_cols](https://www.pybroker.com/en

The strategy buys when [ctx.preds](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) for the next-bar return is positive and exits when it is negative. We then run a [walkforward](https:/

**PyBroker v2** supports training one model across all symbols passed to [Strategy.add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution), as shown in this notebook.

This notebook repurposes the linear regression example from [Training a Model](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html). Below, one shared [LinearRegression](https://scikit-learn.org/stable/modules/genera

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

This notebook explains how to create and integrate custom stock indicators in **PyBroker**.  Indicators in **PyBroker** are written using [NumPy](https://numpy.org/), a powerful library for numerical computing. To optimize performance, we'l

The following code shows an indicator function that calculates close prices minus a moving average (CMMA), which can be used for a [mean reversion](https://en.wikipedia.org/wiki/Mean_reversion_(finance)) strategy:

The ```cmma``` function takes two arguments: ```bar_data```, which is an instance of the [BarData](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.BarData) class that holds OHLCV data and custom fields, and

The ```vec_cmma``` function is JIT-compiled by Numba and nested inside ```cmma```. This is necessary since a Numba compiled function supports a NumPy array as an argument but not an instance of a Python class like ```BarData```. Note the co

Here, we are giving the name ```cmma_20``` to the indicator function and specifying the ```lookback``` parameter as ```20``` bars. Any arguments in the indicator function that come after ```bar_data``` will be passed as user-defined argumen

The following is an example of how to use the registered ```Indicator``` in **PyBroker** with some data downloaded from [Yahoo Finance](https://finance.yahoo.com):

As you can see, the ```Indicator``` instance is a ```Callable```. Once called, the resulting computed indicator values are returned as a [Pandas Series](https://pandas.pydata.org/docs/reference/api/pandas.Series.html).

The ```Indicator``` class also provides functions for measuring its information content. For example, you can compute the [interquartile range (IQR)](https://en.wikipedia.org/wiki/Interquartile_range):

Or compute the relative [entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)):

The indicator values are retrieved by calling [ctx.indicator](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.indicator) on the [ExecContext](https://www.pybroker.com/en/latest/reference/pybro

Here, the ```buy_cmma_cross``` function is added to the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) along with the ```cmma_20``` indicator. We can enable caching of the computed

**PyBroker** computes indicator values before the backtest runs. By default, these calculations occur serially. See [Configuring Parallelization](https://www.pybroker.com/en/latest/notebooks/11.%20Configuring%20Parallelization.html) for det

**PyBroker** provides vectorized helper functions to make the process of computing indicators easier. One of these helper functions is [highv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.highv), which calcu

The [pybroker.vect](https://www.pybroker.com/en/latest/reference/pybroker.vect.html) module also includes other vectorized helpers such as [lowv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.lowv), [sumv](ht

Additionally, **PyBroker** includes convenient wrappers for [highest](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.highest) and [lowest](https://www.pybroker.com/en/latest/reference/pybroker.indica

Use an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) to calculate multiple indicators. Add the `cmma_20` and `hhv_5` indicators to the `IndicatorSet` to compute them tog

[TA-Lib](https://github.com/TA-Lib/ta-lib-python) is a widely used technical analysis library that implements many financial indicators. You can install it with `pip install ta-lib`.

**PyBroker** also includes built-in indicators that are available in the [indicator module](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html). **PyBroker** reimplements these standard indicators with volatility normaliza

[In the next tutorial, you will learn how to train a model using custom indicators in PyBroker](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html).

In the [last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we learned how to write stock indicators in **PyBroker**. Indicators are a good starting point for developing a trading strategy. But to cr

One of the main features of **PyBroker** is the ability to train and backtest machine learning models. These models can utilize indicators as features to make more accurate predictions about market movements. Once trained, these models can 

As with [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource) and [Indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator) data, **PyBrok

In [the last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we implemented an indicator that calculates the close-minus-moving-average (CMMA) using [NumPy](https://www.numpy.org) and [Numba](https://

Next, we want to build a model that predicts the next day's return using the 20-day CMMA. Using [simple linear regression](https://en.wikipedia.org/wiki/Simple_linear_regression) is a good approach to begin experimenting with as a baseline 

Below we import a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model from [scikit-learn](https://scikit-learn.org/stable/):

After fitting the model, the function uses the testing data to evaluate the model's accuracy, specifically by computing the [R-squared](https://en.wikipedia.org/wiki/Coefficient_of_determination) score. The R-squared score provides a measur

Once the function to train the model has been defined, it needs to be registered with **PyBroker**. This is done by creating a new [ModelSource](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource)  i

To create a trading strategy that uses the trained model, create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) object using the [YFinance](https://www.pybroker.com/en/latest

The [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) method is then called on the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#py

The last step is to run the backtest by calling the [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) method on the `Strategy` object. Set the `train_size` to `0.5` to specif

**PyBroker** employs a powerful algorithm known as [Walkforward Analysis](https://www.youtube.com/watch?v=WBZ_Vv-iMv4) to perform backtesting. The algorithm partitions the backtest data into a fixed number of time windows, each containing a

![Walkforward Diagram](https://github.com/edtechre/pybroker/blob/master/docs/_static/walkforward.gif?raw=true)

Let's consider a trading strategy that generates buy and sell signals from the [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model that we trained earlier. The strategy is i

The [ctx.preds('slr')](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) method is used to access the predictions made by the ```'slr'``` model for the current stock symbol being executed

Run the backtest by calling the [walkforward](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward) method on the `Strategy` object, passing the desired number of time windows and the tr

Beyond linear regression, **PyBroker** can train other model types such as gradient boosted machines, neural networks, or any other architecture that we choose. To help support these models, **PyBroker** offers extensive customization optio

Additionally, **PyBroker v2** now supports training [time series models](https://www.pybroker.com/en/latest/notebooks/16.%20Time%20Series%20Models.html) and [multi-symbol models](https://www.pybroker.com/en/latest/notebooks/17.%20Multi-Symb

Your chosen interval must always be longer than the bars being compressed. For example, if you fetch daily bars from [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance), then `"weekly"` and `"m

The [compress_bars](https://www.pybroker.com/en/latest/reference/pybroker.interval.html#pybroker.interval.compress_bars) function converts OHLCV data (either a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame

*   **Volume:** The sum of the volumes. *   **VWAP:** The volume-weighted average. *   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance

*   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance)'s `adj_close`).

Let's compress AMD into calendar weeks and view the result as a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) with [bars_to_df](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybro

To use higher timeframes in your backtest, pass the `intervals` parameter to [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution). Your execution function can then acc

To prevent look-ahead bias, [ctx.interval](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.interval) only ever exposes *completed* bars. For example, the week or month that is currently formin

To compute an indicator on compressed bars, bind it to one or more intervals with [Indicator.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator.intervals).

**PyBroker** automatically combines bound intervals with those in the execution's `intervals` parameter. Here, the `"weekly"` interval is made accessible via [ctx.interval("weekly")](https://www.pybroker.com/en/latest/reference/pybroker.con

Note that the binding will override also computing the indicator on the base timeframe of the data source. To also compute the indicator on the base timeframe of the data source, pass `"base"` to [Indicator.intervals()](https://www.pybroker

You can bind models in the same way with [ModelSource.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource.intervals). **PyBroker** will then train models for each interval using the in

This example trains a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model to predict the next weekly return from the weekly close:

During [Walkforward Analysis](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward), the `lookahead` between an interval model's train and test data is enforced using the compressed bar 

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

[In the previous notebook](https://www.pybroker.com/en/latest/notebooks/2.%20Backtesting%20a%20Strategy.html), we implemented and backtested a trading strategy. Here is that implementation again:

As before, we create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) instance with the given configurations:

While the `total_pnl` metric above suggests a profitable strategy, these results could just be due to chance. To increase confidence in our evaluation, we can use the [bootstrap method](https://en.wikipedia.org/wiki/Bootstrapping_(statistic

**PyBroker** applies the bootstrap method to calculate [confidence intervals](https://en.wikipedia.org/wiki/Confidence_interval) for two performance metrics: the [Profit Factor](https://www.pybroker.com/en/latest/reference/pybroker.eval.htm

**PyBroker** uses the [bias-corrected and accelerated (BCa) bootstrap method](https://en.wikipedia.org/wiki/Bootstrapping_(statistics)#Bias-corrected_and_accelerated_(BCa)_bootstrap) to calculate confidence intervals for these metrics. Retu

[In the next notebook, we will discuss how to incorporate ranking long and short signals in your trading strategies](https://www.pybroker.com/en/latest/notebooks/4.%20Ranking%20Long%20and%20Short%20Signals.html).

**PyBroker** uses [Joblib](https://joblib.readthedocs.io/) to compute indicators, train models, and optimize parameters in parallel.

[set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) updates the global Joblib configuration. The [n_jobs](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pyb

Indicators are computed **per symbol**: all indicators for a given symbol are grouped into a single task, and one task is dispatched per symbol. Passing `parallel_indicators=True` to [backtest](https://www.pybroker.com/en/latest/reference/p

Standalone indicator computation with an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) accepts the same `parallel_indicators` flag:

Model training runs serially by default. Passing `parallel_models=True` to [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) or [walkforward](https://www.pybroker.com/en/late

This example adapts the linear regression model from [Training a Model](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html):

[Ray](https://www.ray.io/) can distribute the same work across many cores or an entire cluster. Install it with `pip install ray` and then register it with Joblib via [register_ray](https://docs.ray.io/en/latest/ray-more-libs/joblib.html) (

After registering Ray, pass `backend="ray"` to [set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) to make it available as a backend:

**PyBroker** will now use the Ray backend for all parallel tasks. For example, calling [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) with `parallel_indicators=True`:

We will explore [parameter optimization](https://www.pybroker.com/en/latest/notebooks/12.%20Parameter%20Optimization.html) in the next notebook, which can also be parallelized in certain scenarios.

**PyBroker v2** supports parameterized strategies. This allows you to backtest strategies using different combinations of parameters and automatically select the best performers. This process is known as **parameter optimization** and is ha

A hyperparameter is a named, tunable value created with [hyperparam](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.hyperparam). Each one has a [default](https://www.pybroker.com/en/latest/reference/py

- **Indicators**: pass it as a keyword argument to [indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.indicator).

- **Executions**: attach it with `hyperparams=` on [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) and read it with [ctx.hyperparam](https://www.pybroker.com/en/l

The [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.optimize) method splits the data into train and test windows as specified by `train_size` (`0.5` for 50/50 by default). As Optuna 

[best_params](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.best_params) holds the best in-sample values, and [best_score](https://www.pybroker.com/en/latest/reference/pybroker.optimize

Using the optimized parameters, we're able to see an improvment to the total return from before. The [result](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.result) attribute contains th

Grid search grows multiplicatively with each added hyperparameter. An alternative approach is using `sampler="tpe"`. Optuna's [TPESampler](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.TPESampler.html)

`sampler="random"` chooses combinations uniformly at random with Optuna's [RandomSampler](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.RandomSampler.html). Like grid, random trials can be evaluated in

Any [optuna.samplers.BaseSampler](https://optuna.readthedocs.io/en/stable/reference/samplers/index.html) instance can also be passed directly to [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strateg

Every optimization also returns the underlying [optuna.Study](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html) for inspecting the trials:

Finally, [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.optimize) supports walkforward optimization. If you pass `> 1` to the `windows` parameter, PyBroker will independently tune t

Each window is tuned separately, so the best parameters can differ between windows. The combined result contains the [best_params](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.best_par

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

To limit the number of long positions that can be held at any time to ```1```, we call [set_max_long_positions](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.set_max_long_positions). This eff

**PyBroker** can also rank short signals using [short_score](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.short_score), where short orders are placed for the ticker symbols with the highest

[In the next notebook, we will discuss how to implement custom indicators in PyBroker](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html).

Our strategy will involve ranking and buying stocks with the highest [price rate-of-change (ROC)](https://www.investopedia.com/terms/p/pricerateofchange.asp). To start, we'll define a 20-day ROC indicator using [TA-Lib](https://github.com/T

To implement the strategy, we write a `rotate` function that sets each stock's [long_score](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.long_score) to its 20-day ROC. **PyBroker** then ran

Now that we have a method for scoring stocks by their ROC, we can use the [enable_rotation](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.enable_rotation) method to turn on rotational trading

We cap long positions at `2` with [set_max_long_positions](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.set_max_long_positions). Setting `worst_rank_held` to `5` liquidates any currently hel

**PyBroker** will allocate our capital equally between positions by default. To customize this, we can pass a ``sizer`` function to [enable_rotation](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Stra

**PyBroker v2** now enables dynamic symbol selection with [SymbolSelector](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.SymbolSelector).

Below, data is downloaded for twenty liquid large-caps from [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance):

Dynamic symbol selection is handled using a [SymbolSelector](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.SymbolSelector), which can be any callable that takes a [Pandas DataFrame](https://pandas.pydata.

For each [walkforward](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward) window, the `top_dollar_volume` selector runs on the train split and selects the top three stocks to trade du

Executable file

[Credential-related source omitted]

Retrieves stock data from `Alpaca <https://alpaca.markets/>`_.

[Credential-related source omitted]

Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_.

Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_\ .

- `auto_adjust: bool` - `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finan

- `query(symbols: Union[str, Iterable[str]], start_date: Union[str, datetime], end_date: Union[str, datetime], _timeframe: Optional[str]='', _adjust: Optional[Any]=None) -> pd.DataFrame`: Queries data from `Yahoo Finance <https://finance.ya

- `profit_factor(changes: NDArray[np.float64], use_log: bool=False) -> float`: Computes the profit factor, which is the ratio of gross profit to gross loss. - `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log tran

- `log_profit_factor(changes: NDArray[np.float64]) -> float`: Computes the log transformed profit factor, which is the ratio of gross profit to gross loss. - `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Co

- `sharpe_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sharpe Ratio <https://en.wikipedia.org/wiki/Sharpe_ratio>`_, using the population standard deviation of ``returns``.

- `downside_deviation(returns: NDArray[np.float64]) -> float`: Computes downside deviation, the denominator of the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `sortino_ratio(returns: NDArray[np.float64], obs: Optional[int]=None) -> float`: Computes the `Sortino Ratio <https://en.wikipedia.org/wiki/Sortino_ratio>`_.

- `drawdown_conf(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int) -> DrawdownMetrics`: Computes upper bounds of confidence intervals for maximum drawdown using the bootstrap method. - `bootstrap_eval_all(changes: NDA

- `bootstrap_eval_all(changes: NDArray[np.float64], returns: NDArray[np.float64], n_boot: int, bars_per_year: int) -> tuple[BootConfIntervals, BootConfIntervals, DrawdownMetrics]`: Computes all bootstrap metrics in one shared resampling pas

- `relative_entropy(values: NDArray[np.float64]) -> float`: Computes the relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(values: NDArray[np.float64]) -> float`: Computes the `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_ of ``values``.

- `ulcer_index(values: NDArray[np.float64], period: Optional[int]=None) -> float`: Computes the `Ulcer Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: the root mean square of percentage drawdowns from the running peak.

- `upi(values: NDArray[np.float64], period: Optional[int]=None, ui: Optional[float]=None, bars_per_year: Optional[int]=None) -> float`: Computes the `Ulcer Performance Index <https://en.wikipedia.org/wiki/Ulcer_index>`_ of ``values``: retur

- `name: str` - `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(info

- `hyperparam_names() -> frozenset[str]` - `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory

- `relative_entropy(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its relative `entropy <https://en.wikipedia.org/wiki/Entropy_(information_theory)>`_.

- `iqr(data: Union[BarData, pd.DataFrame]) -> float`: Generates indicator data with ``data`` and computes its `interquartile range (IQR) <https://en.wikipedia.org/wiki/Interquartile_range>`_.

- `unique_dates() -> NDArray[np.datetime64]`: Returns sorted unique dates across every symbol in the store. - `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict``

- `fetch_dict(symbol: str, names: Iterable[str], end_index: Optional[int]=None) -> dict[str, Optional[NDArray]]`: Fetches a ``dict`` of column data for ``symbol``. - `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> Optional[NDArray]`: Fetches a :class:`numpy.ndarray` of column data for ``symbol``.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray[np.float64]`: Fetches :class:`pybroker.indicator.Indicator` data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> pd.DataFrame`: Fetches model input data.

- `fetch(symbol: str, name: str, end_index: Optional[int]=None) -> NDArray`: Fetches model predictions.

- `fetch_float(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> float`: Returns a bar price as ``float`` using the per-bar cache when possible. - `fetch_bar_ohl

- `fetch(symbol: str, price: Union[int, float, np.floating, Decimal, PriceType, Callable[[str, BarData], Union[int, float, Decimal]]]) -> Decimal`

Mixin implementing logic for `Walkforward Analysis <https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html#Walkforward-Analysis>`_.

- `walkforward_split(df: pd.DataFrame, windows: int, lookahead: int, train_size: float=0.9, shuffle: bool=False) -> Iterator[WalkforwardWindow]`: Splits a :class:`pandas.DataFrame` containing data for multiple ticker symbols into an :class:

- `clear_executions()`: Clears executions that were added with :meth:`.add_execution`. - `backtest(start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tup

- `walkforward(windows: int, lookahead: int=1, start_date: Optional[Union[str, datetime]]=None, end_date: Optional[Union[str, datetime]]=None, timeframe: str='', between_time: Optional[tuple[str, str]]=None, days: Optional[Union[str, Day, I

Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_.

Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_\ .

class Alpaca(DataSource):     """Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves stock data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class AlpacaCrypto(DataSource):     """Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

"""Retrieves crypto data from `Alpaca <https://alpaca.markets/>`_."""

[Credential-related source omitted]

class YFinance(DataSource):     """Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

"""Retrieves data from `Yahoo Finance <https://finance.yahoo.com/>`_."""

# --- src/pybroker/ext/data.py --- class AKShare(DataSource):     """Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

"""Retrieves data from `AKShare <https://akshare.akfamily.xyz/>`_."""

class YQuery(DataSource):     """Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

"""Retrieves data from Yahoo Finance using `Yahooquery <https://github.com/dpguthrie/yahooquery>`_."""

end_index: Optional[int] = None,     ) -> dict[str, Optional[NDArray]]: ...     def fetch(

) -> dict[str, Optional[NDArray]]: ...     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

"""Caches and retrieves :class:`pybroker.indicator.Indicator` data."""     # Constructed by the framework; not user-instantiable.     def fetch(

# Constructed by the framework; not user-instantiable.     def fetch(         self, symbol: str, name: str, end_index: Optional[int] = None

def fetch(

Welcome to **PyBroker**! The best place to start is by learning about the [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource) class. A `DataSource` fetches data from external providers, all

One of the built-in data sources in **PyBroker** is [Yahoo Finance](https://finance.yahoo.com). To use it, import [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance):

The code above queries data for AAPL and MSFT, returning the results in a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html).

To speed up data retrieval, you can cache your queries using **PyBroker**'s caching system. Enable caching by calling [pybroker.enable_data_source_cache('name')](https://www.pybroker.com/en/latest/reference/pybroker.cache.html#pybroker.cach

The next call to [query](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource.query) caches the returned data to disk. Each unique combination of ticker symbol and date range is cached separately:

You can clear the cache using [pybroker.clear_data_source_cache](https://www.pybroker.com/en/latest/reference/pybroker.cache.html#pybroker.cache.clear_data_source_cache):

Or disable caching altogether using [pybroker.disable_data_source_cache](https://www.pybroker.com/en/latest/reference/pybroker.cache.html#pybroker.cache.disable_data_source_cache):

Note that these calls should be made after first calling [pybroker.enable_data_source_cache](https://www.pybroker.com/en/latest/reference/pybroker.cache.html#pybroker.cache.enable_data_source_cache).

[Credential-related source omitted]

[Credential-related source omitted]

If you are interested in fetching cryptocurrency data, you can use [AlpacaCrypto](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.AlpacaCrypto). Here's an example of how to query hourly data for BTC/USD:

[Credential-related source omitted]

**PyBroker** also supports an [AKShare](https://github.com/akfamily/akshare) ```DataSource``` for fetching **Chinese** stock data. AKShare, a widely-used open-source package, is tailored for obtaining financial data, with a focus on the Chi

To use it, run `pip install akshare` and import the [AKShare](https://www.pybroker.com/en/latest/reference/pybroker.ext.data.html#pybroker.ext.data.AKShare) data source included in PyBroker:

**NOTE**: If the above causes a  ``Native library not available`` error and you still want to use AKShare, then [see this issue for details on how to resolve it](https://github.com/edtechre/pybroker/issues/36#issuecomment-1605910339).

If the built-in data sources do not cover your needs, **PyBroker** lets you implement your own [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource). Examples include CSV files or external AP

[In the next notebook, we'll take a look at how to use DataSources to backtest a simple trading strategy](https://www.pybroker.com/en/latest/notebooks/2.%20Backtesting%20a%20Strategy.html).

For the backtest, we will use [Yahoo Finance](https://finance.yahoo.com) as our [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource). We will also enable data caching to ensure we only downl

First, create a [StrategyConfig](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig) object to configure the `Strategy`. In this example, we set the initial cash to `500,000`:

The `Strategy` instance is now ready to download data from Yahoo Finance for the period between March 1, 2017, and March 1, 2022. To modify other settings, refer to the [StrategyConfig reference documentation](https://www.pybroker.com/en/la

The `buy_low` function receives an [ExecContext](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext) (`ctx`) containing historical data for the current ticker (AAPL or MSFT). You can access the m

To place an order, calculate the 25% portfolio allocation using [ctx.calc_target_shares](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.calc_target_shares) and assign it to [ctx.buy_shares](h

By default, buy orders fill on the following bar (`buy_delay=1`) at the [bar's midpoint price](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.PriceType.MIDDLE). You can customize this behavior using [Strat

Next, use [ctx.hold_bars](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.hold_bars) to specify the holding period. Upon liquidation, shares are sold at the [ExecContext.sell_fill_price](https

To apply these `buy_low` rules to AAPL and MSFT, use the [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) method:

(Note, you can also retrieve bar data for another symbol by calling [ExecContext#foreign](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.foreign))

To run a backtest, call the [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) method on the ```Strategy``` instance. Here is an example:

The `backtest` method returns a [TestResult](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.TestResult) object containing detailed metrics from your backtest. For instance, you can use [Matplotlib](htt

Additionally, `result.metrics_df` provides a DataFrame of metrics calculated from the backtest returns. You can find detailed explanations of these metrics in the [reference documentation](https://www.pybroker.com/en/latest/reference/pybrok

You can also filter data by specific time ranges (such as 9:30 to 10:30 AM) using the [between_time](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) argument.

Although the metrics earlier indicate that we have a profitable strategy, we may have been misled by randomness. [In the next notebook, we'll discuss how to use bootstrapping to further evaluate our trading strategies](https://www.pybroker.

[In the previous notebook](https://www.pybroker.com/en/latest/notebooks/2.%20Backtesting%20a%20Strategy.html), we implemented and backtested a trading strategy. Here is that implementation again:

As before, we create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) instance with the given configurations:

While the `total_pnl` metric above suggests a profitable strategy, these results could just be due to chance. To increase confidence in our evaluation, we can use the [bootstrap method](https://en.wikipedia.org/wiki/Bootstrapping_(statistic

**PyBroker** applies the bootstrap method to calculate [confidence intervals](https://en.wikipedia.org/wiki/Confidence_interval) for two performance metrics: the [Profit Factor](https://www.pybroker.com/en/latest/reference/pybroker.eval.htm

**PyBroker** uses the [bias-corrected and accelerated (BCa) bootstrap method](https://en.wikipedia.org/wiki/Bootstrapping_(statistics)#Bias-corrected_and_accelerated_(BCa)_bootstrap) to calculate confidence intervals for these metrics. Retu

[In the next notebook, we will discuss how to incorporate ranking long and short signals in your trading strategies](https://www.pybroker.com/en/latest/notebooks/4.%20Ranking%20Long%20and%20Short%20Signals.html).

To limit the number of long positions that can be held at any time to ```1```, we call [set_max_long_positions](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.set_max_long_positions). This eff

**PyBroker** can also rank short signals using [short_score](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.short_score), where short orders are placed for the ticker symbols with the highest

[In the next notebook, we will discuss how to implement custom indicators in PyBroker](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html).

This notebook explains how to create and integrate custom stock indicators in **PyBroker**.  Indicators in **PyBroker** are written using [NumPy](https://numpy.org/), a powerful library for numerical computing. To optimize performance, we'l

The following code shows an indicator function that calculates close prices minus a moving average (CMMA), which can be used for a [mean reversion](https://en.wikipedia.org/wiki/Mean_reversion_(finance)) strategy:

The ```cmma``` function takes two arguments: ```bar_data```, which is an instance of the [BarData](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.BarData) class that holds OHLCV data and custom fields, and

The ```vec_cmma``` function is JIT-compiled by Numba and nested inside ```cmma```. This is necessary since a Numba compiled function supports a NumPy array as an argument but not an instance of a Python class like ```BarData```. Note the co

Here, we are giving the name ```cmma_20``` to the indicator function and specifying the ```lookback``` parameter as ```20``` bars. Any arguments in the indicator function that come after ```bar_data``` will be passed as user-defined argumen

The following is an example of how to use the registered ```Indicator``` in **PyBroker** with some data downloaded from [Yahoo Finance](https://finance.yahoo.com):

As you can see, the ```Indicator``` instance is a ```Callable```. Once called, the resulting computed indicator values are returned as a [Pandas Series](https://pandas.pydata.org/docs/reference/api/pandas.Series.html).

The ```Indicator``` class also provides functions for measuring its information content. For example, you can compute the [interquartile range (IQR)](https://en.wikipedia.org/wiki/Interquartile_range):

Or compute the relative [entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)):

The indicator values are retrieved by calling [ctx.indicator](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.indicator) on the [ExecContext](https://www.pybroker.com/en/latest/reference/pybro

Here, the ```buy_cmma_cross``` function is added to the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) along with the ```cmma_20``` indicator. We can enable caching of the computed

**PyBroker** computes indicator values before the backtest runs. By default, these calculations occur serially. See [Configuring Parallelization](https://www.pybroker.com/en/latest/notebooks/11.%20Configuring%20Parallelization.html) for det

**PyBroker** provides vectorized helper functions to make the process of computing indicators easier. One of these helper functions is [highv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.highv), which calcu

The [pybroker.vect](https://www.pybroker.com/en/latest/reference/pybroker.vect.html) module also includes other vectorized helpers such as [lowv](https://www.pybroker.com/en/latest/reference/pybroker.vect.html#pybroker.vect.lowv), [sumv](ht

Additionally, **PyBroker** includes convenient wrappers for [highest](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.highest) and [lowest](https://www.pybroker.com/en/latest/reference/pybroker.indica

Use an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) to calculate multiple indicators. Add the `cmma_20` and `hhv_5` indicators to the `IndicatorSet` to compute them tog

[TA-Lib](https://github.com/TA-Lib/ta-lib-python) is a widely used technical analysis library that implements many financial indicators. You can install it with `pip install ta-lib`.

**PyBroker** also includes built-in indicators that are available in the [indicator module](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html). **PyBroker** reimplements these standard indicators with volatility normaliza

[In the next tutorial, you will learn how to train a model using custom indicators in PyBroker](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html).

In the [last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we learned how to write stock indicators in **PyBroker**. Indicators are a good starting point for developing a trading strategy. But to cr

One of the main features of **PyBroker** is the ability to train and backtest machine learning models. These models can utilize indicators as features to make more accurate predictions about market movements. Once trained, these models can 

As with [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource) and [Indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator) data, **PyBrok

In [the last notebook](https://www.pybroker.com/en/latest/notebooks/5.%20Writing%20Indicators.html), we implemented an indicator that calculates the close-minus-moving-average (CMMA) using [NumPy](https://www.numpy.org) and [Numba](https://

Next, we want to build a model that predicts the next day's return using the 20-day CMMA. Using [simple linear regression](https://en.wikipedia.org/wiki/Simple_linear_regression) is a good approach to begin experimenting with as a baseline 

Below we import a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model from [scikit-learn](https://scikit-learn.org/stable/):

After fitting the model, the function uses the testing data to evaluate the model's accuracy, specifically by computing the [R-squared](https://en.wikipedia.org/wiki/Coefficient_of_determination) score. The R-squared score provides a measur

Once the function to train the model has been defined, it needs to be registered with **PyBroker**. This is done by creating a new [ModelSource](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource)  i

To create a trading strategy that uses the trained model, create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) object using the [YFinance](https://www.pybroker.com/en/latest

The [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) method is then called on the [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#py

The last step is to run the backtest by calling the [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) method on the `Strategy` object. Set the `train_size` to `0.5` to specif

**PyBroker** employs a powerful algorithm known as [Walkforward Analysis](https://www.youtube.com/watch?v=WBZ_Vv-iMv4) to perform backtesting. The algorithm partitions the backtest data into a fixed number of time windows, each containing a

![Walkforward Diagram](https://github.com/edtechre/pybroker/blob/master/docs/_static/walkforward.gif?raw=true)

Let's consider a trading strategy that generates buy and sell signals from the [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model that we trained earlier. The strategy is i

The [ctx.preds('slr')](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) method is used to access the predictions made by the ```'slr'``` model for the current stock symbol being executed

Run the backtest by calling the [walkforward](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward) method on the `Strategy` object, passing the desired number of time windows and the tr

Beyond linear regression, **PyBroker** can train other model types such as gradient boosted machines, neural networks, or any other architecture that we choose. To help support these models, **PyBroker** offers extensive customization optio

Additionally, **PyBroker v2** now supports training [time series models](https://www.pybroker.com/en/latest/notebooks/16.%20Time%20Series%20Models.html) and [multi-symbol models](https://www.pybroker.com/en/latest/notebooks/17.%20Multi-Symb

**PyBroker** comes with pre-built [DataSources](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource) for [Yahoo Finance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFin

The following example implements a custom `CSVDataSource` to load data from a CSV file. It reads a file named `prices.csv` into a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html):

To make the custom `'rsi'` column from the CSV file available to **PyBroker**, register it using [pybroker.register_columns](https://www.pybroker.com/en/latest/reference/pybroker.scope.html#pybroker.scope.register_columns). This allows **Py

To use ```CSVDataSource``` in a backtest, we create a new [Strategy](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy) object and pass it the custom ```DataSource```:

Because we registered the custom `rsi` column with **PyBroker**, it can be accessed in the [ExecContext](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext) using `ctx.rsi`.

If you do not need the flexibility of implementing your own [DataSource](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.DataSource), you can pass a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/a

To set a custom exit price, you can use the `exit_price` fields available for each stop type. When configured, **PyBroker** checks the stop against the `exit_price` and uses that price for the exit when triggered. The following code sets [s

For more details on the attributes available for configuring stops, see the [ExecContext reference documentation](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext).

**PyBroker** allows you to simulate portfolio rebalancing by adjusting your asset allocation to match a desired target. This notebook also demonstrates how to rebalance using [portfolio optimization](https://en.wikipedia.org/wiki/Portfolio_

With the `rebalance` function complete, we can backtest our strategy using a portfolio of five stocks. To process all stocks simultaneously on each bar of data, we use the [Strategy.set_after_exec](https://www.pybroker.com/en/latest/referen

[Portfolio optimization](https://en.wikipedia.org/wiki/Portfolio_optimization) guides rebalancing to meet specific objectives, such as allocating stocks to minimize risk.

[Riskfolio-Lib](https://riskfolio-lib.readthedocs.io/) is a popular Python library for portfolio optimization. You can install it using `pip install riskfolio-lib`.

The following example demonstrates how to construct a minimum risk portfolio by minimizing the [Conditional Value at Risk (CVaR)](https://www.investopedia.com/terms/c/conditional_value_at_risk.asp) based on the past year of returns:

For more information and examples, see the [official Riskfolio-Lib documentation](https://riskfolio-lib.readthedocs.io/). Next, we backtest the strategy:

Our strategy will involve ranking and buying stocks with the highest [price rate-of-change (ROC)](https://www.investopedia.com/terms/p/pricerateofchange.asp). To start, we'll define a 20-day ROC indicator using [TA-Lib](https://github.com/T

To implement the strategy, we write a `rotate` function that sets each stock's [long_score](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.long_score) to its 20-day ROC. **PyBroker** then ran

Now that we have a method for scoring stocks by their ROC, we can use the [enable_rotation](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.enable_rotation) method to turn on rotational trading

We cap long positions at `2` with [set_max_long_positions](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.set_max_long_positions). Setting `worst_rank_held` to `5` liquidates any currently hel

**PyBroker** will allocate our capital equally between positions by default. To customize this, we can pass a ``sizer`` function to [enable_rotation](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Stra

**PyBroker** uses [Joblib](https://joblib.readthedocs.io/) to compute indicators, train models, and optimize parameters in parallel.

[set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) updates the global Joblib configuration. The [n_jobs](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pyb

Indicators are computed **per symbol**: all indicators for a given symbol are grouped into a single task, and one task is dispatched per symbol. Passing `parallel_indicators=True` to [backtest](https://www.pybroker.com/en/latest/reference/p

Standalone indicator computation with an [IndicatorSet](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.IndicatorSet) accepts the same `parallel_indicators` flag:

Model training runs serially by default. Passing `parallel_models=True` to [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) or [walkforward](https://www.pybroker.com/en/late

This example adapts the linear regression model from [Training a Model](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html):

[Ray](https://www.ray.io/) can distribute the same work across many cores or an entire cluster. Install it with `pip install ray` and then register it with Joblib via [register_ray](https://docs.ray.io/en/latest/ray-more-libs/joblib.html) (

After registering Ray, pass `backend="ray"` to [set_parallel](https://www.pybroker.com/en/latest/reference/pybroker.parallel.html#pybroker.parallel.set_parallel) to make it available as a backend:

**PyBroker** will now use the Ray backend for all parallel tasks. For example, calling [backtest](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.backtest) with `parallel_indicators=True`:

We will explore [parameter optimization](https://www.pybroker.com/en/latest/notebooks/12.%20Parameter%20Optimization.html) in the next notebook, which can also be parallelized in certain scenarios.

**PyBroker v2** supports parameterized strategies. This allows you to backtest strategies using different combinations of parameters and automatically select the best performers. This process is known as **parameter optimization** and is ha

A hyperparameter is a named, tunable value created with [hyperparam](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.hyperparam). Each one has a [default](https://www.pybroker.com/en/latest/reference/py

- **Indicators**: pass it as a keyword argument to [indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.indicator).

- **Executions**: attach it with `hyperparams=` on [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution) and read it with [ctx.hyperparam](https://www.pybroker.com/en/l

The [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.optimize) method splits the data into train and test windows as specified by `train_size` (`0.5` for 50/50 by default). As Optuna 

[best_params](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.best_params) holds the best in-sample values, and [best_score](https://www.pybroker.com/en/latest/reference/pybroker.optimize

Using the optimized parameters, we're able to see an improvment to the total return from before. The [result](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.result) attribute contains th

Grid search grows multiplicatively with each added hyperparameter. An alternative approach is using `sampler="tpe"`. Optuna's [TPESampler](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.TPESampler.html)

`sampler="random"` chooses combinations uniformly at random with Optuna's [RandomSampler](https://optuna.readthedocs.io/en/stable/reference/samplers/generated/optuna.samplers.RandomSampler.html). Like grid, random trials can be evaluated in

Any [optuna.samplers.BaseSampler](https://optuna.readthedocs.io/en/stable/reference/samplers/index.html) instance can also be passed directly to [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strateg

Every optimization also returns the underlying [optuna.Study](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html) for inspecting the trials:

Finally, [optimize](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.optimize) supports walkforward optimization. If you pass `> 1` to the `windows` parameter, PyBroker will independently tune t

Each window is tuned separately, so the best parameters can differ between windows. The combined result contains the [best_params](https://www.pybroker.com/en/latest/reference/pybroker.optimize.html#pybroker.optimize.OptimizeResult.best_par

Until now, our backtests have been limited to cash-only trades. This notebook explores the margin trading features in **PyBroker v2**. We'll use [StrategyConfig](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.con

Margin is enabled with the [leverage](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.leverage) config option, which multiplies buying power for both long and short positions.

Position sizing is where leverage comes into play. The [ctx.calc_target_shares](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.calc_target_shares) method sizes orders as a fraction of your de

[result.portfolio](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.TestResult.portfolio) records the margin balances on every bar. When a levered position is opened, a portion of cash (`entry cost / lev

The [margin](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.PortfolioBar.margin) column is separate and tracks the current value of open short positions, so it stays at zero when the strategy is long

On the first of these filtered bars, a single entry filled. Cash dropped by `$25,413` to post half of the entry cost as collateral, while the `margin_loan` column records the borrowed remainder. While the collateral and margin loan are fixe

To see the effect of leverage on our strategy, we rerun the strategy with a cash only [leverage](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.leverage) of `1.0`. We also disable PyBroker's

Leverage more than doubled the return (and nearly doubled the max drawdown), but borrowing is not free. You can simulate this financing cost using the [interest_rate](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroke

Looking at the tail of the portfolio, `cash` will stay zero. Meanwhile, the accrued interest is added to the [margin_loan](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.PortfolioBar.margin_loan) and

To demonstrate this, we will short symbols trading below their moving average. We will also enable [record_position_bars](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.record_position_bars)

For open short positions, the [margin](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.PortfolioBar.margin) column tracks their current notional exposure, which can exceed your total equity when using

When you open a short, collateral equal to `entry cost / leverage` is held from your cash, and the [margin_loan](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.PortfolioBar.margin_loan) column record

Your [net_cash_balance](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.PortfolioBar.net_cash_balance) equals your remaining cash minus this margin loan, turning negative if the loan exceeds your avai

Because we enabled [record_position_bars](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.record_position_bars), [result.positions](https://www.pybroker.com/en/latest/reference/pybroker.strat

This notebook demonstrates **PyBroker's** three built-in slippage models added in v2. It also introduces the [SlippageModel](https://www.pybroker.com/en/latest/reference/pybroker.slippage.html#pybroker.slippage.SlippageModel) base class, wh

To see the effect of each model, we reuse the dip-buying strategy from [Backtesting a Strategy](https://www.pybroker.com/en/latest/notebooks/2.%20Backtesting%20a%20Strategy.html). The rule is simple: buy when the latest close drops below th

Now, we run the baseline backtest with no slippage. Every order fills at the the midpoint between the bar's low and high prices ([PriceType.MIDDLE](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.PriceType.

The [FixedSlippageModel](https://www.pybroker.com/en/latest/reference/pybroker.slippage.html#pybroker.slippage.FixedSlippageModel) applies a fixed, adverse price adjustment measured in basis points (where 1 basis point equals 0.01%). Buy pr

Because the remaining examples run several more backtests, we will also disable logging with [disable_logging](https://www.pybroker.com/en/latest/reference/pybroker.scope.html#pybroker.scope.disable_logging) to keep the output short. Next, 

Because slippage tends to grow as volatility rises, the [VolatilitySlippageModel](https://www.pybroker.com/en/latest/reference/pybroker.slippage.html#pybroker.slippage.VolatilitySlippageModel) ties its adverse price adjustment directly to m

The [VolumeSlippageModel](https://www.pybroker.com/en/latest/reference/pybroker.slippage.html#pybroker.slippage.VolumeSlippageModel) accounts for limited market liquidity by applying two mechanics:

To create your own model, subclass [SlippageModel](https://www.pybroker.com/en/latest/reference/pybroker.slippage.html#pybroker.slippage.SlippageModel) and override the [apply_slippage](https://www.pybroker.com/en/latest/reference/pybroker.

Your chosen interval must always be longer than the bars being compressed. For example, if you fetch daily bars from [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance), then `"weekly"` and `"m

The [compress_bars](https://www.pybroker.com/en/latest/reference/pybroker.interval.html#pybroker.interval.compress_bars) function converts OHLCV data (either a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame

*   **Volume:** The sum of the volumes. *   **VWAP:** The volume-weighted average. *   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance

*   **Custom columns:** The last value in the period (e.g., [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance)'s `adj_close`).

Let's compress AMD into calendar weeks and view the result as a [Pandas DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) with [bars_to_df](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybro

To use higher timeframes in your backtest, pass the `intervals` parameter to [add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution). Your execution function can then acc

To prevent look-ahead bias, [ctx.interval](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.interval) only ever exposes *completed* bars. For example, the week or month that is currently formin

To compute an indicator on compressed bars, bind it to one or more intervals with [Indicator.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.Indicator.intervals).

**PyBroker** automatically combines bound intervals with those in the execution's `intervals` parameter. Here, the `"weekly"` interval is made accessible via [ctx.interval("weekly")](https://www.pybroker.com/en/latest/reference/pybroker.con

Note that the binding will override also computing the indicator on the base timeframe of the data source. To also compute the indicator on the base timeframe of the data source, pass `"base"` to [Indicator.intervals()](https://www.pybroker

You can bind models in the same way with [ModelSource.intervals(...)](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.ModelSource.intervals). **PyBroker** will then train models for each interval using the in

This example trains a [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model to predict the next weekly return from the weekly close:

During [Walkforward Analysis](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward), the `lookahead` between an interval model's train and test data is enforced using the compressed bar 

To show how this works, we will backtest two different strategies. The first relies on a volatility forecast from a [GARCH(1,1)](https://en.wikipedia.org/wiki/Autoregressive_conditional_heteroskedasticity) model built with the [arch](https:

GARCH will model the volatility of a return series, so we start by defining an [indicator](https://www.pybroker.com/en/latest/reference/pybroker.indicator.html#pybroker.indicator.indicator) for log returns:

By default, **PyBroker** passes all test window data to the model in a single call to make a make a prediction. While this vectorized approach is efficient, it fails for autoregressive models since they rely on the previous step's output to

The strategy then uses the volatility forecast from [ctx.preds](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) as a regime filter. It enters a long position when forecast volatility is

The second strategy trains a [RandomForestRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html) to predict the next bar's return from lagged returns:

The training function receives `lag_train` and `lag_test` parameters built from configuring the model with the desired number of [lags](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.model). Each parameter i

Registering the model with [lags](https://www.pybroker.com/en/latest/reference/pybroker.model.html#pybroker.model.model) set to `3` will include the past three lagged values for each column declared in [lag_cols](https://www.pybroker.com/en

The strategy buys when [ctx.preds](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.preds) for the next-bar return is positive and exits when it is negative. We then run a [walkforward](https:/

**PyBroker v2** supports training one model across all symbols passed to [Strategy.add_execution](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.add_execution), as shown in this notebook.

This notebook repurposes the linear regression example from [Training a Model](https://www.pybroker.com/en/latest/notebooks/6.%20Training%20a%20Model.html). Below, one shared [LinearRegression](https://scikit-learn.org/stable/modules/genera

**PyBroker v2** now enables dynamic symbol selection with [SymbolSelector](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.SymbolSelector).

Below, data is downloaded for twenty liquid large-caps from [YFinance](https://www.pybroker.com/en/latest/reference/pybroker.data.html#pybroker.data.YFinance):

Dynamic symbol selection is handled using a [SymbolSelector](https://www.pybroker.com/en/latest/reference/pybroker.common.html#pybroker.common.SymbolSelector), which can be any callable that takes a [Pandas DataFrame](https://pandas.pydata.

For each [walkforward](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.walkforward) window, the `top_dollar_volume` selector runs on the train split and selects the top three stocks to trade du

Use [ctx.foreign](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.foreign) and pass a symbol to [ctx.indicator](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.cont

You can also retrieve models, predictions, and other data for other symbols. [For more information, refer to the ExecContext reference documentation.](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecC

Set [buy_limit_price](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.buy_limit_price) or [sell_limit_price](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context

Set [buy_fill_price](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.buy_fill_price) and [sell_fill_price](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.E

Use [positions](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.positions), [long_positions](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.lon

[See the Position class for more information.](https://www.pybroker.com/en/latest/reference/pybroker.portfolio.html#pybroker.portfolio.Position)

Register your custom columns with [pybroker.register_columns](https://www.pybroker.com/en/latest/reference/pybroker.scope.html#pybroker.scope.register_columns):

Use the [buy_delay](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.buy_delay) and [sell_delay](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfi

See the [cancel_pending_order](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.cancel_pending_order) and [cancel_all_pending_orders](https://www.pybroker.com/en/latest/reference/pybroker.conte

Use the [ctx.session](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.session) dictionary:

Use [sell_all_shares](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.sell_all_shares) or [cover_all_shares](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context

Use [set_before_exec](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.Strategy.set_before_exec) or [set_after_exec](https://www.pybroker.com/en/latest/reference/pybroker.strategy.html#pybroker.strategy.

Set the [bars_per_year](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.bars_per_year) configuration option. For example, setting a value of ``252`` would be used to annualize daily returns.

Use [param](https://www.pybroker.com/en/latest/reference/pybroker.scope.html#pybroker.scope.param) for global values shared across a session. For tunable strategy parameters used with [optimize](https://www.pybroker.com/en/latest/reference/

[set_target_shares](https://www.pybroker.com/en/latest/reference/pybroker.context.html#pybroker.context.ExecContext.set_target_shares) will buy and sell enough shares to approximate a target allocation:

Set [record_position_bars](https://www.pybroker.com/en/latest/reference/pybroker.config.html#pybroker.config.StrategyConfig.record_position_bars) to capture per-bar position snapshots in [result.positions](https://www.pybroker.com/en/latest