Pyharmonics

https://pyharmonics.readthedocs.io/en/latest/
Admin
Pyharmonics is a Python library that detects harmonic trading patterns in OHLC candle data for...
Tokens:54,841
Snippets:353
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Pyharmonics library

Source: https://pyharmonics.readthedocs.io/en/latest/index.html

Instructions for installing the Pyharmonics package via Git or PyPI. This setup is required to access the library's market data and analysis modules.

```bash
# From git
git clone git@github.com:niall-oc/pyharmonics.git
cd pyharmonics
pip install .

# From pypi
pip install pyharmonics
```

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

### Install Pyharmonics library

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/index.rst.txt

Instructions for installing the Pyharmonics library via Git or PyPI to begin using the harmonic pattern detection tools.

```bash
$ git clone git@github.com:niall-oc/pyharmonics.git
$ cd pyharmonics
$ pip install .
$ cd src
$ python
```

```bash
$ pip install pyharmonics
$ python
```

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

### Initializing 3D Option Surface Plots

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/plotter/option.html

Constructor and setup logic for the OptionSurface class, which prepares 3D surface plots based on Yahoo Finance option chain data.

```python
def set_main_plot(self):
    self.main_plot = go.Figure(
        go.Surface(
            contours={
                "x": {"show": True, "start": 0, "end": len(self.yo.ticker.options)},
                "y": {"show": True, "start": self.call_strikes[0], "end": self.call_strikes[-1]}
            }
        )
    )
```

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

### GET /whats_options_interest

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Retrieve and visualize options open interest for a specific symbol.

```APIDOC
## GET /whats_options_interest

### Description
Displays the options open interest for the given symbol and plots the point of minimum losses for the market maker.

### Method
GET

### Parameters
#### Query Parameters
- **symbol** (string) - Required - The ticker symbol to search.

### Response
#### Success Response (200)
- **YahooOptionData** (Object) - The YahooOptionData object containing the results.
```

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

### GET /whats_forming_binance

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Search for forming harmonic patterns and divergences using Binance market data.

```APIDOC
## GET /whats_forming_binance

### Description
Search for forming harmonic patterns and divergences in the given Binance data.

### Method
GET

### Parameters
#### Query Parameters
- **symbol** (string) - Required - The trading symbol (e.g., 'BTCUSDT').
- **interval** (string) - Required - The timeframe or interval.
- **limit_to** (int) - Optional - Limit results to last n candles (default: 10).
- **percent_complete** (float) - Optional - Completion threshold (default: 0.8).
- **candles** (int) - Optional - Number of candles to fetch (default: 1000).

### Response
#### Success Response (200)
- **HarmonicSearch** (Object) - The HarmonicSearch object containing the results.
```

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

### GET /whats_forming

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Search for forming harmonic patterns and divergences in provided data.

```APIDOC
## GET /whats_forming

### Description
Search for forming harmonic patterns and divergences in the given CandleData object.

### Method
GET

### Parameters
#### Request Body
- **cd** (CandleData) - Required - The CandleData object to search.
- **limit_to** (int) - Optional - Limit results to patterns completing in the last n candles (default: 10).
- **percent_complete** (float) - Optional - Percentage of pattern completion required (default: 0.8).

### Response
#### Success Response (200)
- **HarmonicSearch** (Object) - The HarmonicSearch object containing the results.
```

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

### Retrieve Historical Candles with PyHarmonics

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/binance_data.html

This snippet demonstrates how to initialize a start date using the datetime module and fetch historical candle data for a specified trading pair. It requires the datetime library and an initialized PyHarmonics client instance.

```python
import datetime

start = datetime.datetime(2021, 8, 28, 23, 59, 59)
b.get_candles('MATICUSDT', b.DAY_1, start=start)
```

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

### Example Usage: Market Data and Technical Analysis in Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/search/harmonic.html

Demonstrates initializing market data retrieval from Binance and setting up technical analysis tools. This includes fetching historical candle data and initializing an OHLCTechnicals object for further analysis. Dependencies include BinanceCandleData, OHLCTechnicals, datetime, and constants.

```python
if __name__ == '__main__':
    from pyharmonics.marketdata import BinanceCandleData
    from pyharmonics.search import DivergenceSearch
    from pyharmonics import OHLCTechnicals
    from pyharmonics.plotter import HarmonicPlotter
    import datetime

    present = int(datetime.datetime.now().timestamp() * 1000)

    b = BinanceCandleData()
    b.get_candles('BTCUSDT', b.HOUR_1, 1000)
    t = OHLCTechnicals(b.df, b.symbol, b.interval, peak_spacing=10)
```

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

### Visualize Trading Positions with Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/quick.html

The play_position function creates a Position object and uses PositionPlotter to visualize peaks and the trade setup. It requires a HarmonicSearch object, a pattern, a strike price, and a dollar amount.

```python
def play_position(hs, pattern, strike, dollar_amount):
    pos = Position(pattern, strike, dollar_amount)
    p = PositionPlotter(hs.td, pos)
    p.add_peaks()
    p.show()
```

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

### Search and Retrieve Harmonic Patterns

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.search.html

Provides examples for initializing HarmonicSearch, searching for fully formed patterns, and identifying patterns that are currently forming. It also shows how to filter results by pattern family and completion status.

```python
h = HarmonicSearch(t)
# Search for forming patterns
h.forming()
h.get_patterns(formed=False)

# Retrieve specific patterns
h.get_patterns()
h.get_patterns(family=h.XABCD)
h.get_patterns(family=h.ABCD, formed=False)

# Search for fully formed patterns
h.search()
h.search(limit_to=3)
```

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

### Divergence Constructor (Python)

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/patterns.html

Initializes a Divergence object, storing information about the price and indicator points, and the type of divergence (bullish or bearish). Includes a doctest example.

```python
    def __init__(
        self,
        indicator: str,
        name: str,
        x: tuple,
        y: tuple,
        ind_x: tuple,
        ind_y: tuple,
        bullish: bool
    ):
        """
        Constructor for Divergence.

        >>> d = Divergence('RSI', 'Bullish', (1, 2), (3, 4), (5, 6), (7, 8), True)

        :param str indicator: The indicator for the divergence.
        :param str name: The name of the divergence.
        :param tuple x: The x points for the price.
        :param tuple y: The y points for the price.
        :param tuple ind_x: The x points for the indicator.
        :param tuple ind_y: The y points for the indicator.
        :param bool bullish: True if the divergence is bullish
        """
        self.indicator = indicator
        self.name = name
        self.x = x
        self.y = y
        self.ind_x = ind_x
        self.ind_y = ind_y
        self.bullish = bullish
```

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

### Fetch Cryptocurrency Market Data with BinanceCandleData

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Demonstrates how to initialize the BinanceCandleData class and retrieve historical candle data for a specific trading pair. Supports fetching by count, start date, and end date.

```python
m = BinanceCandleData()
m.get_candles('BTCUSDT', '1h', num_candles=1000)
m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))
m.get_candles('BTCUSDT', '1h', num_candles=1000, start=datetime.datetime(2020, 3, 21, 14, 0, 15))
m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

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

### Adjust Peak Spacing for Technical Analysis (Python)

Source: https://pyharmonics.readthedocs.io/en/latest/technicals_guide.html

This example demonstrates how to adjust the `peak_spacing` parameter when initializing the Technicals object. Increasing this value can lead to more identified peaks, which might be useful for detecting more harmonic patterns but could also result in an excessive number of patterns.

```python
from pyharmonics.technicals import Technicals
from pyharmonics.marketdata import BinanceCandleData

b = BinanceCandleData()
b.get_candles('ETHUSDT', b.HOUR_4, 400)
t = Technicals(b.df, peak_spacing=12)
```

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

### Initialize Technical Analysis Classes

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Demonstrates how to instantiate OHLCTechnicals with a dataframe, symbol, and timeframe to begin technical analysis.

```python
t = OHLCTechnicals(df, symbol, time_frame)
```

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

### Get Yahoo Finance Candle Data

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Fetches historical candle data for a specified stock symbol and interval from Yahoo Finance. Supports fetching a specific number of candles or a range defined by start and end times.

```python
>>> y = Yahoo()
>>> y.get_candles('MSFT', '1d')
```

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

### GET /api/v1/klines

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/binance_data.html

Fetches historical candlestick data for a given symbol and interval. Supports fetching a specific number of candles or a range between start and end times. Handles multiple API calls for large requests.

```APIDOC
## GET /api/v1/klines

### Description
Fetches historical candlestick data for a given symbol and interval. Supports fetching a specific number of candles or a range between start and end times. Handles multiple API calls for large requests.

### Method
GET

### Endpoint
/api/v1/klines

### Parameters
#### Query Parameters
- **symbol** (string) - Required - The trading symbol (e.g., 'BTCUSDT').
- **interval** (string) - Required - The candlestick interval (e.g., '1h', '1d'). Must be one of the supported intervals.
- **num_candles** (integer) - Optional - The number of historical candles to retrieve. If not specified, defaults to a maximum limit.
- **start** (datetime) - Optional - The start time for retrieving candles. If specified with `end`, retrieves candles within this range.
- **end** (datetime) - Optional - The end time for retrieving candles. If specified with `start`, retrieves candles within this range.

### Request Example
```python
# Fetching 1000 1-hour candles for BTCUSDT
m.get_candles('BTCUSDT', '1h', num_candles=1000)

# Fetching 1000 1-hour candles for BTCUSDT ending at a specific time
m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))

# Fetching 1000 1-hour candles for BTCUSDT starting at a specific time
m.get_candles('BTCUSDT', '1h', num_candles=1000, start=datetime.datetime(2020, 3, 21, 14, 0, 15))

# Fetching all available 1-hour candles for BTCUSDT starting from a specific time
m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

### Response
#### Success Response (200)
- **df** (DataFrame) - A pandas DataFrame containing the candlestick data. Each row represents a candle with fields like open time, open price, high price, low price, close price, volume, etc.

#### Response Example
```json
{
  "symbol": "BTCUSDT",
  "interval": "1h",
  "open_time": [1584800400000, 1584804000000, ...],
  "open_price": ["8500.00", "8550.00", ...],
  "high_price": ["8600.00", "8650.00", ...],
  "low_price": ["8450.00", "8500.00", ...],
  "close_price": ["8550.00", "8600.00", ...],
  "volume": ["1000.00", "1200.00", ...],
  "close_time": [1584803999999, 1584807599999, ...],
  "quote_asset_volume": ["8550000.00", "10320000.00", ...],
  "number_of_trades": [10000, 12000, ...],
  "taker_buy_base_asset_volume": ["500.00", "600.00", ...],
  "taker_buy_quote_asset_volume": ["4275000.00", "5160000.00", ...],
  "ignore": ["0.00", "0.00", ...]
}
```

### Error Handling
- **InvalidTimeframe**: Raised if the provided `interval` is not supported by Binance.
```

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

### Get Candle Block from Binance API - Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/binance_data.html

Makes a direct call to the Binance API to retrieve a block of candlestick data. It accepts optional start time, end time, and a limit on the number of candles to fetch. The data is returned in a format suitable for further processing.

```python
def _get_candle_block(self, start=None, end=None, num_candles=None):
        """
        Calls binance API to get a block of candle data.

        >>> m._get_candle_block(start=datetime.datetime(2020, 3, 21, 14, 0, 15))
        >>> m._get_candle_block(end=datetime.datetime(2020, 3, 21, 14, 0, 15))
        >>> m._get_candle_block(num_candles=1000)

        :param start: The start time for a range of candles.
        :param end: The end time for a range of candles.
        :param num_candles: The number of candles to fetch.
        :return: The data from the API.
        """
        limit = num_candles

        data = self.rc.klines(
            self.symbol,
            self.INTERVALS[self.interval],
            startTime=start,
            endTime=end,
            limit=limit
        )
        return data
```

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

### Initialize Technicals and process trend data

Source: https://pyharmonics.readthedocs.io/en/latest/technicals_guide.html

Demonstrates how to instantiate the Technicals object using a dataset and frequency parameters. The resulting object provides a DataFrame containing various technical indicators and peak/dip markers.

```python
from pyharmonics.technicals import Technicals
from pyharmonics.utils import UER

# Initialize Technicals with data, name, frequency, and peak spacing
t = Technicals(UER, 'Unemployment', 'monthly', peak_spacing=6)

# Access the processed DataFrame
print(t.df)
```

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

### Fetch and Analyze Binance Market Data with Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/quick.html

These functions automate the process of fetching Binance candle data and passing it to the analysis engine. They support both completed and forming pattern searches.

```python
def whats_new_binance(symbol, interval, limit_to=-1, candles=1000):
    bc = BinanceCandleData()
    bc.get_candles(symbol, interval, candles)
    return whats_new(bc, limit_to=limit_to)

def whats_forming_binance(symbol, interval, limit_to=10, percent_complete=0.8, candles=1000):
    bc = BinanceCandleData()
    bc.get_candles(symbol, interval, candles)
    return whats_forming(bc, limit_to=limit_to, percent_complete=percent_complete)
```

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

### Retrieve market data and initialize technical analysis

Source: https://pyharmonics.readthedocs.io/en/latest/index.html

Demonstrates how to fetch OHLC candle data using the BinanceCandleData class and initialize the Technicals object. This serves as the foundation for subsequent harmonic pattern analysis.

```python
from pyharmonics.marketdata import BinanceCandleData
from pyharmonics.technicals import Technicals

# Fetch data
b = BinanceCandleData()
b.get_candles('BTCUSDT', b.MIN_15, 1000)

# Initialize technicals
t = Technicals(b.df, b.symbol, b.interval)
```

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

### GET /get_series_x_y

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Retrieves indicator readings for specific indexes within a technical series.

```APIDOC
## GET /get_series_x_y

### Description
Returns the time and indicator readings at the specified indexes for a given series.

### Method
GET

### Endpoint
/get_series_x_y

### Parameters
#### Query Parameters
- **series_indexes** (list) - Required - The list of indexes to query.
- **series** (str) - Required - The indicator series name (e.g., 'macd', 'rsi').

### Request Example
{
  "series_indexes": [100, 200, 300],
  "series": "macd"
}

### Response
#### Success Response (200)
- **data** (list) - A list containing the requested indexes and their corresponding indicator values.

#### Response Example
{
  "data": [[100, 200, 300], [5.5, -11.2, -160.5]]
}
```

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

### GET /filter_peak_data

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Filters and extracts high or low peak data points from the technical series.

```APIDOC
## GET /filter_peak_data

### Description
Extracts either the highs or the lows from the identified peaks in the dataset.

### Method
GET

### Endpoint
/filter_peak_data

### Parameters
#### Query Parameters
- **lows** (bool) - Optional - If True, returns the lows; otherwise, returns the highs. Defaults to False.

### Request Example
{
  "lows": true
}

### Response
#### Success Response (200)
- **peaks** (list) - A list of tuples containing index, price, and type identifier.

#### Response Example
{
  "peaks": [[29, 27125.0, 0], [46, 26942.82, 0]]
}
```

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

### Import Pyharmonics Quick Functions

Source: https://pyharmonics.readthedocs.io/en/latest/quick_start.html

Imports all necessary components from the pyharmonics.quick module, including market data classes, technical analysis tools, search utilities, position management, plotting functionalities, and constants.

```python
from pyharmonics.quick import *

from pyharmonics.marketdata import YahooCandleData, BinanceCandleData, YahooOptionData
from pyharmonics.technicals import OHLCTechnicals, Technicals
from pyharmonics.search import HarmonicSearch, DivergenceSearch
from pyharmonics.positions import Position
from pyharmonics.plotter import HarmonicPlotter, PositionPlotter, OptionPlotter
from pyharmonics import constants
```

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

### GET /get_peak_x_y

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

Retrieves the time and price data for identified peaks within the technical dataset.

```APIDOC
## GET /get_peak_x_y

### Description
Returns the time and prices at specific indexes for a given peak type found in the technical data.

### Method
GET

### Endpoint
/get_peak_x_y

### Parameters
#### Query Parameters
- **peak_type** (str) - Required - The series containing True or False where True marks a peak on this trend.

### Request Example
{
  "peak_type": "price_peaks"
}

### Response
#### Success Response (200)
- **data** (tuple) - A tuple containing the time and price values for the requested peak indexes.

#### Response Example
{
  "data": [["2023-04-17 08:59:59", 30485.0], ["2023-04-17 12:59:59", 28000.0]]
}
```

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

### Initialize Technicals and Access DataFrame

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/technicals_guide.rst.txt

Demonstrates how to instantiate the Technicals class using a dataset and configuration parameters, and how to inspect the resulting DataFrame containing calculated technical indicators.

```python
from pyharmonics.technicals import Technicals
from pyharmonics.utils import UER

# Initialize Technicals with data and peak spacing configuration
t = Technicals(UER, 'Unemployment', 'monthly', peak_spacing=6)

# Access the resulting DataFrame
print(t.df)
```

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

### Retrieve and analyze market data

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/index.rst.txt

Demonstrates how to fetch candle data using BinanceCandleData, initialize a Technicals object, and perform a search for harmonic patterns.

```python
from pyharmonics.marketdata import BinanceCandleData
b = BinanceCandleData()
b.get_candles('BTCUSDT', b.MIN_15, 1000)

from pyharmonics.technicals import Technicals
t = Technicals(b.df, b.symbol, b.interval)

from pyharmonics.search import HarmonicSearch
m = HarmonicSearch(t)
m.search()
```

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

### GET /get_candles

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Fetches historical candle data for a specified asset symbol from the configured data source (e.g., Yahoo Finance or Alpaca).

```APIDOC
## GET /get_candles

### Description
Retrieves candle data for a given asset, interval, and optional time range or count.

### Method
GET

### Endpoint
/get_candles

### Parameters
#### Query Parameters
- **symbol** (string) - Required - The asset symbol to fetch (e.g., 'MSFT', 'BTCUSDT').
- **interval** (string) - Required - The time interval (e.g., '1h', '1d', '15m').
- **num_candles** (integer) - Optional - The number of candles to return.
- **start** (datetime) - Optional - The start timestamp for the data range.
- **end** (datetime) - Optional - The end timestamp for the data range.

### Request Example
{
  "symbol": "MSFT",
  "interval": "1h",
  "num_candles": 1000
}

### Response
#### Success Response (200)
- **data** (array) - List of candle objects containing price history.

#### Response Example
{
  "status": "success",
  "data": [{"timestamp": "2020-03-21T14:00:00", "open": 150.0, "close": 155.0}]
}
```

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

### Import Pyharmonics Quick Functions

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/quick_start.rst.txt

Imports all functions from the pyharmonics.quick module. This provides access to various utility functions for market data analysis, technicals, search, positions, and plotting.

```python
>>> from pyharmonics.quick import *

```

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

### GET /get_candles

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Retrieves historical candle data for a specified symbol and interval. Supports fetching by a specific number of candles or within a defined time range.

```APIDOC
## GET /get_candles

### Description
Fetches historical market candle data for a given symbol. If start and end times are provided, it retrieves data within that range; otherwise, it uses the num_candles parameter to fetch a specific count of candles.

### Method
GET

### Endpoint
/get_candles

### Parameters
#### Query Parameters
- **symbol** (str) - Required - The trading symbol to fetch (e.g., 'BTCUSDT').
- **interval** (TimeFrame) - Required - The time interval for the candles (e.g., '1h', '15m').
- **num_candles** (int) - Optional - The number of candles to fetch (default 1000 limit per block).
- **start** (datetime) - Optional - The start time for the candle range.
- **end** (datetime) - Optional - The end time for the candle range.

### Request Example
{
  "symbol": "BTCUSDT",
  "interval": "1h",
  "num_candles": 1000
}

### Response
#### Success Response (200)
- **data** (DataFrame) - The resulting candle data stored in the instance's dataframe.

#### Response Example
{
  "status": "success",
  "message": "1000 1 hour candles of BTCUSDT retrieved successfully"
}
```

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

### pyharmonics.quick Module

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

This module provides quick functions for analyzing market data and identifying forming patterns.

```APIDOC
## Module: pyharmonics.quick

### Description
Provides convenient functions for quickly analyzing market data and identifying forming patterns.

### Functions
- **play_position()**: Plays a position.
- **whats_forming()**: Identifies forming patterns.
- **whats_forming_binance()**: Identifies forming patterns on Binance data.
- **whats_forming_yahoo()**: Identifies forming patterns on Yahoo Finance data.
- **whats_new()**: Identifies new patterns.
- **whats_new_binance()**: Identifies new patterns on Binance data.
- **whats_new_yahoo()**: Identifies new patterns on Yahoo Finance data.
- **whats_options_interest()**: Analyzes options interest.
- **whats_options_volume()**: Analyzes options volume.
```

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

### Initialize and Configure AlpacaCandleData

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/alpaca.html

Demonstrates how to instantiate the AlpacaCandleData class with custom schemas or time zones. The class requires API credentials to initialize the REST client for data retrieval.

```python
from pyharmonics.marketdata.alpaca import AlpacaCandleData

# Initialize with default settings
a = AlpacaCandleData(key={'api': 'YOUR_KEY', 'secret': 'YOUR_SECRET'})

# Initialize with custom schema and timezone
schema = [{"name": "open_time", "type": "int64"}, {"name": "open", "type": "float"}]
a = AlpacaCandleData(key={'api': 'YOUR_KEY', 'secret': 'YOUR_SECRET'}, schema=schema, time_zone='Europe/Dublin')
```

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

### Get Time at Index - Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/technicals.html

Retrieves the timestamps corresponding to a given list of index positions from the DataFrame. This is useful for mapping numerical index positions back to their actual time values.

```python
def get_index_x(self, x):
        """
        given the index of a pattern found in this technical data,
        return the time at those indexes.

        >>> t = OHLCTechnicals(df, symbol, time_frame)
        >>> t.get_index_x([1, 2, 3])
        [Timestamp('2023-04-17 08:59:59+0100', tz='Europe/Dublin'),
         Timestamp('2023-04-17 12:59:59+0100', tz='Europe/Dublin'),
         Timestamp('2023-04-17 16:59:59+0100', tz='Europe/Dublin')]

        :param x: list
            The indexes within technical_data.peak_indexes and technical_data.peak_prices that form the pattern.
        :return: list
        """
        return list(self.df.index[x])
```

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

### Retrieve Market Candle Data

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/alpaca.html

Shows how to use the get_candles method to fetch historical price data for specific symbols and intervals. Supports filtering by start and end timestamps.

```python
import datetime

# Fetch 1000 1-hour candles
m.get_candles('BTCUSDT', '1h', num_candles=1000)

# Fetch candles leading up to a specific date
m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))

# Fetch candles from a start date until present
m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

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

### Plotting Forming Patterns

Source: https://pyharmonics.readthedocs.io/en/latest/plotting_guide.html

Shows how to search for patterns that are currently forming and visualize them using the Plotter class.

```python
m = harmonicSearch(t)
m.forming()
p = Plotter(t, 'BTCUSDT', b.HOUR_1)
p.add_harmonic_plots(m.get_patterns(formed=False))
p.show()
```

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

### Get Alpaca Candle Data

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Retrieves candle data for cryptocurrencies from Alpaca. Allows specifying the symbol, interval, number of candles, and start/end times for the data retrieval. Useful for historical price analysis.

```python
>>> m = BinanceCandleData() # 200 1 hour candles of BTCUSDT price history
```

```python
>>> m.get_candles('BTCUSDT', '1h', num_candles=1000) # 1000 1 hour candles of BTCUSDT price history
```

```python
>>> m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))
# 1000 1 hour candles of BTCUSDT price history leading up to 21st march 2020
```

```python
>>> m.get_candles('BTCUSDT', '1h', num_candles=1000, start=datetime.datetime(2020, 3, 21, 14, 0, 15))
# 1000 candle data from 21st of march 2020 until present
```

```python
>>> m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

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

### Harmonic Search Initialization and Forming Pattern Detection

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.search.html

Initializes the HarmonicSearch class and demonstrates how to find harmonic patterns that are currently forming. It allows limiting the search to patterns projected to complete within a certain number of candles and specifying the completion percentage.

```python
from pyharmonics.search import HarmonicSearch

# Assuming 't' is an initialized technicals object
h = HarmonicSearch(t)
h.forming()
patterns = h.get_patterns(formed=False)
```

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

### Get Pattern Direction - Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/utils.html

Determines the direction (bullish or bearish) of a price pattern based on the last two price points. It assumes a simple comparison where a decrease indicates bullishness and an increase indicates bearishness.

```python
def get_pattern_direction(prices: list) -> str:
    """
    All patterns forming a final retrace where the price is moving up are
    indicating a reversal to the downside is iminent.  This is bearish.

    >>> utils.get_pattern_direction([1.0, 2.0, 3.0])
    'bullish'
    >>> utils.get_pattern_direction([3.0, 2.0, 1.0])
    'bearish'

    :param prices: The prices of the pattern.
    :return: The direction of the pattern
    """
    if prices[-1] < prices[-2]:
        return constants.BULLISH
    else:
        return constants.BEARISH
```

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

### Import Pyharmonics Core Modules

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/quick_start.rst.txt

Imports essential classes and modules from Pyharmonics, including data providers (YahooCandleData, BinanceCandleData, YahooOptionData), technical analysis tools (OHLCTechnicals, Technicals), search functionalities (HarmonicSearch, DivergenceSearch), position management (Position), plotting utilities (HarmonicPlotter, PositionPlotter, OptionPlotter), and constants.

```python
from pyharmonics.marketdata import YahooCandleData, BinanceCandleData, YahooOptionData
from pyharmonics.technicals import OHLCTechnicals, Technicals
from pyharmonics.search import HarmonicSearch, DivergenceSearch
from pyharmonics.positions import Position
from pyharmonics.plotter import HarmonicPlotter, PositionPlotter, OptionPlotter
from pyharmonics import constants

```

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

### Initialize OHLCTechnicals and Fetch Candle Data (Python)

Source: https://pyharmonics.readthedocs.io/en/latest/technicals_guide.html

This snippet shows how to initialize the BinanceCandleData object, fetch OHLC candle data for a given asset and interval, and then initialize the OHLCTechnicals object with the fetched data. It also demonstrates handling a common ValueError by ensuring candle data is retrieved before initializing OHLCTechnicals.

```python
from pyharmonics.marketdata import BinanceCandleData
from pyharmonics.technicals import OHLCTechnicals

b = BinanceCandleData()
t = OHLCTechnicals(b.df, b.symbol, b.interval, peak_spacing=20)
# ValueError: Candle DataFrame is None! call cd.get_candles(ASSET, INTERVAL) first.

b.get_candles('ETHUSDT', b.HOUR_4, 400)
t = OHLCTechnicals(b.df, b.symbol, b.interval)
print(t.df)
```

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

### Fetch and Process Market Candles

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/yahoo.html

Retrieves historical candle data for a specific asset using yfinance. It handles parameter setup, data fetching, column renaming, and time zone conversion.

```python
def get_candles(self, symbol, interval, num_candles=None, start=None, end=None):
    self.df = None
    self._set_params(symbol, interval, num_candles=num_candles, start=start, end=end)
    tick = yf.Ticker(self.symbol)
    self.df = tick.history(
        period=self.LIMITS[self.interval],
        interval=self.INTERVALS[self.interval],
        start=self._epoch_to_datetime(self.start),
        end=self._epoch_to_datetime(self.end)
    )
    self._trim_data()
    rename_columns = {c: c.lower().replace(' ', '_') for c in self.df.columns}
    self.df = self.df.rename(columns=rename_columns)
    self.df[self.CLOSE_TIME] = self.df.index.map(lambda d: self._datetime_to_epoch(d))
    self.df[self.DTS] = pd.to_datetime(self.df[self.CLOSE_TIME], unit='s', utc=True).dt.tz_convert(self.time_zone)
    self.reset_index()
```

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

### Divergence Search Initialization and Usage

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.search.html

Initializes the DivergenceSearch class and demonstrates its usage for finding price divergences. It allows searching for divergences within a specified candle spread and limiting the number of results.

```python
from pyharmonics.search import DivergenceSearch

# Assuming 'technicals' is an initialized TechnicalsBase object
d = DivergenceSearch(technicals)
d.search()
d.search(limit_to=5)
```

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

### Get Candle Span - Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/utils.html

Calculates a list of candle time indexes within a specified span around a given candle time. It takes the candle time, the gap between candles, and the number of gaps to include on either side as input.

```python
def get_candle_span(candle_time, candle_gap: int, num_gaps: int) -> list:
    """
    Get the span of candles around the given candle time.

    >>> utils.get_candle_span(10, 1, 3)
    [7, 8, 9, 10, 11, 12, 13]
    >>> utils.get_candle_span(100, 10, 3)
    [70, 80, 90, 100, 110, 120, 130]

    :param candle_time: The time index to span.
    :param candle_gap: The gap between candles.
    :param num_gaps: The number of gaps to span.
    :return: The list of time indexes
    """
    return list(range(candle_time - (candle_gap * num_gaps), candle_time + (candle_gap * num_gaps) + candle_gap, candle_gap))
```

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

### pyharmonics.marketdata Package

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

This package is likely to contain functionalities related to fetching and managing market data.

```APIDOC
## Package: pyharmonics.marketdata

### Description
This package is dedicated to handling and processing market data, potentially including fetching, cleaning, and structuring time-series financial data.
```

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

### Fetch Market Candle Data

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.marketdata.html

Retrieves historical candle data for a specified symbol and interval. Supports fetching by a specific number of candles or within a defined start and end time range, automatically handling pagination for large requests.

```python
a.get_candles('BTCUSDT', TimeFrame(1, TimeFrameUnit.Hour), num_candles=1000)
a.get_candles('BTCUSDT', TimeFrame(1, TimeFrameUnit.Hour), start=datetime.datetime(2020, 3, 21, 14, 0, 15))
a.get_candles('BTCUSDT', TimeFrame(1, TimeFrameUnit.Hour), end=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

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

### Initialize OHLCTechnicals with OHLC Data (Python)

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/technicals_guide.rst.txt

Demonstrates initializing the OHLCTechnicals object with OHLC data. It requires a DataFrame with OHLCV columns, symbol, and interval. An error occurs if candle data is not fetched first.

```python
from pyharmonics.marketdata import BinanceCandleData
from pyharmonics.technicals import OHLCTechnicals
b = BinanceCandleData()
t = OHLCTechnicals(b.df, b.symbol, b.interval, peak_spacing=20)

```

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

### pyharmonics.search Package

Source: https://pyharmonics.readthedocs.io/en/latest/pyharmonics.html

This package likely contains modules for searching and identifying specific patterns within market data.

```APIDOC
## Package: pyharmonics.search

### Description
This package is designed for implementing search algorithms to identify specific harmonic patterns or other market structures within financial datasets.
```

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

### Fetch Candlestick Data - Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/binance_data.html

Fetches historical candlestick data for a given symbol and interval from Binance. It supports fetching a specific number of candles, a range between start and end times, or a combination. For large requests, it efficiently retrieves data in blocks of 1000 candles to manage API limits and performance.

```python
def get_candles(self, symbol, interval, num_candles=None, start=None, end=None):
        """
        If start and end are defined all candles between those time ranges will be pulled
        and stored in self.df.  This is done using multiple calls.
        This is done in blocks of 1000 candles.

        If only start or end or both are None, then a single call is made.
        If num_candles is greater than 1000 then multiple calls are made to get the data.

        >>> m.get_candles('BTCUSDT', '1h', num_candles=1000)
        >>> m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))
        >>> m.get_candles('BTCUSDT', '1h', num_candles=1000, start=datetime.datetime(2020, 3, 21, 14, 0, 15))
        >>> m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))

        :param symbol: The symbol to fetch.
        :param interval: The interval to fetch.
        :param num_candles: The number of candles to fetch.
        :param start: The start time for a range of candles.
        :param end: The end time for a range of candles.
        """
        self.df = None
        row_data = []
        if interval not in self.INTERVALS:
            raise InvalidTimeframe(f"Binance timeframe intervals must be one of {self.INTERVALS}")

        self._set_params(symbol, interval, num_candles=num_candles, start=start, end=end)
        # Start and end are explicit.

        if self.start and self.end:
            start_index = self.start
            end_index = self.end
            while start_index <= end_index:
                block_data = self._get_candle_block(end=end_index)
                if len(block_data) < 2:
                    break
                end_index = block_data[0][0]
                row_data += block_data
            block_data = self._get_candle_block()
        elif self.num_candles > self.MAX_CANDLES:
            candles_remaining = self.num_candles
            time_index = self._datetime_to_epoch(self.end or datetime.datetime.now())
            while candles_remaining > 0:
                block_data = self._get_candle_block(end=time_index, num_candles=min(self.MAX_CANDLES, candles_remaining))
                if len(block_data) < 2:
                    break
                time_index = block_data[0][0]
                candles_remaining -= len(block_data)
                row_data += block_data
        else:
            # Start + num_candles  OR (end OR now ) - num_candles is returned
            row_data = self._get_candle_block(start=self.start, end=self.end, num_candles=self.num_candles)
        self.df = self._to_dataframe(row_data)
        row_data = None
        self.reset_index()
```

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

### Fetch and Analyze Yahoo Finance Data with Python

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/quick.html

These functions automate the process of fetching Yahoo Finance candle data and passing it to the analysis engine for pattern detection.

```python
def whats_new_yahoo(symbol, interval, limit_to=-1, candles=1000):
    yc = YahooCandleData()
    yc.get_candles(symbol, interval, candles)
    return whats_new(yc, limit_to=limit_to)
```

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

### Plotting Harmonic Patterns

Source: https://pyharmonics.readthedocs.io/en/latest/plotting_guide.html

Demonstrates how to initialize a Plotter object to visualize specific harmonic pattern families or all discovered patterns on a given ticker and interval.

```python
from pyharmonics.plotter import Plotter
# Plot specific family
p = Plotter(t, 'BTCUSDT', b.HOUR_1)
p.add_harmonic_plots(m.get_patterns(family=m.XABCD))
p.show()

# Plot all patterns
p = Plotter(t, 'BTCUSDT', b.HOUR_1)
p.add_harmonic_plots(m.get_patterns())
p.show()
```

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

### Initialize and Fetch Binance Market Data

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/marketdata/binance_data.html

Demonstrates how to instantiate the BinanceCandleData class and retrieve historical candle data using various time parameters. Note that Binance limits API calls to a maximum of 1000 candles per request.

```python
from pyharmonics.marketdata.binance_data import BinanceCandleData
import datetime

# Instantiate the class
m = BinanceCandleData()

# Fetch 1000 candles of 1-hour BTCUSDT data
m.get_candles('BTCUSDT', '1h', num_candles=1000)

# Fetch data leading up to a specific date
m.get_candles('BTCUSDT', '1h', num_candles=1000, end=datetime.datetime(2020, 3, 21, 14, 0, 15))

# Fetch data from a specific start date until present
m.get_candles('BTCUSDT', '1h', start=datetime.datetime(2020, 3, 21, 14, 0, 15))
```

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

### Identify Formed Harmonic Patterns (Binance and Yahoo)

Source: https://pyharmonics.readthedocs.io/en/latest/_sources/quick_start.rst.txt

These functions identify and report on completed harmonic patterns (ABC, ABCD, XABCD) on a given asset. The `limit_to` parameter can be used to filter patterns based on their completion time, with a recommended value of 3 for recent patterns. `percent_complete` filters patterns based on how close they are to completion.

```python
whats_forming_binance(symbol, interval, limit_to=10, percent_complete=0.8, candles=1000)

```

```python
whats_forming_yahoo(symbol, interval, limit_to=10, percent_complete=0.8, candles=1000)

```

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

### Initialize OptionPlotter and Configure Main Plot

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/plotter/option.html

The OptionPlotter class constructor initializes the option chain data and visual settings. The set_main_plot method constructs a multi-subplot layout using Plotly, integrating trend, price, and pain metrics.

```python
class OptionPlotter:
    def __init__(self, yo, expiry):
        self.yo = yo
        self.options = yo.options[expiry]
        self.expiry = expiry
        self.price = yo.price
        self.symbol = yo.symbol
        self.min_pain = self.options.min_pain
        self.title = f"{self.symbol} - {self.expiry}"
        self.set_main_plot()

    def set_main_plot(self):
        self.main_plot = make_subplots(
            rows=2, cols=2, shared_xaxes=False,
            vertical_spacing=0.1,
            row_heights=[.5, .4], column_widths=[.6, .4]
        )
        self.main_plot.update_layout(template='plotly_dark', title=self.title)
```

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

### Initialize HarmonicPlotter

Source: https://pyharmonics.readthedocs.io/en/latest/_modules/pyharmonics/plotter/harmonic.html

Constructor for the HarmonicPlotter class, which extends PlotterBase to handle specific harmonic pattern visualization requirements.

```python
class HarmonicPlotter(PlotterBase):
    def __init__(self, technicals: OHLCTechnicals, row_map=None, colors=None, plot_ema=False, plot_sma=True):
        super().__init__(technicals, row_map, colors, plot_ema, plot_sma)
```

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

### Search and visualize harmonic patterns

Source: https://pyharmonics.readthedocs.io/en/latest/index.html

Shows how to use the HarmonicSearch class to identify patterns and the Plotter class to visualize them. Users can filter by pattern family or search for patterns that are currently forming.

```python
from pyharmonics.search import HarmonicSearch
from pyharmonics.plotter import Plotter

# Search for patterns
m = HarmonicSearch(t)
m.search()

# Plot findings
p = Plotter(t, 'BTCUSDT', b.MIN_15)
p.add_harmonic_plots(m.get_patterns(family=m.XABCD))
p.show()

# Search for forming patterns
h = HarmonicSearch(t)
h.forming()
p.add_harmonic_plots(h.get_patterns(formed=False))
p.show()
```

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

### Authenticate and Fetch Data with Alpaca

Source: https://pyharmonics.readthedocs.io/en/latest/market_data_guide.html

Shows how to provide API credentials to the AlpacaCandleData class to fetch market data. Note that Alpaca requires both a key and a secret dictionary.

```python
from pyharmonics.marketdata import AlpacaCandleData
key = {'api': 'whatever', 'secret': 'whatever'}
a = AlpacaCandleData(key)
a.get_candles('QQQ', a.MIN_5, 300)
```
Tokens:
Raw