### Install Dependencies with Pip

Source: https://github.com/eslazarev/vwap-backtrader/blob/main/README.md

Install all required Python packages for the project by running this command in your terminal.

```bash
pip install -r requirements.txt
```

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

### Complete Trading System Example

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Demonstrates setting up and running both VWAP strategies with visualization using the Backtrader cerebro engine.

```APIDOC
## Complete Trading System Example

### Description
This example illustrates a full Backtrader setup, including adding multiple VWAP strategies (`VwapRollingStrategy` and `VwapIntradayStrategy`), fetching market data, setting initial capital, running the backtest, and visualizing the results with a candlestick chart.

### Method
N/A (Script Execution)

### Endpoint
N/A (Script Execution)

### Parameters
N/A

### Request Body
N/A

### Request Example
```python
import backtrader as bt
from src.brokers.yahoo_broker import get_ohlc_pandas_data
from src.strategies.vwap_instraday_strategy import VwapIntradayStrategy
from src.strategies.vwap_rolling_strategy import VwapRollingStrategy

# Complete trading system setup
if __name__ == "__main__":
    # Initialize Backtrader engine
    cerebro = bt.Cerebro()

    # Add both VWAP strategies
    cerebro.addstrategy(VwapRollingStrategy)
    cerebro.addstrategy(VwapIntradayStrategy)

    # Fetch market data (S&P 500 with 15-minute bars)
    MARKET = "^GSPC"
    data = get_ohlc_pandas_data(MARKET, "15m")
    cerebro.adddata(data)

    # Set initial portfolio value
    cerebro.broker.setcash(100000.0)

    # Run backtest
    print(f"Starting Portfolio Value: {cerebro.broker.getvalue():.2f}")
    results = cerebro.run()
    print(f"Final Portfolio Value: {cerebro.broker.getvalue():.2f}")

    # Plot candlestick chart with VWAP indicators overlaid
    cerebro.plot(style="candlestick")
```

### Response
#### Success Response (Execution Output)
- **Starting Portfolio Value**: Initial cash value.
- **Final Portfolio Value**: Portfolio value after backtest execution.
- **Interactive chart window**: Visual representation of the backtest results.

#### Response Example
```
Starting Portfolio Value: 100000.00
Final Portfolio Value: 100000.00
[Interactive chart window with candlestick prices and VWAP lines]
```
```

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

### VwapRollingStrategy Usage

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Example of how to use the VwapRollingIndicator within a Backtrader strategy with a custom period.

```APIDOC
## VwapRollingStrategy Usage

### Description
This section shows how to integrate the `VwapRollingIndicator` into a custom Backtrader strategy, allowing for a configurable rolling period for VWAP calculations.

### Method
N/A (Strategy Implementation)

### Endpoint
N/A (Strategy Implementation)

### Parameters
#### Strategy Parameters
- **period** (int) - Optional - The lookback period for the rolling VWAP calculation. Defaults to 20.

### Request Body
N/A

### Request Example
```python
class MyRollingStrategy(bt.Strategy):
    params = {"period": 20}  # Configurable rolling period

    def __init__(self):
        # Add rolling VWAP with 20-bar period
        self.vwap = VwapRollingIndicator(self.data, period=self.p.period, plot=True)

    def next(self):
        # Mean reversion strategy: buy below VWAP, sell above
        if self.data.close[0] < self.vwap.vwap_rolling[0] * 0.99:  # 1% below VWAP
            if not self.position:
                self.buy()
        elif self.data.close[0] > self.vwap.vwap_rolling[0] * 1.01:  # 1% above VWAP
            if self.position:
                self.sell()
```

### Response
N/A (Strategy Logic)
```

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

### Complete Trading System Setup

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Sets up and runs a Backtrader cerebro engine with multiple VWAP strategies and fetched market data. Includes initial cash, portfolio value tracking, and plotting.

```python
import backtrader as bt
from src.brokers.yahoo_broker import get_ohlc_pandas_data
from src.strategies.vwap_instraday_strategy import VwapIntradayStrategy
from src.strategies.vwap_rolling_strategy import VwapRollingStrategy

# Complete trading system setup
if __name__ == "__main__":
    # Initialize Backtrader engine
    cerebro = bt.Cerebro()

    # Add both VWAP strategies
    cerebro.addstrategy(VwapRollingStrategy)
    cerebro.addstrategy(VwapIntradayStrategy)

    # Fetch market data (S&P 500 with 15-minute bars)
    MARKET = "^GSPC"
    data = get_ohlc_pandas_data(MARKET, "15m")
    cerebro.adddata(data)

    # Set initial portfolio value
    cerebro.broker.setcash(100000.0)

    # Run backtest
    print(f"Starting Portfolio Value: {cerebro.broker.getvalue():.2f}")
    results = cerebro.run()
    print(f"Final Portfolio Value: {cerebro.broker.getvalue():.2f}")

    # Plot candlestick chart with VWAP indicators overlaid
    cerebro.plot(style="candlestick")
```

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

### VWAP Intraday Indicator for Backtrader

Source: https://github.com/eslazarev/vwap-backtrader/blob/main/README.md

Use this indicator to calculate the Volume Weighted Average Price that resets at the start of each trading day. It requires timezone configuration.

```python
class VwapIntradayIndicator(bt.Indicator):
    """
    Volume Weighted Average Price (VWAP) indicator for intraday trading.
    """

    lines = ("vwap_intraday",)
    params = {"timezone": "America/New_York"}
    plotinfo = {"subplot": False}
    plotlines = {"vwap_intraday": {"color": "blue"}}

    def __init__(self) -> None:
        self.hlc = (self.data.high + self.data.low + self.data.close) / 3.0

        self.current_date: Optional[datetime.date] = None
        self.previous_date_index: int = -1

    def next(self) -> None:
        current_date = (
            pytz.utc.localize(self.data.datetime.datetime()).astimezone(pytz.timezone(self.p.timezone)).date()
        )
        len_self: int = len(self)

        if self.current_date != current_date:
            self.current_date = current_date
            self.previous_date_index = len_self - 1

        volumes = self.data.volume.get(size=len_self - self.previous_date_index)
        hlc = self.hlc.get(size=len_self - self.previous_date_index)

        numerator = sum(hlc[i] * volumes[i] for i in range(len(volumes)))
        self.lines.vwap_intraday[0] = None if sum(volumes) == 0 else numerator / sum(volumes)
```

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

### Intraday VWAP Indicator Implementation

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Defines the VwapIntradayIndicator class, which calculates the volume-weighted average price from the start of each trading day. It requires timezone configuration for accurate daily resets. The indicator is designed to be plotted directly on the price chart.

```python
import backtrader as bt
from src.indicators.vwap_intraday_indicator import VwapIntradayIndicator

class VwapIntradayIndicator(bt.Indicator):
    """
    Volume Weighted Average Price (VWAP) indicator for intraday trading.
    Resets at the start of each trading day based on configured timezone.
    """

    lines = ("vwap_intraday",)
    params = {"timezone": "America/New_York"}  # Configurable timezone
    plotinfo = {"subplot": False}  # Overlay on price chart
    plotlines = {"vwap_intraday": {"color": "blue"}}

    def __init__(self) -> None:
        # Typical price calculation: (High + Low + Close) / 3
        self.hlc = (self.data.high + self.data.low + self.data.close) / 3.0
        self.current_date = None
        self.previous_date_index = -1

    def next(self) -> None:
        # Detect new trading day and reset accumulation
        current_date = (
            pytz.utc.localize(self.data.datetime.datetime())
            .astimezone(pytz.timezone(self.p.timezone))
            .date()
        )

        if self.current_date != current_date:
            self.current_date = current_date
            self.previous_date_index = len(self) - 1

        # Calculate VWAP from day start
        volumes = self.data.volume.get(size=len(self) - self.previous_date_index)
        hlc = self.hlc.get(size=len(self) - self.previous_date_index)

        numerator = sum(hlc[i] * volumes[i] for i in range(len(volumes)))
        self.lines.vwap_intraday[0] = None if sum(volumes) == 0 else numerator / sum(volumes)
```

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

### Run Main Script

Source: https://github.com/eslazarev/vwap-backtrader/blob/main/README.md

Execute the main Python script to apply VWAP indicators to trading strategies and visualize results.

```bash
python src/main.py
```

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

### Clone Repository with Git

Source: https://github.com/eslazarev/vwap-backtrader/blob/main/README.md

Clone the project repository to your local machine using the provided Git command.

```bash
git clone https://github.com/eslazarev/vwap-backtrader.git
cd vwap-backtrade
```

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

### Intraday VWAP Strategy Usage

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Demonstrates how to integrate the VwapIntradayIndicator into a Backtrader strategy. It shows how to instantiate the indicator with a specific timezone and implement basic trading logic based on price crossing the VWAP line.

```python
# Usage in a strategy
class MyIntradayStrategy(bt.Strategy):
    def __init__(self):
        # Add intraday VWAP with custom timezone
        self.vwap = VwapIntradayIndicator(self.data, timezone="America/New_York", plot=True)

    def next(self):
        # Trading logic: buy when price crosses above VWAP
        if self.data.close[0] > self.vwap.vwap_intraday[0]:
            if not self.position:
                self.buy()
        # Sell when price crosses below VWAP
        elif self.data.close[0] < self.vwap.vwap_intraday[0]:
            if self.position:
                self.sell()
```

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

### Rolling VWAP Indicator Implementation

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Defines the VwapRollingIndicator class, which calculates a continuous volume-weighted average price over a specified period. This indicator is useful for identifying longer-term trends and does not reset daily. It uses Backtrader's SumN and DivByZero indicators for calculation.

```python
import backtrader as bt
from src.indicators.vwap_rolling_indicator import VwapRollingIndicator

class VwapRollingIndicator(bt.Indicator):
    """
    Volume Weighted Average Price (VWAP) indicator with rolling calculation.
    Uses a configurable period window for continuous VWAP.
    """

    lines = ("vwap_rolling",)
    params = {"period": 14}  # Rolling window size (default: 14 bars)
    plotinfo = {"subplot": False}  # Overlay on price chart
    plotlines = {"vwap_rolling": {"color": "green"}}

    def __init__(self) -> None:
        # Typical price: (High + Low + Close) / 3
        self.hlc = (self.data.high + self.data.low + self.data.close) / 3.0

        # Sum of (typical price * volume) over the period
        self.hlc_volume_sum = bt.ind.SumN(self.hlc * self.data.volume, period=self.p.period)

        # Sum of volume over the period
        self.volume_sum = bt.ind.SumN(self.data.volume, period=self.p.period)

        # VWAP = sum(price*volume) / sum(volume), with zero-division protection
        self.lines.vwap_rolling = bt.DivByZero(self.hlc_volume_sum, self.volume_sum, None)
```

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

### Custom Rolling VWAP Strategy

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Implement a mean reversion strategy using a rolling VWAP indicator. Configure the rolling period during initialization.

```python
class MyRollingStrategy(bt.Strategy):
    params = {"period": 20}  # Configurable rolling period

    def __init__(self):
        # Add rolling VWAP with 20-bar period
        self.vwap = VwapRollingIndicator(self.data, period=self.p.period, plot=True)

    def next(self):
        # Mean reversion strategy: buy below VWAP, sell above
        if self.data.close[0] < self.vwap.vwap_rolling[0] * 0.99:  # 1% below VWAP
            if not self.position:
                self.buy()
        elif self.data.close[0] > self.vwap.vwap_rolling[0] * 1.01:  # 1% above VWAP
            if self.position:
                self.sell()
```

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

### Fetch OHLC Data with Pandas

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Fetches OHLC data from Yahoo Finance and converts it to a Backtrader-compatible PandasData feed. Supports various timeframes and automatic UTC conversion.

```python
import backtrader as bt
from src.brokers.yahoo_broker import get_ohlc_pandas_data

# Supported timeframes mapping
TIMEFRAME_MAP = {
    "1m": (bt.TimeFrame.Minutes, 1),
    "2m": (bt.TimeFrame.Minutes, 2),
    "5m": (bt.TimeFrame.Minutes, 5),
    "15m": (bt.TimeFrame.Minutes, 15),
    "30m": (bt.TimeFrame.Minutes, 30),
    "60m": (bt.TimeFrame.Minutes, 60),
    "90m": (bt.TimeFrame.Minutes, 90),
    "1h": (bt.TimeFrame.Minutes, 60),
    "1d": (bt.TimeFrame.Days, 1),
    "5d": (bt.TimeFrame.Days, 5),
    "1wk": (bt.TimeFrame.Weeks, 1),
    "1mo": (bt.TimeFrame.Months, 1),
    "3mo": (bt.TimeFrame.Months, 3),
}

def get_ohlc_pandas_data(market: str, timeframe: str) -> bt.feeds.PandasData:
    """
    Fetch OHLC data from Yahoo Finance and convert to Backtrader data feed.

    Parameters:
    - market (str): Trading symbol (e.g., "^GSPC" for S&P 500, "AAPL" for Apple)
    - timeframe (str): Data interval (1m, 5m, 15m, 1h, 1d, 1wk, 1mo, etc.)

    Returns:
    - bt.feeds.PandasData: Backtrader-compatible data feed
    """
    data_source = yf.Ticker(market)
    df = data_source.history(interval=timeframe)
    df.index = df.index.tz_convert("UTC")
    bt_timeframe, compression = TIMEFRAME_MAP.get(timeframe, (bt.TimeFrame.Minutes, 1))
    return bt.feeds.PandasData(dataname=df, timeframe=bt_timeframe, compression=compression)


# Fetch S&P 500 data with 15-minute intervals
data = get_ohlc_pandas_data("^GSPC", "15m")

# Fetch Apple daily data
data = get_ohlc_pandas_data("AAPL", "1d")

# Fetch Bitcoin hourly data
data = get_ohlc_pandas_data("BTC-USD", "1h")
```

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

### get_ohlc_pandas_data

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Fetches OHLC data from Yahoo Finance and converts it into a Backtrader-compatible PandasData feed.

```APIDOC
## GET /eslazarev/vwap-backtrader/src/brokers/yahoo_broker/get_ohlc_pandas_data

### Description
Fetches OHLC (Open, High, Low, Close) market data from Yahoo Finance and converts it to a Backtrader-compatible data feed. Supports multiple timeframes from 1-minute to 3-month intervals with automatic timezone conversion to UTC.

### Method
GET

### Endpoint
/eslazarev/vwap-backtrader/src/brokers/yahoo_broker/get_ohlc_pandas_data

### Parameters
#### Query Parameters
- **market** (str) - Required - Trading symbol (e.g., "^GSPC" for S&P 500, "AAPL" for Apple)
- **timeframe** (str) - Required - Data interval (e.g., "1m", "5m", "15m", "1h", "1d", "1wk", "1mo", "3mo")

### Request Example
```python
import backtrader as bt
from src.brokers.yahoo_broker import get_ohlc_pandas_data

# Fetch S&P 500 data with 15-minute intervals
data = get_ohlc_pandas_data("^GSPC", "15m")

# Fetch Apple daily data
data = get_ohlc_pandas_data("AAPL", "1d")

# Fetch Bitcoin hourly data
data = get_ohlc_pandas_data("BTC-USD", "1h")
```

### Response
#### Success Response (200)
- **bt.feeds.PandasData** (object) - A Backtrader-compatible data feed object containing OHLC data.

#### Response Example
```python
# Example of the returned object structure (conceptual)
# <backtrader.feeds.pandas.PandasData object at 0x...>
```
```

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

### VWAP Rolling Indicator for Backtrader

Source: https://github.com/eslazarev/vwap-backtrader/blob/main/README.md

Implement this indicator for a continuously updated VWAP value over a specified rolling period. The period parameter defaults to 14.

```python
class VwapRollingIndicator(bt.Indicator):
    """
    Volume Weighted Average Price (VWAP) indicator, rolling calculation.
    """

    lines = ("vwap_rolling",)
    params = {"period": 14}
    plotinfo = {"subplot": False}
    plotlines = {"vwap_rolling": {"color": "green"}}

    def __init__(self) -> None:
        self.hlc = (self.data.high + self.data.low + self.data.close) / 3.0
        self.hlc_volume_sum = bt.ind.SumN(self.hlc * self.data.volume, period=self.p.period)
        self.volume_sum = bt.ind.SumN(self.data.volume, period=self.p.period)

        self.lines.vwap_rolling = bt.DivByZero(self.hlc_volume_sum, self.volume_sum, None)
```

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

### Unit Test VWAP Rolling Indicator with Synthetic Data

Source: https://context7.com/eslazarev/vwap-backtrader/llms.txt

Unit test for the VwapRollingIndicator using Python's unittest framework. It sets up synthetic OHLCV data and adds the indicator to a Backtrader strategy for testing initialization.

```python
import unittest
import backtrader as bt
import numpy as np
import pandas as pd
from src.indicators.vwap_rolling_indicator import VwapRollingIndicator

class TestVwapRollingIndicator(unittest.TestCase):
    def setUp(self):
        self.cerebro = bt.Cerebro()
        self.data = self._create_test_data()
        self.cerebro.adddata(self.data)

    def _create_test_data(self):
        """Create predictable synthetic OHLCV data for testing."""
        dates = pd.date_range(start="2024-01-01", periods=20, freq="D")

        # Repeating pattern for predictable VWAP calculations
        high = np.array([10.0, 11.0, 12.0, 13.0, 14.0] * 4)
        low = np.array([9.0, 10.0, 11.0, 12.0, 13.0] * 4)
        close = np.array([9.5, 10.5, 11.5, 12.5, 13.5] * 4)
        volume = np.array([100, 200, 300, 400, 500] * 4)

        df = pd.DataFrame({
            "high": high,
            "low": low,
            "close": close,
            "volume": volume,
            "openinterest": [0] * len(dates)
        }, index=dates)

        return bt.feeds.PandasData(dataname=df)

    def test_indicator_initialization(self):
        """Test that VWAP indicator initializes correctly."""
        class TestStrategy(bt.Strategy):
            def __init__(self):
                self.vwap = VwapRollingIndicator()

        self.cerebro.addstrategy(TestStrategy)
        results = self.cerebro.run()

        # Verify indicator was created
        self.assertIsNotNone(results[0].vwap)

if __name__ == "__main__":
    unittest.main()

# Run tests:
# python -m pytest tests/test_vwap_rolling.py -v

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.