Zipline

https://zipline.ml4trading.io
Admin
Zipline is a Pythonic event-driven backtesting system for developing and testing trading algorithms...
Tokens:302,476
Snippets:2,417
Trust Score:7.4
Update:5 months ago
Show doc for...
Tokens:
Raw
### Configure and Install TA-Lib (Linux)

Source: https://zipline.ml4trading.io/development-guidelines.html

Configure and install TA-Lib after downloading the source. This involves running configure, make, and make install.

```bash
cd ta-lib/
./configure --prefix=/usr
make
sudo make install

```

--------------------------------

### Import Zipline Example Algorithm

Source: https://zipline.ml4trading.io/_sources/beginner-tutorial.rst.txt

Imports a pre-built example algorithm named 'buyapple' from the zipline.examples module.

```python
from zipline.examples import buyapple
```

--------------------------------

### Run a Trading Algorithm with Yahoo Finance Data

Source: https://zipline.ml4trading.io/releases.html

This example demonstrates how to set up and run a basic trading algorithm using Zipline, loading historical data from Yahoo Finance. Ensure you have pylab installed for plotting.

```python
from datetime import datetime
import pytz
from zipline import TradingAlgorithm
from zipline.utils.factory import load_from_yahoo

from zipline.api import order

def initialize(context):
    context.test = 10

def handle_date(context, data):
    order('AAPL', 10)
    print(context.test)

if __name__ == '__main__':
    import pylab as pl
    start = datetime(2008, 1, 1, 0, 0, 0, 0, pytz.utc)
    end = datetime(2010, 1, 1, 0, 0, 0, 0, pytz.utc)
    data = load_from_yahoo(
        stocks=['AAPL'],
        indexes={},
        start=start,
        end=end)
    data = data.dropna()
    algo = TradingAlgorithm(
        initialize=initialize,
        handle_data=handle_date)
    results = algo.run(data)
    results.portfolio_value.plot()
    pl.show()
```

--------------------------------

### Initialize Benchmark Series (Daily Emission, Asset Starts Same Day)

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Fetches and calculates daily benchmark returns when the benchmark asset started trading on the same day as the simulation. It uses the open-to-close return for the first day and subsequent daily percentage changes.

```python
        elif start_date == trading_days[0]:
            # Attempt to handle case where stock data starts on first
            # day, in this case use the open to close return.
            benchmark_series = data_portal.get_history_window(
                [asset],
                trading_days[-1],
                bar_count=len(trading_days),
                frequency="1d",
                field="price",
                data_frequency=self.emission_rate,
                ffill=True,
            )[asset]

            # get a minute history window of the first day
            first_open = data_portal.get_spot_value(
                asset,
                "open",
                trading_days[0],
                "daily",
            )
            first_close = data_portal.get_spot_value(
                asset,
                "close",
                trading_days[0],
                "daily",
            )

            first_day_return = (first_close - first_open) / first_open

            returns = benchmark_series.pct_change()[:]
            returns[0] = first_day_return
            return returns, returns
```

--------------------------------

### Initialize Benchmark Series (Daily Emission, Asset Starts Before Simulation)

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Fetches and calculates daily benchmark returns when the benchmark asset started trading before the simulation. It retrieves a history window of daily prices and computes percentage changes.

```python
        start_date = asset.start_date
        if start_date < trading_days[0]:
            # get the window of close prices for benchmark_asset from the
            # last trading day of the simulation, going up to one day
            # before the simulation start day (so that we can get the %
            # change on day 1)
            benchmark_series = data_portal.get_history_window(
                [asset],
                trading_days[-1],
                bar_count=len(trading_days) + 1,
                frequency="1d",
                field="price",
                data_frequency=self.emission_rate,
                ffill=True,
            )[asset]

            returns = benchmark_series.pct_change()[1:]
            return returns, returns
```

--------------------------------

### Install Fedora/RHEL Dependencies

Source: https://zipline.ml4trading.io/install.html

Installs necessary binary dependencies for Zipline on RHEL-derived Linux distributions using dnf.

```bash
$ sudo dnf install atlas-devel gcc-c++ gcc-gfortran libgfortran python-devel redhat-rpm-config hdf5

```

--------------------------------

### Install Arch Linux Dependencies

Source: https://zipline.ml4trading.io/install.html

Installs necessary binary dependencies for Zipline on Arch Linux using pacman.

```bash
$ pacman -S lapack gcc gcc-fortran pkg-config hdf5

```

--------------------------------

### Install Zipline using pip

Source: https://zipline.ml4trading.io/index.html

Install the zipline-reloaded package using pip. Ensure system prerequisites are met.

```bash
pip install zipline-reloaded

```

--------------------------------

### Install TA-Lib on Linux

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Install the TA-Lib C library on Linux systems, a dependency for running tests.

```bash
wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz
tar -xvzf ta-lib-0.4.0-src.tar.gz
cd ta-lib/
./configure --prefix=/usr
make
sudo make install
```

--------------------------------

### Install Debian/Ubuntu Dependencies

Source: https://zipline.ml4trading.io/install.html

Installs necessary binary dependencies for Zipline on Debian-derived Linux distributions using apt.

```bash
$ sudo apt install libatlas-base-dev python-dev gfortran pkg-config libfreetype6-dev hdf5-tools

```

--------------------------------

### Install TA-Lib on OS X

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Install the TA-Lib C library on OS X using Homebrew.

```bash
$ brew install ta-lib
```

--------------------------------

### Install Zipline using pip

Source: https://zipline.ml4trading.io/install.html

Use this command to install the Zipline package after ensuring all system dependencies are met.

```bash
$ pip install zipline-reloaded

```

--------------------------------

### CachedObject Example

Source: https://zipline.ml4trading.io/_modules/zipline/utils/cache.html

Demonstrates the creation and usage of CachedObject, including checking for expiration.

```python
>>> from pandas import Timestamp, Timedelta
>>> expires = Timestamp('2014', tz='UTC')
>>> obj = CachedObject(1, expires)
>>> obj.unwrap(expires - Timedelta('1 minute'))
1
>>> obj.unwrap(expires)
1
>>> obj.unwrap(expires + Timedelta('1 minute'))
... # doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
    ...
Expired: 2014-01-01 00:00:00+00:00
```

--------------------------------

### Install Zipline with Test Dependencies

Source: https://zipline.ml4trading.io/development-guidelines.html

Install Zipline in editable mode with test dependencies. This allows you to make changes and have them reflected immediately.

```bash
pip install -e .[test]

```

--------------------------------

### Check Zipline Help

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Verify the Zipline installation by checking the command-line interface help.

```bash
$ zipline --help
```

--------------------------------

### Install Python 3 on Arch Linux

Source: https://zipline.ml4trading.io/install.html

Installs Python 3 using pacman on Arch Linux, which may be required for Zipline.

```bash
$ pacman -S python3

```

--------------------------------

### Install Zipline in Editable Mode

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Install Zipline in editable mode with test dependencies after activating your virtual environment.

```bash
pip install -e .[test]
```

--------------------------------

### Initialize BcolzDailyBarWriter

Source: https://zipline.ml4trading.io/_modules/zipline/data/bcolz_daily_bars.html

Initializes the writer with a filename, calendar, and session range. Ensures start and end sessions are valid trading days.

```python
class BcolzDailyBarWriter:
    """Class capable of writing daily OHLCV data to disk in a format that can
    be read efficiently by BcolzDailyOHLCVReader.

    Parameters
    ----------
    filename : str
        The location at which we should write our output.
    calendar : zipline.utils.calendar.trading_calendar
        Calendar to use to compute asset calendar offsets.
    start_session: pd.Timestamp
        Midnight UTC session label.
    end_session: pd.Timestamp
        Midnight UTC session label.

    See Also
    --------
    zipline.data.bcolz_daily_bars.BcolzDailyBarReader
    """

    _csv_dtypes = {
        "open": float64_dtype,
        "high": float64_dtype,
        "low": float64_dtype,
        "close": float64_dtype,
        "volume": float64_dtype,
    }

    def __init__(self, filename, calendar, start_session, end_session):
        self._filename = filename
        start_session = start_session.tz_localize(None)
        end_session = end_session.tz_localize(None)

        if start_session != end_session:
            if not calendar.is_session(start_session):
                raise ValueError("Start session %s is invalid!" % start_session)
            if not calendar.is_session(end_session):
                raise ValueError("End session %s is invalid!" % end_session)

        self._start_session = start_session
        self._end_session = end_session

        self._calendar = calendar
```

--------------------------------

### Get Trading Days for Window

Source: https://zipline.ml4trading.io/_modules/zipline/data/data_portal.html

Calculates the trading days for a historical window. Raises an error if the requested window starts before the available data.

```python
@remember_last
def _get_days_for_window(self, end_date, bar_count):
        tds = self.trading_calendar.sessions
        end_loc = tds.get_loc(end_date)
        start_loc = end_loc - bar_count + 1
        if start_loc < self._first_trading_day_loc:
            raise HistoryWindowStartsBeforeData(
                first_trading_day=self._first_trading_day.date(),
                bar_count=bar_count,
                suggested_start_day=tds[self._first_trading_day_loc + bar_count].date(),
            )
        return tds[start_loc : end_loc + 1]
```

--------------------------------

### Get Daily Benchmark Returns

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Retrieve daily benchmark returns for a given period. If only a start date is provided, returns the scalar value for that day.

```python
def daily_returns(self, start, end=None):
        """Returns the daily returns for the given period.

        Parameters
        ----------
        start : datetime
            The inclusive starting session label.
        end : datetime, optional
            The inclusive ending session label. If not provided, treat
            ``start`` as a scalar key.

        Returns
        -------
        returns : pd.Series or float
            The returns in the given period. The index will be the trading
            calendar in the range [start, end]. If just ``start`` is provided,
            return the scalar value on that day.
        """
        if end is None:
            return self._daily_returns[start]

        return self._daily_returns[start:end]
```

--------------------------------

### Get Contract SIDs for Root Symbol

Source: https://zipline.ml4trading.io/_modules/zipline/assets/assets.html

Retrieves a list of contract SIDs for a given root symbol from the futures_contracts table. Filters for non-null start dates and orders by SID.

```python
def _get_contract_sids(self, root_symbol):
        fc_cols = self.futures_contracts.c
        with self.engine.connect() as conn:
            return (
                conn.execute(
                    sa.select(
                        fc_cols.sid,
                    )
                    .where(
                        (fc_cols.root_symbol == root_symbol)
                        & (fc_cols.start_date != pd.NaT.value)
                    )
                    .order_by(fc_cols.sid)
                )
                .scalars()
                .fetchall()
            )
```

--------------------------------

### Get Environment Information

Source: https://zipline.ml4trading.io/releases.html

Retrieve information about the current Zipline environment. By default, it returns 'zipline', but specific fields like 'arena', 'data_frequency', 'start', 'end', 'capital_base', or 'platform' can be requested.

```python
get_environment()
```

```python
get_environment('arena')
```

--------------------------------

### Initialize working_dir Context Manager

Source: https://zipline.ml4trading.io/_modules/zipline/utils/cache.html

Sets up a context manager for a temporary directory that will be moved to a final destination upon successful exit.

```python
def __init__(self, final_path, *args, **kwargs):
    self._tmpdir = mkdtemp(*args, **kwargs)
    self._final_path = final_path
```

--------------------------------

### Initialize EquityPricingLoader

Source: https://zipline.ml4trading.io/_modules/zipline/pipeline/loaders/equity_pricing_loader.html

Constructs an EquityPricingLoader with specified readers for raw prices, adjustments, and FX rates.

```python
from zipline.data.fx import ExplodingFXRateReader


class EquityPricingLoader(implements(PipelineLoader)):
    """A PipelineLoader for loading daily OHLCV data.

    Parameters
    ----------
    raw_price_reader : zipline.data.session_bars.SessionBarReader
        Reader providing raw prices.
    adjustments_reader : zipline.data.adjustments.SQLiteAdjustmentReader
        Reader providing price/volume adjustments.
    fx_reader : zipline.data.fx.FXRateReader
       Reader providing currency conversions.
    """


    def __init__(self, raw_price_reader, adjustments_reader, fx_reader):
        self.raw_price_reader = raw_price_reader
        self.adjustments_reader = adjustments_reader
        self.fx_reader = fx_reader
```

--------------------------------

### Initialize Benchmark Series (Minute Emission)

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Fetches and calculates minute-level benchmark returns when the simulation's emission rate is set to 'minute'. It retrieves a history window of minute prices and computes percentage changes.

```python
        if self.emission_rate == "minute":
            minutes = trading_calendar.sessions_minutes(
                self.sessions[0], self.sessions[-1]
            )
            benchmark_series = data_portal.get_history_window(
                [asset],
                minutes[-1],
                bar_count=len(minutes) + 1,
                frequency="1m",
                field="price",
                data_frequency=self.emission_rate,
                ffill=True,
            )[asset]

            return (
                benchmark_series.pct_change()[1:],
                self.downsample_minute_return_series(
                    trading_calendar,
                    benchmark_series,
                ),
            )
```

--------------------------------

### Install TA-Lib Python Package

Source: https://zipline.ml4trading.io/development-guidelines.html

Install the TA-Lib Python package after the C library is installed. This makes TA-Lib functions available in Python.

```bash
pip install TA-lib

```

--------------------------------

### Build and View Docs Locally

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Build the Zipline documentation locally using Sphinx and view it in a browser. Assumes you are in the Zipline root directory.

```bash
# assuming you're in the Zipline root directory
$ cd docs
$ make html
$ {BROWSER} build/html/index.html
```

--------------------------------

### Handle Invalid Benchmark Asset Start Date

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Raises a ValueError if the benchmark asset's start date is after the simulation start date, indicating it cannot be used for the simulation period.

```python
        else:
            raise ValueError(
                "cannot set benchmark to asset that does not exist during"
                " the simulation period (asset start date=%r)" % start_date
            )
```

--------------------------------

### SimplePipelineEngine Initialization

Source: https://zipline.ml4trading.io/api-reference.html

Initializes the SimplePipelineEngine.

```APIDOC
## SimplePipelineEngine Initialization

### Description
Initializes the SimplePipelineEngine.

### Method
- `SimplePipelineEngine.__init__(...)`
```

--------------------------------

### StartOfPeriodLedgerField

Source: https://zipline.ml4trading.io/_modules/zipline/finance/metrics/metric.html

Tracks the value of a ledger field at the start of the simulation and the start of each session.

```APIDOC
## StartOfPeriodLedgerField

### Description
Keep track of the value of a ledger field at the start of the period.

### Parameters
* `ledger_field` (str): The ledger field to read.
* `packet_field` (str, optional): The name of the field to populate in the packet. If not provided, `ledger_field` will be used.

### Methods
* `start_of_simulation(ledger, emission_rate, trading_calendar, sessions, benchmark_source)`: Stores the ledger field value at the start of the simulation.
* `start_of_session(ledger, session, data_portal)`: Stores the ledger field value at the start of each session.
* `end_of_bar(packet, ledger, dt, session_ix, data_portal)`: Updates the packet with the start-of-period values at the end of each bar.
* `end_of_session(packet, ledger, session, session_ix, data_portal)`: Updates the packet with the start-of-period values at the end of each session.
```

--------------------------------

### Create and Activate Virtual Environment (virtualenvwrapper)

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Create and activate a virtual environment using virtualenvwrapper.

```bash
$ mkvirtualenv zipline
```

--------------------------------

### Install Zipline with Conda

Source: https://zipline.ml4trading.io/install.html

Install the Zipline-reloaded package from the ml4t channel within your activated conda environment.

```bash
(env_zipline) $ conda install -c ml4t zipline-reloaded
```

--------------------------------

### Build and View Local Documentation

Source: https://zipline.ml4trading.io/development-guidelines.html

Build the Zipline documentation locally using Sphinx and open it in your browser. This allows you to preview changes to the docs.

```bash
# assuming you're in the Zipline root directory
cd docs
make html
{BROWSER} build/html/index.html

```

--------------------------------

### Install Zipline with Conda

Source: https://zipline.ml4trading.io/releases.html

Use this command to install Zipline using Conda, which is an alternative to local compilation with pip.

```bash
conda install -c quantopian zipline

```

--------------------------------

### Create and Checkout Development Branch

Source: https://zipline.ml4trading.io/development-guidelines.html

Navigate into the cloned directory and create a new branch for your changes. Use a descriptive name for the branch.

```bash
cd zipline-reloaded
git checkout -b some-short-descriptive-name

```

--------------------------------

### EquityPricingLoader Initialization

Source: https://zipline.ml4trading.io/api-reference.html

Initializes the EquityPricingLoader.

```APIDOC
## EquityPricingLoader Initialization

### Description
Initializes the EquityPricingLoader.

### Method
- `EquityPricingLoader.__init__()`
```

--------------------------------

### Running Algorithms via CLI

Source: https://zipline.ml4trading.io/releases.html

This section details how to run Zipline algorithms directly from the command line, including specifying the algorithm file, symbols, date range, and output file.

```APIDOC
## Running Algorithms via CLI

### Description
This command-line interface allows you to execute Zipline algorithms. You can specify the algorithm file, trading symbols, start and end dates for the backtest, and an output file for the performance data.

### Usage
```bash
python run_algo.py -f <algorithm_file.py> --symbols <symbol1,symbol2,...> --start <YYYY-MM-DD> --end <YYYY-MM-DD> -o <output.pickle>
```

### Example
```bash
python run_algo.py -f dual_moving_avg.py --symbols AAPL --start 2011-1-1 --end 2012-1-1 -o dma.pickle
```

### Notes
- If a file named `<algorithm_file_name>_analyze.py` exists, it will be executed after the main algorithm.
- The performance DataFrame will be saved to the specified output file.
```

--------------------------------

### Use `working_dir` Context Manager

Source: https://zipline.ml4trading.io/api-reference.html

Demonstrates using `working_dir` to manage a temporary directory that is moved to a final destination upon successful completion of the context.

```python
>>> from zipline.utils.cache import working_dir
>>> with working_dir('final/path/to/directory') as d:
...     # Perform operations within the temporary directory
...     pass
... 

```

--------------------------------

### Verify Zipline CLI Installation

Source: https://zipline.ml4trading.io/development-guidelines.html

After installation, check if the `zipline` command-line interface is accessible within your activated virtual environment.

```bash
zipline --help

```

--------------------------------

### Run Zipline Algorithm in IDE

Source: https://zipline.ml4trading.io/_sources/beginner-tutorial.rst.txt

Execute a Zipline algorithm from your IDE by calling `run_algorithm`. This example shows how to fetch benchmark data and pass it to the function.

```python
from zipline import run_algorithm
import pandas as pd
import pandas_datareader.data as web

def initialize(context):
    ...

def handle_data(context, data):
    ...

start = pd.Timestamp('2014')
end = pd.Timestamp('2018')

sp500 = web.DataReader('SP500', 'fred', start, end).SP500
benchmark_returns = sp500.pct_change()

result = run_algorithm(start=start.tz_localize('UTC'),
                       end=end.tz_localize('UTC'),
                       initialize=initialize,
                       handle_data=handle_data,
                       capital_base=100000,
                       benchmark_returns=benchmark_returns,
                       bundle='quandl',
                       data_frequency='daily')
```

--------------------------------

### Activate Conda Environment

Source: https://zipline.ml4trading.io/install.html

Activate the newly created conda environment before installing Zipline. This ensures Zipline is installed in the isolated environment.

```bash
$ conda activate env_zipline
```

--------------------------------

### Initialize BenchmarkSource with Benchmark Asset

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Initialize BenchmarkSource with a benchmark asset, trading calendar, sessions, and data portal. This is used when benchmark returns are not pre-calculated.

```python
if len(sessions) == 0:
            self._precalculated_series = pd.Series()
elif benchmark_asset is not None:
            self._validate_benchmark(benchmark_asset)
            (
                self._precalculated_series,
                self._daily_returns,
            ) = self._initialize_precalculated_series(
                benchmark_asset, trading_calendar, sessions, data_portal
            )
elif benchmark_returns is not None:
            self._daily_returns = daily_series = benchmark_returns.reindex(
                sessions,
            ).fillna(0)

            if self.emission_rate == "minute":
                # we need to take the env's benchmark returns, which are daily,
                # and resample them to minute
                minutes = trading_calendar.sessions_minutes(sessions[0], sessions[-1])
                minute_series = daily_series.tz_localize(minutes.tzinfo).reindex(
                    index=minutes, method="ffill"
                )

                self._precalculated_series = minute_series
            else:
                self._precalculated_series = daily_series
else:
            raise Exception(
                "Must provide either benchmark_asset or " "benchmark_returns."
            )
```

--------------------------------

### Metric `start_of_simulation` Signature

Source: https://zipline.ml4trading.io/risk-and-perf-metrics.html

Implement the `start_of_simulation` method to initialize caches for a single simulation. This method is called once per simulation.

```python
def start_of_simulation(self,
                        ledger,
                        emission_rate,
                        trading_calendar,
                        sessions,
                        benchmark_source):
    ...

```

--------------------------------

### Install Zipline using conda

Source: https://zipline.ml4trading.io/index.html

Install the zipline-reloaded package from the conda-forge channel using conda. Consider using mamba for conflict resolution.

```bash
conda install -c conda-forge zipline-reloaded

```

--------------------------------

### PNL Metric Start of Session Update

Source: https://zipline.ml4trading.io/_modules/zipline/finance/metrics/metric.html

Updates the previous PNL value at the start of each session. This is used to calculate the PNL change for the session.

```python
    def start_of_session(self, ledger, session, data_portal):
        self._previous_pnl = ledger.portfolio.pnl
```

--------------------------------

### Install macOS Dependencies with Homebrew

Source: https://zipline.ml4trading.io/install.html

Installs essential packages like freetype, pkg-config, gcc, openssl, hdf5, and ta-lib using Homebrew on macOS.

```bash
$ brew install freetype pkg-config gcc openssl hdf5 ta-lib

```

--------------------------------

### Define a Custom Pipeline Dataset

Source: https://zipline.ml4trading.io/_modules/zipline/pipeline/data/dataset.html

Example of defining a custom dataset by subclassing `DataSet`. This example shows how to define columns like 'open' with their respective data types.

```python
class EquityPricing(DataSet):
    open = Column(float)
```

--------------------------------

### Create and Activate Virtual Environment (virtualenvwrapper)

Source: https://zipline.ml4trading.io/development-guidelines.html

Alternatively, use virtualenvwrapper to create and activate a virtual environment named 'zipline'.

```bash
mkvirtualenv zipline

```

--------------------------------

### AssetDBWriter.init_db

Source: https://zipline.ml4trading.io/api-reference.html

Connects to the database and creates tables for asset metadata.

```APIDOC
## init_db

### Description
Connect to database and create tables.

### Parameters
* **txn** (sa.engine.Connection, optional) - The transaction block to execute in. If this is not provided, a new transaction will be started with the engine provided.

### Returns
* **metadata** - The metadata that describes the new assets db.

### Return type
sa.MetaData
```

--------------------------------

### Validate Benchmark Asset Start Date

Source: https://zipline.ml4trading.io/_modules/zipline/sources/benchmark_source.html

Checks if the benchmark asset's start date is before the first simulation session. Raises BenchmarkAssetNotAvailableTooEarly if the asset is not available early enough.

```python
if benchmark_asset.start_date > self.sessions[0]:
            # the asset started trading after the first simulation day
            raise BenchmarkAssetNotAvailableTooEarly(
                sid=str(self.benchmark_asset),
                dt=self.sessions[0],
                start_dt=benchmark_asset.start_date,
            )
```

--------------------------------

### Example Commit Message

Source: https://zipline.ml4trading.io/development-guidelines.html

An example of a well-formatted commit message following Zipline's guidelines. It includes a prefix, a concise subject, and a detailed body explaining the change and its rationale.

```text
MAINT: Remove unused calculations of max_leverage, et al.

In the performance period the max_leverage, max_capital_used,
cumulative_capital_used were calculated but not used.

At least one of those calculations, max_leverage, was causing a
divide by zero error.

Instead of papering over that error, the entire calculation was
a bit suspect so removing, with possibility of adding it back in
later with handling the case (or raising appropriate errors) when
the algorithm has little cash on hand.


```

--------------------------------

### Start of Session Logic

Source: https://zipline.ml4trading.io/_modules/zipline/finance/ledger.html

Resets transaction and order caches at the start of a new session. It also saves the previous day's total returns to ensure accurate calculation of `todays_returns`.

```python
def start_of_session(self, session_label):
        self._processed_transactions.clear()
        self._orders_by_modified.clear()
        self._orders_by_id.clear()

        # Save the previous day's total returns so that ``todays_returns``
        # produces returns since yesterday. This does not happen in
        # ``end_of_session`` because we want ``todays_returns`` to produce the
        # correct value in metric ``end_of_session`` handlers.
        self._previous_total_returns = self.portfolio.returns

```

--------------------------------

### Initialize a Cache Instance

Source: https://zipline.ml4trading.io/_modules/zipline/utils/cache.html

Instantiate a Cache object, specifying the directory path, serialization method, and cleanup behavior on failure. Defaults to using pickle serialization and cleaning up on failure.

```python
cache = Cache(path="/tmp/mycache", serialization="msgpack", clean_on_failure=False)
```

--------------------------------

### StartOfPeriodLedgerField: Track Ledger Value at Period Start

Source: https://zipline.ml4trading.io/_modules/zipline/finance/metrics/metric.html

Records the value of a ledger field at the start of the simulation and subsequent sessions. This value is then used in 'cumulative_perf', 'minute_perf', and 'daily_perf' at the end of each period.

```python
class StartOfPeriodLedgerField:
    """Keep track of the value of a ledger field at the start of the period.

    Parameters
    ----------
    ledger_field : str
        The ledger field to read.
    packet_field : str, optional
        The name of the field to populate in the packet. If not provided,
        ``ledger_field`` will be used.
    """

    def __init__(self, ledger_field, packet_field=None):
        self._get_ledger_field = op.attrgetter(ledger_field)
        if packet_field is None:
            self._packet_field = ledger_field.rsplit(".", 1)[-1]
        else:
            self._packet_field = packet_field

    def start_of_simulation(
        self, ledger, emission_rate, trading_calendar, sessions, benchmark_source
    ):
        self._start_of_simulation = self._get_ledger_field(ledger)

    def start_of_session(self, ledger, session, data_portal):
        self._previous_day = self._get_ledger_field(ledger)

    def _end_of_period(self, sub_field, packet, ledger):
        packet_field = self._packet_field
        packet["cumulative_perf"][packet_field] = self._start_of_simulation
        packet[sub_field][packet_field] = self._previous_day

    def end_of_bar(self, packet, ledger, dt, session_ix, data_portal):
        self._end_of_period("minute_perf", packet, ledger)

    def end_of_session(self, packet, ledger, session, session_ix, data_portal):
        self._end_of_period("daily_perf", packet, ledger)
```

--------------------------------

### Zipline Run Command Help

Source: https://zipline.ml4trading.io/_sources/beginner-tutorial.rst.txt

Displays the help information for the `zipline run` command, outlining available options for executing backtests.

```bash
$ zipline run --help
```

--------------------------------

### Calculate Trading Dates

Source: https://zipline.ml4trading.io/_modules/zipline/utils/events.html

Recalculates trading period start and close dates based on the current datetime. This is called when the period start is not set or the current datetime is beyond the current period close.

```python
if self._period_start is None or self._period_close <= dt:
            self.calculate_dates(dt)
```

--------------------------------

### Initialize Asset Database Tables

Source: https://zipline.ml4trading.io/_modules/zipline/assets/asset_writer.html

Creates SQL tables in the asset database if they do not already exist. This is a prerequisite for writing data.

```python
def _real_write(
        self,
        equities,
        equity_symbol_mappings,
        equity_supplementary_mappings,
        futures,
        exchanges,
        root_symbols,
        chunk_size,
    ):
        with self.engine.begin() as conn:
            # Create SQL tables if they do not exist.
            self.init_db(conn)

            if exchanges is not None:
                self._write_df_to_table(
                    exchanges_table,
                    exchanges,
                    conn,
                    chunk_size,
                )
```

--------------------------------

### BusinessDaysSincePreviousEvent Factor Example

Source: https://zipline.ml4trading.io/_modules/zipline/pipeline/factors/events.html

Example of how to use BusinessDaysSincePreviousEvent to filter assets based on the recency of their last event date. This factor calculates the number of business days since the most recent event for each asset.

```python
days_since_event = BusinessDaysSincePreviousEvent(
    inputs=[MyDataset.asof_date]
)

# Filter returning True for each asset whose most recent asof_date
# was in the last 5 business days.
recency_filter = (days_since_event <= 5)
```

--------------------------------

### Example Pipeline Output

Source: https://zipline.ml4trading.io/api-reference.html

Illustrates the potential output of a Zipline pipeline with defined columns, showing transformed price data for different assets.

```text
'PRICE' 'WINSOR_1' 'WINSOR_2' 'WINSOR_3'
Asset_1    1        2          4          3
Asset_2    2        2          4          3
Asset_3    3        3          4          3
Asset_4    4        4          4          4
Asset_5    5        5          5          4
Asset_6    6        5          5          4


```

--------------------------------

### Portfolio Class Initialization

Source: https://zipline.ml4trading.io/_modules/zipline/protocol.html

Initializes a Portfolio object with starting date and capital base. It sets up attributes for tracking cash, positions, and performance.

```python
def __init__(self, start_date=None, capital_base=0.0):
        self_ = MutableView(self)
        self_.cash_flow = 0.0
        self_.starting_cash = capital_base
        self_.portfolio_value = capital_base
        self_.pnl = 0.0
        self_.returns = 0.0
        self_.cash = capital_base
        self_.positions = Positions()
        self_.start_date = start_date
        self_.positions_value = 0.0
        self_.positions_exposure = 0.0
```

--------------------------------

### Get Positions

Source: https://zipline.ml4trading.io/_modules/zipline/finance/ledger.html

Retrieves the current list of positions.

```APIDOC
## positions

### Description
Retrieves the current list of positions.

### Returns
- **positions** (list) - A list of current positions.
```

--------------------------------

### StartOfPeriodLedgerField

Source: https://zipline.ml4trading.io/api-reference.html

Keep track of the value of a ledger field at the start of the period.

```APIDOC
## StartOfPeriodLedgerField

### Description
Keep track of the value of a ledger field at the start of the period.

### Parameters
#### Path Parameters
- **ledger_field** (str) - Required - The ledger field to read.
- **packet_field** (str, optional) - The name of the field to populate in the packet. If not provided, `ledger_field` will be used.
```

--------------------------------

### DataPortal Initialization

Source: https://zipline.ml4trading.io/api-reference.html

Initializes the DataPortal, which serves as the central interface for all data required by a Zipline simulation. It requires an AssetFinder, a TradingCalendar, and the first trading day. Optional readers for daily and minute bar data, as well as adjustment data, can be provided.

```python
zipline.data.data_portal.DataPortal(asset_finder, trading_calendar, first_trading_day, equity_daily_reader=None, equity_minute_reader=None, future_daily_reader=None, future_minute_reader=None, adjustment_reader=None, last_available_session=None, last_available_minute=None, minute_history_prefetch_length=1560, daily_history_prefetch_length=40)
```

--------------------------------

### Run Backtest with a Specific Bundle

Source: https://zipline.ml4trading.io/bundles.html

Execute a backtest using the `run` command, specifying the data bundle to use with the `--bundle` option. You can also specify a `--bundle-timestamp` to use data from a specific past ingestion.

```bash
$ zipline run --bundle <bundle> --algofile algo.py ...

```

--------------------------------

### start_of_simulation Method Signature

Source: https://zipline.ml4trading.io/_sources/risk-and-perf-metrics.rst.txt

The `start_of_simulation` method is called at the beginning of each simulation to initialize metric caches. It receives various simulation parameters.

```python
def start_of_simulation(self,
                          ledger,
                          emission_rate,
                          trading_calendar,
                          sessions,
                          benchmark_source):
    ...

```

--------------------------------

### Get Orders

Source: https://zipline.ml4trading.io/_modules/zipline/finance/ledger.html

Retrieves orders for a specific datetime or all orders if no datetime is provided.

```APIDOC
## orders

### Description
Retrieve the dict-form of all of the orders in a given bar or for the whole simulation.

### Parameters
- **dt** (pd.Timestamp or None, optional) - The particular datetime to look up order for. If not passed, or None is explicitly passed, all of the orders will be returned.

### Returns
- **orders** (list[dict]) - The order information.
```

--------------------------------

### Create and Activate Virtual Environment (venv)

Source: https://zipline.ml4trading.io/_sources/development-guidelines.rst.txt

Create a Python virtual environment using venv and activate it for development.

```bash
$ python3 -m venv venv
$ source venv/bin/activate
```
Tokens:
Raw