auto-chart-patterns 0.1.0__py3-none-any.whl

auto_chart_patterns/chart_pattern.py

@@ -0,0 +1,169 @@
+from dataclasses import dataclass
+from typing import List, Dict
+from abc import abstractmethod
+from .line import Pivot
+from .zigzag import Zigzag
+import numpy as np
+
+import logging
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ChartPatternProperties:
+    offset: int = 0
+    min_periods_lapsed: int = 21
+    max_live_patterns: int = 50
+    avoid_overlap: bool = True # whether to avoid overlapping patterns
+    allowed_patterns: List[bool] = None
+    allowed_last_pivot_directions: List[int] = None
+
+@dataclass
+class ChartPattern:
+    """Base class for chart patterns"""
+    pivots: List[Pivot]
+    pattern_type: int = 0
+    pattern_name: str = ""
+    extra_props: Dict = None # for adding extra properties, not serialized
+
+    def dict(self):
+        return {
+            "pivots": [p.dict() for p in self.pivots],
+            "pattern_type": self.pattern_type,
+            "pattern_name": self.pattern_name
+        }
+
+    def __eq__(self, other: 'ChartPattern') -> bool:
+        other_pivot_indexes = [p.point.time for p in other.pivots]
+        self_pivot_indexes = [p.point.time for p in self.pivots]
+        return self.pattern_type == other.pattern_type and \
+            self_pivot_indexes == other_pivot_indexes
+
+    @classmethod
+    def from_dict(cls, dict: dict):
+        self = cls(pivots=[Pivot.from_dict(p) for p in dict["pivots"]],
+                   pattern_type=dict["pattern_type"],
+                   pattern_name=dict["pattern_name"])
+        return self
+
+    @abstractmethod
+    def get_pattern_name_by_id(self, pattern_type: int) -> str:
+        """Get pattern name from pattern type ID
+
+        Args:
+            pattern_type: Pattern type identifier
+
+        Returns:
+            str: Name of the pattern
+        """
+        pass
+
+    def process_pattern(self, properties: ChartPatternProperties,
+                       patterns: List['ChartPattern']) -> bool:
+        """
+        Process a new pattern: validate it, check if it's allowed, and manage pattern list
+
+        Args:
+            properties: Scan properties
+            patterns: List of existing patterns
+            max_live_patterns: Maximum number of patterns to keep
+
+        Returns:
+            bool: True if pattern was successfully processed and added
+        """
+        # Log warning if invalid pattern type detected
+        if self.pattern_type == 0:
+            return False
+
+        # Get last direction from the last pivot
+        last_dir = self.pivots[-1].direction
+
+        # Get allowed last pivot direction for this pattern type
+        allowed_last_pivot_direction = 0
+        if properties.allowed_last_pivot_directions is not None:
+            if self.pattern_type < len(properties.allowed_last_pivot_directions):
+                allowed_last_pivot_direction = properties.allowed_last_pivot_directions[self.pattern_type]
+
+        # Check if pattern type is allowed
+        pattern_allowed = True
+        if properties.allowed_patterns is not None:
+            if self.pattern_type > len(properties.allowed_patterns):
+                pattern_allowed = False
+            else:
+                pattern_allowed = (self.pattern_type > 0 and
+                                properties.allowed_patterns[self.pattern_type-1])
+
+        # Check if direction is allowed
+        direction_allowed = (allowed_last_pivot_direction == 0 or
+                           allowed_last_pivot_direction == last_dir)
+
+        if pattern_allowed and direction_allowed:
+            # Check for existing pattern with same pivots
+            existing_pattern = False
+            replacing_patterns = []
+
+            for idx, existing in enumerate(patterns):
+                # Check if pivots match
+                existing_indexes = set([p.point.time for p in existing.pivots])
+                self_indexes = set([p.point.time for p in self.pivots])
+                # check if the indexes of self.pivots are a subset of existing.pivots
+                if self_indexes == existing_indexes:
+                    existing_pattern = True
+                    break
+                elif self_indexes.issubset(existing_indexes) and properties.avoid_overlap:
+                    existing_pattern = True
+                    break
+                elif existing_indexes.issubset(self_indexes) and properties.avoid_overlap:
+                    replacing_patterns.append(idx)
+
+            if not existing_pattern:
+                for idx in replacing_patterns:
+                    patterns.pop(idx)
+
+                # Set pattern name
+                self.pattern_name = self.get_pattern_name_by_id(self.pattern_type)
+
+                # Add new pattern and manage list size
+                patterns.append(self)
+                while len(patterns) > properties.max_live_patterns:
+                    patterns.pop(0)
+
+                return True
+
+        return False
+
+def get_pivots_from_zigzag(zigzag: Zigzag, pivots: List[Pivot], offset: int, min_pivots: int) -> int:
+    for i in range(min_pivots):
+        pivot = zigzag.get_pivot(i + offset)
+        if pivot is None:
+            return i
+        pivots.insert(0, pivot.deep_copy())
+    return i+1
+
+def is_same_height(pivot1: Pivot, pivot2: Pivot, ref_pivots: List[Pivot], flat_ratio: float) -> bool:
+    # check if two pivots are approximately flat with a list of reference pivots
+    # use the first and last pivots in the list as reference points
+    if np.sign(pivot1.direction) != np.sign(pivot2.direction):
+        raise ValueError("Pivots must have the same direction")
+
+    # use the reference pivots to calculate the height ratio
+    if pivot1.direction > 0:
+        ref_prices = np.min([p.point.price for p in ref_pivots])
+    else:
+        ref_prices = np.max([p.point.price for p in ref_pivots])
+
+    diff1 = pivot1.point.price - ref_prices
+    diff2 = pivot2.point.price - ref_prices
+    if diff2 == 0:
+        return False
+
+    ratio = diff1 / diff2
+    fit_pct = 1 - flat_ratio
+    if ratio < 1:
+        same_height = ratio >= fit_pct
+    else:
+        same_height = ratio <= 1 / fit_pct
+    logger.debug(f"Pivot {pivot1.point.index} ({pivot1.point.price:.4f}) "
+                 f"and {pivot2.point.index} ({pivot2.point.price:.4f}), "
+                 f"ref_prices: {ref_prices:.4f}, ratio: {ratio:.4f}")
+    return same_height
+

auto_chart_patterns/line.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+import pandas as pd
+@dataclass
+class Point:
+    time: str
+    index: int
+    price: float
+
+    def dict(self):
+        return {
+            "time": str(self.time),
+            "price": float(self.price)
+        }
+
+    @classmethod
+    def from_dict(cls, dict: dict):
+        self = cls(time=pd.to_datetime(dict["time"]),
+                   index=0,
+                   price=dict["price"])
+        return self
+
+    def copy(self):
+        return Point(self.time, self.index, self.price)
+
+@dataclass
+class Pivot:
+    point: Point
+    direction: int # 1 for high, -1 for low
+    diff: float = 0.0 # price difference between the pivot and the previous pivot
+    index_diff: int = 0 # index difference between the pivot and the previous pivot
+    cross_diff: float = 0.0 # price difference between the pivot and the previous pivot of the same direction
+
+    def dict(self):
+        return {
+            "point": self.point.dict(),
+            "direction": self.direction
+        }
+
+    @classmethod
+    def from_dict(cls, dict: dict):
+        self = cls(point=Point.from_dict(dict["point"]),
+                   direction=dict["direction"])
+        return self
+
+    def deep_copy(self):
+        return Pivot(
+            point=self.point.copy(),
+            direction=self.direction,
+            cross_diff=self.cross_diff,
+            diff=self.diff,
+            index_diff=self.index_diff
+        )
+
+@dataclass
+class Line:
+    def dict(self):
+        return {
+            "p1": self.p1.dict(),
+            "p2": self.p2.dict()
+        }
+
+    @classmethod
+    def from_dict(cls, dict):
+        return cls(p1=Point.from_dict(dict["p1"]), p2=Point.from_dict(dict["p2"]))
+
+    def __init__(self, p1: Point, p2: Point):
+        self.p1 = p1
+        self.p2 = p2
+
+    def get_price(self, index: int) -> float:
+        """Calculate price at given index using linear interpolation"""
+        if self.p2.index == self.p1.index:
+            return self.p1.price
+
+        slope = (self.p2.price - self.p1.price) / (self.p2.index - self.p1.index)
+        return self.p1.price + slope * (index - self.p1.index)
+
+    def get_slope(self) -> float:
+        if self.p2.index == self.p1.index:
+            return 0.0
+        return (self.p2.price - self.p1.price) / (self.p2.index - self.p1.index)
+
+    def copy(self):
+        return Line(self.p1.copy(), self.p2.copy())

auto_chart_patterns/reversal_patterns.py

@@ -0,0 +1,202 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from .chart_pattern import ChartPattern, ChartPatternProperties, get_pivots_from_zigzag, \
+    is_same_height
+from .line import Pivot, Line, Point
+from .zigzag import Zigzag
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ReversalPatternProperties(ChartPatternProperties):
+    # minimum number of days to form a pattern
+    min_periods_lapsed: int = 15
+    # maximum allowed ratio between aligned horizontal pivots
+    flat_ratio: float = 0.15
+    # maximum allowed ratio between the two side peaks and the middle peak
+    peak_symmetry_ratio: float = 0.5
+
+class ReversalPattern(ChartPattern):
+    def __init__(self, pivots: List[Pivot], support_line: Line):
+        self.pivots = pivots
+        self.pivots_count = len(pivots)
+        self.support_line = support_line
+        self.extra_props = {}
+
+    @classmethod
+    def from_dict(cls, dict):
+        self = cls(pivots=[Pivot.from_dict(p) for p in dict["pivots"]],
+                   support_line=Line.from_dict(dict["support_line"]))
+        self.pattern_type = dict["pattern_type"]
+        self.pattern_name = dict["pattern_name"]
+        return self
+
+    def dict(self):
+        obj = super().dict()
+        obj["support_line"] = self.support_line.dict()
+        return obj
+
+    def get_pattern_name_by_id(self, id: int) -> str:
+        pattern_names = {
+            1: "Double Tops",
+            2: "Double Bottoms",
+            3: "Triple Tops",
+            4: "Triple Bottoms",
+            5: "Head and Shoulders",
+            6: "Inverted Head and Shoulders",
+        }
+        return pattern_names[id]
+
+    def resolve(self, properties: ReversalPatternProperties) -> 'ReversalPattern':
+        self.pattern_type = 0
+        if self.pivots_count == 5:
+            if self.pivots[0].direction < 0:
+                self.pattern_type = 1 # Double Tops
+            else:
+                self.pattern_type = 2 # Double Bottoms
+        elif self.pivots_count == 7:
+            if is_same_height(self.pivots[1], self.pivots[5], self.pivots, properties.flat_ratio):
+                # check if three pivots are approximately flat
+                if is_same_height(self.pivots[1], self.pivots[3], self.pivots, properties.flat_ratio) and \
+                    is_same_height(self.pivots[3], self.pivots[5], self.pivots, properties.flat_ratio):
+                    # 3 pivots are approximately flat, we have a triple top or bottom
+                    logger.debug(f"Pivots: {self.pivots[1].point.index}, {self.pivots[3].point.index}, "
+                                 f"{self.pivots[5].point.index} are flat")
+                    if self.pivots[0].direction < 0:
+                        self.pattern_type = 3 # Triple Tops
+                    else:
+                        self.pattern_type = 4 # Triple Bottoms
+                # check if the side peaks are lower than the middle peak
+                elif self.pivots[0].direction < 0 and self.pivots[3].cross_diff > 0 and \
+                    self.pivots[5].cross_diff < 0:
+                    self.pattern_type = 5 # Head and Shoulders
+                elif self.pivots[0].direction > 0 and self.pivots[3].cross_diff < 0 and \
+                    self.pivots[5].cross_diff > 0:
+                    self.pattern_type = 6 # Inverted Head and Shoulders
+        else:
+            raise ValueError("Invalid number of pivots")
+        return self
+
+def check_peak_symmetry(diff1: int, diff2: int, threshold: float) -> bool:
+    # check the symmetry of the side peaks and the middle peak
+    ratio = float(diff1) / float(diff2)
+    fit_pct = 1 - threshold
+    if ratio < 1:
+        valid = ratio >= fit_pct
+    else:
+        valid = ratio <= 1 / fit_pct
+    return valid
+
+def inspect_five_pivot_pattern(pivots: List[Pivot], properties: ReversalPatternProperties) -> bool:
+    # check tops or bottoms are approximately flat
+    if is_same_height(pivots[1], pivots[3], pivots, properties.flat_ratio):
+        if pivots[0].direction > 0:
+            # may be a double bottom, check the sandle point price
+            if pivots[2].point.price < pivots[0].point.price or \
+                pivots[2].point.price < pivots[4].point.price:
+                return True
+        else:
+            # may be a double top, check the sandle point price
+            if pivots[2].point.price > pivots[0].point.price or \
+                pivots[2].point.price > pivots[4].point.price:
+                return True
+    return False
+
+def inspect_seven_pivot_pattern(pivots: List[Pivot], properties: ReversalPatternProperties) -> bool:
+    # check the double sandle points price range and flat ratio
+    if pivots[0].direction > 0:
+        if pivots[2].point.price >= pivots[0].point.price or \
+            pivots[4].point.price >= pivots[0].point.price:
+            return False
+    else:
+        if pivots[2].point.price <= pivots[0].point.price or \
+            pivots[4].point.price <= pivots[0].point.price:
+            return False
+    # check the symmetry of the side peaks and the middle peak
+    return check_peak_symmetry(pivots[3].point.index - pivots[1].point.index,
+                              pivots[5].point.index - pivots[3].point.index,
+                              properties.peak_symmetry_ratio)
+
+def find_cross_point(line: Line, start_index: int, end_index: int, zigzag: Zigzag) -> Optional[Point]:
+    if start_index > end_index:
+        return None
+    for i in range(start_index, end_index):
+        current = zigzag.get_df_data_by_index(i)
+        high = current['high']
+        low = current['low']
+        price = line.get_price(i)
+        if high >= price and low <= price:
+            return Point(zigzag.get_df_data_by_index(i).name, i, price)
+    return None
+
+def get_support_line(pivots: List[Pivot], start_index: int, end_index: int, zigzag: Zigzag) -> Optional[Line]:
+    if len(pivots) > 2:
+        raise ValueError("At most two points are required to form a line")
+    if len(pivots) == 1:
+        line = Line(pivots[0].point, pivots[0].point)
+        cross_point2 = find_cross_point(line, pivots[0].point.index+1, end_index, zigzag)
+    else:
+        line = Line(pivots[0].point, pivots[1].point)
+        cross_point2 = find_cross_point(line, pivots[1].point.index+1, end_index, zigzag)
+
+    cross_point1 = find_cross_point(line, start_index, pivots[0].point.index, zigzag)
+    if cross_point1 is None:
+        # the line is not crossing the chart on the left side
+        return None
+    # the cross point on the right side can be none as the chart is still trending
+    if cross_point2 is None:
+        cross_point2 = Point(zigzag.get_df_data_by_index(end_index).name,
+                             end_index, line.get_price(end_index))
+    return Line(cross_point1, cross_point2)
+
+def find_reversal_patterns(zigzag: Zigzag, offset: int, properties: ReversalPatternProperties,
+                  patterns: List[ReversalPattern]) -> bool:
+    """
+    Find reversal patterns using zigzag pivots
+
+    Args:
+        zigzag: Zigzag instance
+        offset: Offset to start searching for pivots
+        properties: Reversal pattern properties
+        patterns: List to store found patterns
+
+    Returns:
+        List[ReversalPattern]: Found patterns
+    """
+    found_7_pattern = False
+    found_5_pattern = False
+    pivots = []
+    pivots_count = get_pivots_from_zigzag(zigzag, pivots, offset, 7)
+    if pivots_count == 7:
+        if inspect_seven_pivot_pattern(pivots, properties):
+            # we may have a triple top or bottom or head and shoulders
+            support_line = get_support_line(
+                [pivots[2], pivots[4]], pivots[0].point.index, pivots[6].point.index, zigzag)
+
+            index_delta = pivots[-1].point.index - pivots[0].point.index + 1
+            if support_line is not None and index_delta >= properties.min_periods_lapsed:
+                pattern = ReversalPattern(pivots, support_line).resolve(properties)
+                found_7_pattern = pattern.process_pattern(properties, patterns)
+
+    # continue to inspect 5 point pattern
+    if pivots_count >= 5:
+        for i in range(0, pivots_count - 5 + 1):
+            pivots = []
+            get_pivots_from_zigzag(zigzag, pivots, offset + i, 5) # check the last 5 pivots as the pivots are in reverse order
+            if inspect_five_pivot_pattern(pivots, properties):
+                # use the sandle point to form a support line
+                support_line = get_support_line(
+                    [pivots[2]], pivots[0].point.index, pivots[4].point.index, zigzag)
+
+                index_delta = pivots[-1].point.index - pivots[0].point.index + 1
+                if support_line is not None and index_delta >= properties.min_periods_lapsed:
+                    pattern = ReversalPattern(pivots, support_line).resolve(properties)
+                    found = pattern.process_pattern(properties, patterns)
+
+                    if found:
+                        found_5_pattern = True
+
+    return found_7_pattern or found_5_pattern
+
+

auto_chart_patterns/rsi_div_patterns.py

@@ -0,0 +1,146 @@
+from dataclasses import dataclass
+from auto_chart_patterns.chart_pattern import ChartPatternProperties
+from auto_chart_patterns.line import Line, Point
+from auto_chart_patterns.zigzag import window_peaks
+from typing import List
+import pandas as pd
+import logging
+
+log = logging.getLogger(__name__)
+
+@dataclass
+class RsiDivergenceProperties(ChartPatternProperties):
+    min_periods_lapsed: int = 5 # minimum number of days to form a pattern
+    min_change_pct: float = 0.005 # minimum change percentage
+
+class RsiDivergencePattern:
+    def __init__(self, points: List[Point], divergence_line: Line, is_high_pivots: bool):
+        self.points = points
+        self.divergence_line = divergence_line
+        self.is_high_pivots = is_high_pivots
+
+    def get_pattern_name_by_id(self, id: int) -> str:
+        pattern_names = {
+            1: "Bullish",
+            2: "Bearish",
+            3: "Hidden Bullish",
+            4: "Hidden Bearish",
+        }
+        return pattern_names[id]
+
+    def get_change_direction(self, value1: float, value2: float,
+                             properties: RsiDivergenceProperties) -> int:
+        change_pct = (value2 - value1) / value1
+        if change_pct > properties.min_change_pct:
+            return 1
+        elif change_pct < -properties.min_change_pct:
+            return -1
+        return 0
+
+    def resolve(self, properties: RsiDivergenceProperties) -> 'RsiDivergencePattern':
+        if len(self.points) != 2:
+            raise ValueError("Rsi Divergence must have 2 points")
+        self.pattern_type = 0
+
+        # makes prices always greater than the rsi values
+        price_change_dir = self.get_change_direction(self.points[0].price,
+            self.points[1].price, properties)
+        rsi_change_dir = self.get_change_direction(self.divergence_line.p1.price,
+            self.divergence_line.p2.price, properties)
+
+        log.debug(f"points: {self.points[0].index}, {self.points[1].index}, "
+                  f"rsi: {self.divergence_line.p1.price}, {self.divergence_line.p2.price}, "
+                  f"price_change_dir: {price_change_dir}, rsi_change_dir: {rsi_change_dir}")
+
+        if price_change_dir == 1 and rsi_change_dir == -1:
+            if self.is_high_pivots:
+                # higher high but lower RSI
+                self.pattern_type = 2 # bearish
+            else:
+                # higher low but lower RSI
+                self.pattern_type = 3 # hidden bullish
+        elif price_change_dir == -1 and rsi_change_dir == 1:
+            if self.is_high_pivots:
+                # lower high but higher RSI
+                self.pattern_type = 4 # hidden bearish
+            else:
+                # lower low but higher RSI
+                self.pattern_type = 1 # bullish
+
+        if self.pattern_type != 0:
+            self.pattern_name = self.get_pattern_name_by_id(self.pattern_type)
+        return self
+
+def calc_rsi(prices: pd.DataFrame, period: int = 14) -> pd.Series:
+    """Calculate RSI"""
+    series = prices["close"]
+    ewm = dict(alpha=1.0 / period, min_periods=period, adjust=True, ignore_na=True)
+    diff = series.diff()
+    ups = diff.clip(lower=0).ewm(**ewm).mean()
+    downs = diff.clip(upper=0).abs().ewm(**ewm).mean()
+
+    return 100.0 - (100.0 / (1.0 + ups / downs))
+
+def handle_rsi_pivots(rsi_pivots: pd.DataFrame, is_high_pivots: bool,
+                      properties: RsiDivergenceProperties, patterns: List[RsiDivergencePattern]):
+    if is_high_pivots:
+        rsi_col = 'rsi_high'
+        price_col = 'high'
+    else:
+        rsi_col = 'rsi_low'
+        price_col = 'low'
+
+    for i in range(len(rsi_pivots)-1):
+        current_row = rsi_pivots.iloc[i]
+        next_row = rsi_pivots.iloc[i+1]
+        current_index = current_row['row_number'].astype(int)
+        next_index = next_row['row_number'].astype(int)
+        if next_index - current_index + 1 < properties.min_periods_lapsed:
+            continue
+
+        point1 = Point(current_row.name, current_index,
+                       current_row[rsi_col])
+        point2 = Point(next_row.name, next_index,
+                       next_row[rsi_col])
+        divergence_line = Line(point1, point2)
+        price_points = [Point(current_row.name, current_index,
+                       current_row[price_col]),
+                 Point(next_row.name, next_index,
+                       next_row[price_col])]
+        pattern = RsiDivergencePattern(price_points, divergence_line, is_high_pivots).resolve(properties)
+        if pattern.pattern_type != 0:
+            patterns.append(pattern)
+
+def find_rsi_divergences(backcandles: int, forwardcandles: int,
+                         properties: RsiDivergenceProperties,
+                         patterns: List[RsiDivergencePattern], df: pd.DataFrame):
+    """
+    Find RSI divergences using zigzag pivots
+
+    Args:
+        backcandles: Number of backcandles
+        forwardcandles: Number of forwardcandles
+        properties: RSI divergence properties
+        patterns: List to store found patterns
+        df: DataFrame with prices
+    """
+    # calculate rsi
+    rsi = calc_rsi(df)
+    # get rsi peaks
+    rsi_highs, rsi_lows = window_peaks(rsi, backcandles, forwardcandles)
+    rsi_high_pivots = rsi.where(rsi == rsi_highs)
+    rsi_low_pivots = rsi.where(rsi == rsi_lows)
+    # add row number
+    df['row_number'] = pd.RangeIndex(len(df))
+
+    # Merge for highs - including RSI values
+    rsi_pivots= pd.merge(
+        # Convert Series to DataFrame with column name
+        pd.DataFrame({'rsi_high': rsi_high_pivots, 'rsi_low': rsi_low_pivots}),
+        df[['row_number', 'high', 'low']],
+        left_index=True,
+        right_index=True,
+        how='inner'
+    )
+    handle_rsi_pivots(rsi_pivots[['rsi_high', 'high','row_number']].dropna(), True, properties, patterns)
+    handle_rsi_pivots(rsi_pivots[['rsi_low', 'low','row_number']].dropna(), False, properties, patterns)

auto_chart_patterns/trendline_patterns.py

@@ -0,0 +1,446 @@
+from dataclasses import dataclass
+from typing import List, Tuple, Optional
+import numpy as np
+from .line import Point, Pivot, Line
+from .zigzag import Zigzag
+from .chart_pattern import ChartPattern, ChartPatternProperties, get_pivots_from_zigzag, \
+    is_same_height
+
+import logging
+logger = logging.getLogger(__name__)
+
+@dataclass
+class TrendLineProperties(ChartPatternProperties):
+    number_of_pivots: int = 5 # minimum number of pivots to form a pattern
+    flat_ratio: float = 0.2 # maximum allowed flat ratio between flat trend lines
+    align_ratio: float = 0.4 # maximum allowed ratio between aligned diagonal pivots
+    flag_ratio: float = 1.5 # minimum allowed flag/pennant ratio between flag pole and flag width
+    flag_pole_span: int = 15 # maximum periods a flag/pennant pole can span
+    flag_span: int = 15 # maximum periods a flag/pennant can span
+    max_candle_body_crosses: int = 1 # maximum allowed candle body crosses for a valid trend line
+
+class TrendLinePattern(ChartPattern):
+    def __init__(self, pivots: List[Pivot], trend_line1: Line, trend_line2: Line):
+        self.pivots = pivots
+        self.trend_line1 = trend_line1
+        self.trend_line2 = trend_line2
+        self.extra_props = {}
+
+    @classmethod
+    def from_dict(cls, dict):
+        self = cls(pivots=[Pivot.from_dict(p) for p in dict["pivots"]],
+                   trend_line1=Line.from_dict(dict["trend_line1"]),
+                   trend_line2=Line.from_dict(dict["trend_line2"]))
+        self.pattern_type = dict["pattern_type"]
+        self.pattern_name = dict["pattern_name"]
+        return self
+
+    def dict(self):
+        obj = super().dict()
+        obj["trend_line1"] = self.trend_line1.dict()
+        obj["trend_line2"] = self.trend_line2.dict()
+        return obj
+
+    def get_pattern_name_by_id(self, id: int) -> str:
+        pattern_names = {
+            1: "Ascending Channel",
+            2: "Descending Channel",
+            3: "Ranging Channel",
+            4: "Rising Wedge (Expanding)",
+            5: "Falling Wedge (Expanding)",
+            6: "Diverging Triangle",
+            7: "Ascending Triangle (Expanding)",
+            8: "Descending Triangle (Expanding)",
+            9: "Rising Wedge (Contracting)",
+            10: "Falling Wedge (Contracting)",
+            11: "Converging Triangle",
+            12: "Descending Triangle (Contracting)",
+            13: "Ascending Triangle (Contracting)",
+            14: "Bull Pennant",
+            15: "Bear Pennant",
+            16: "Bull Flag",
+            17: "Bear Flag"
+        }
+        return pattern_names.get(id, "Error")
+
+    def resolve(self, properties: TrendLineProperties) -> 'TrendLinePattern':
+        """
+        Resolve pattern by updating trend lines, pivot points, and ratios
+
+        Args:
+            properties: ScanProperties object containing pattern parameters
+
+        Returns:
+            self: Returns the pattern object for method chaining
+        """
+        # Get first and last indices/times from pivots
+        first_index = self.pivots[0].point.index
+        last_index = self.pivots[-1].point.index
+        first_time = self.pivots[0].point.time
+        last_time = self.pivots[-1].point.time
+
+        # Update trend line 1 endpoints
+        self.trend_line1.p1 = Point(
+            time=first_time,
+            index=first_index,
+            price=self.trend_line1.get_price(first_index)
+        )
+        self.trend_line1.p2 = Point(
+            time=last_time,
+            index=last_index,
+            price=self.trend_line1.get_price(last_index)
+        )
+
+        # Update trend line 2 endpoints
+        self.trend_line2.p1 = Point(
+            time=first_time,
+            index=first_index,
+            price=self.trend_line2.get_price(first_index)
+        )
+        self.trend_line2.p2 = Point(
+            time=last_time,
+            index=last_index,
+            price=self.trend_line2.get_price(last_index)
+        )
+
+        # Update pivot points to match trend lines
+        for i, pivot in enumerate(self.pivots):
+            current_trend_line = self.trend_line2 if i % 2 == 1 else self.trend_line1
+
+            # Update pivot price to match trend line
+            pivot.point.price = current_trend_line.get_price(pivot.point.index)
+
+        # Resolve pattern name/type
+        self.resolve_pattern_name(properties)
+        return self
+
+    def resolve_pattern_name(self, properties: TrendLineProperties) -> 'TrendLinePattern':
+        """Determine the pattern type based on trend lines and angles"""
+        t1p1 = self.trend_line1.p1.price
+        t1p2 = self.trend_line1.p2.price
+        t2p1 = self.trend_line2.p1.price
+        t2p2 = self.trend_line2.p2.price
+
+        # Calculate angles between trend lines
+        upper_angle = ((t1p2 - min(t2p1, t2p2)) / (t1p1 - min(t2p1, t2p2))
+                      if t1p1 > t2p1 else
+                      (t2p2 - min(t1p1, t1p2)) / (t2p1 - min(t1p1, t1p2)))
+
+        lower_angle = ((t2p2 - max(t1p1, t1p2)) / (t2p1 - max(t1p1, t1p2))
+                      if t1p1 > t2p1 else
+                      (t1p2 - max(t2p1, t2p2)) / (t1p1 - max(t2p1, t2p2)))
+
+        # Determine line directions
+        upper_line_dir = (1 if upper_angle > 1 + properties.flat_ratio else
+                         -1 if upper_angle < 1 - properties.flat_ratio else 0)
+
+        lower_line_dir = (-1 if lower_angle > 1 + properties.flat_ratio else
+                         1 if lower_angle < 1 - properties.flat_ratio else 0)
+
+        # Calculate differences and ratios
+        start_diff = abs(t1p1 - t2p1)
+        end_diff = abs(t1p2 - t2p2)
+        min_diff = min(start_diff, end_diff)
+        bar_diff = self.trend_line1.p2.index - self.trend_line2.p1.index
+        price_diff = abs(start_diff - end_diff) / bar_diff if bar_diff != 0 else 0
+
+        probable_converging_bars = min_diff / price_diff if price_diff != 0 else float('inf')
+
+        is_expanding = end_diff > start_diff
+        is_contracting = start_diff > end_diff
+
+        is_channel = (probable_converging_bars > 2 * bar_diff or
+                     (not is_expanding and not is_contracting) or
+                     (upper_line_dir == 0 and lower_line_dir == 0))
+
+        invalid = np.sign(t1p1 - t2p1) != np.sign(t1p2 - t2p2)
+
+        # Determine pattern type
+        if invalid:
+            self.pattern_type = 0
+        elif is_channel:
+            if upper_line_dir > 0 and lower_line_dir > 0:
+                self.pattern_type = 1  # Ascending Channel
+            elif upper_line_dir < 0 and lower_line_dir < 0:
+                self.pattern_type = 2  # Descending Channel
+            else:
+                self.pattern_type = 3  # Ranging Channel
+        elif is_expanding:
+            if upper_line_dir > 0 and lower_line_dir > 0:
+                self.pattern_type = 4  # Rising Wedge (Expanding)
+            elif upper_line_dir < 0 and lower_line_dir < 0:
+                self.pattern_type = 5  # Falling Wedge (Expanding)
+            elif upper_line_dir > 0 and lower_line_dir < 0:
+                self.pattern_type = 6  # Diverging Triangle
+            elif upper_line_dir > 0 and lower_line_dir == 0:
+                self.pattern_type = 7  # Ascending Triangle (Expanding)
+            elif upper_line_dir == 0 and lower_line_dir < 0:
+                self.pattern_type = 8  # Descending Triangle (Expanding)
+        elif is_contracting:
+            if upper_line_dir > 0 and lower_line_dir > 0:
+                self.pattern_type = 9  # Rising Wedge (Contracting)
+            elif upper_line_dir < 0 and lower_line_dir < 0:
+                self.pattern_type = 10  # Falling Wedge (Contracting)
+            elif upper_line_dir < 0 and lower_line_dir > 0:
+                self.pattern_type = 11  # Converging Triangle
+            elif lower_line_dir == 0:
+                self.pattern_type = 12 if upper_line_dir < 0 else 1  # Descending Triangle (Contracting)
+            elif upper_line_dir == 0:
+                self.pattern_type = 13 if lower_line_dir > 0 else 2  # Ascending Triangle (Contracting)
+
+        if properties.number_of_pivots == 4:
+            # check flag ratio and difference
+            flag_pole_height = abs(self.pivots[0].diff)
+            flag_pole_span = self.pivots[0].index_diff
+            flag_span = self.pivots[-1].point.index - self.pivots[0].point.index
+            flag_size = max(abs(self.trend_line1.p1.price - self.trend_line2.p1.price),
+                            abs(self.trend_line1.p2.price - self.trend_line2.p2.price))
+            # flag size must be smaller than its pole
+            if flag_size * properties.flag_ratio < flag_pole_height and \
+                flag_pole_span <= properties.flag_pole_span and \
+                flag_span <= properties.flag_span:
+                if self.pattern_type == 1 or self.pattern_type == 2 or self.pattern_type == 3:
+                    # channel patterns
+                    if self.pivots[0].direction > 0:
+                        self.pattern_type = 16  # Bull Flag
+                    elif self.pivots[0].direction < 0:
+                        self.pattern_type = 17  # Bear Flag
+                    else:
+                        self.pattern_type = 0
+                elif self.pattern_type == 9 or self.pattern_type == 10 or \
+                    self.pattern_type == 11 or self.pattern_type == 12 or \
+                    self.pattern_type == 13:
+                    # pennant patterns
+                    if self.pivots[0].direction > 0:
+                        self.pattern_type = 14  # Bull Pennant
+                    else:
+                        self.pattern_type = 15  # Bear Pennant
+                else:
+                    self.pattern_type = 0
+            else:
+                # invalidate other pattern types
+                self.pattern_type = 0
+
+        return self
+
+def is_aligned(pivots: List[Pivot], ref_pivots: List[Pivot], align_ratio: float,
+               flat_ratio: float) -> bool:
+    if len(pivots) > 3:
+        raise ValueError("Pivots can't be more than 3")
+    if len(pivots) < 3:
+        return True
+
+    first = pivots[0]
+    second = pivots[1]
+    third = pivots[2]
+    if is_same_height(first, second, ref_pivots, flat_ratio) and \
+        is_same_height(second, third, ref_pivots, flat_ratio):
+        logger.debug(f"Pivots: {first.point.index}, {second.point.index}, {third.point.index} "
+                     f"are aligned as a horizontal line")
+        return True
+
+    # check the ratio of the price differences to the bar differences
+    if third.cross_diff == 0:
+        # the first and third pivots are the same height, but they are not aligned
+        # with the second pivot
+        return False
+    price_ratio = second.cross_diff / third.cross_diff
+    bar_ratio = float(second.point.index - first.point.index) / \
+        float(third.point.index - second.point.index)
+    ratio = price_ratio / bar_ratio
+    fit_pct = 1 - align_ratio
+    if ratio < 1:
+        aligned = ratio >= fit_pct
+    else:
+        aligned = ratio <= 1 / fit_pct
+    logger.debug(f"Pivots: {first.point.index}, {second.point.index}, {third.point.index} "
+                 f"price ratio: {price_ratio:.4f}, bar ratio: {bar_ratio:.4f}, ratio: {ratio:.4f}")
+    return aligned
+
+def check_if_line_cross_candle_body(line: Line, direction: float, zigzag: Zigzag,
+                                    line_end_index: Optional[int] = None) -> int:
+    """
+    Check if a line crosses the candle body
+    """
+    if line_end_index is not None and line_end_index > line.p2.index:
+        end_index = line_end_index
+    else:
+        end_index = line.p2.index
+
+    crosses = 0
+    for i in range(line.p1.index + 1, end_index):
+        bar_data = zigzag.get_df_data_by_index(i)
+        if direction > 0 and line.get_price(i) < max(bar_data['open'], bar_data['close']):
+            crosses += 1
+        elif direction < 0 and line.get_price(i) > min(bar_data['open'], bar_data['close']):
+            crosses += 1
+    return crosses
+
+def inspect_line_by_point(line: Line, point_bar: int, direction: float,
+                          zigzag: Zigzag) -> Tuple[bool, float]:
+    """
+    Inspect a single line against price data from a pandas DataFrame
+
+    Args:
+        line: Line object to inspect
+        point_bar: Index of the point to inspect
+        direction: Direction of the trend (1 for up, -1 for down)
+        zigzag: Zigzag calculator instance
+
+    Returns:
+        Tuple of (valid: bool, diff: float)
+    """
+    # Get price data from DataFrame
+    bar_data = zigzag.get_df_data_by_index(point_bar)
+
+    # Determine prices based on direction
+    line_price = line.get_price(point_bar)
+    line_price_diff = abs(line.p1.price - line.p2.price)
+    if direction > 0:
+        # upper line
+        body_high_price = max(bar_data['open'], bar_data['close'])
+        if line_price < body_high_price:
+            # invalid if line is crossing the candle body
+            return False, float('inf') # make the difference as large as possible
+        elif line_price > bar_data['high']:
+            # line is above the candle wick
+            diff = line_price - bar_data['high']
+            return diff < line_price_diff, diff
+        else:
+            # line is crossing the candle wick
+            return True, 0
+    else:
+        # lower line
+        body_low_price = min(bar_data['open'], bar_data['close'])
+        if line_price > body_low_price:
+            # invalid if line is crossing the candle body
+            return False, float('inf') # make the difference as large as possible
+        elif line_price < bar_data['low']:
+            # line is below the candle wick
+            diff = bar_data['low'] - line_price
+            return diff < line_price_diff, diff
+        else:
+            # line is crossing the candle wick
+            return True, 0
+
+def inspect_pivots(pivots: List[Pivot], direction: float, properties: TrendLineProperties,
+                   last_pivot: Pivot, zigzag: Zigzag) -> Tuple[bool, Line]:
+    """
+    Inspect multiple pivots to find the best trend line using DataFrame price data
+
+    Args:
+        pivots: List of pivots to create trend lines
+        direction: Direction of the trend
+        properties: TrendLineProperties object containing pattern parameters
+        last_pivot: The last pivot to inspect
+        zigzag: Zigzag calculator instance
+
+    Returns:
+        Tuple of (valid: bool, best_trend_line: Line)
+    """
+    if len(pivots) == 3:
+        # Create three possible trend lines
+        trend_line1 = Line(pivots[0].point, pivots[2].point)  # First to last
+        # check if the line consisting of the first and last points crosses the candle body
+        if check_if_line_cross_candle_body(trend_line1, direction, zigzag) > \
+            properties.max_candle_body_crosses:
+            return False, None
+        # inspect line by middle point
+        valid1, diff1 = inspect_line_by_point(trend_line1, pivots[1].point.index,
+                                              direction, zigzag)
+        if valid1 and diff1 == 0:
+            # prefer the line connecting the first and last points
+            return True, trend_line1
+
+        trend_line2 = Line(pivots[0].point, pivots[1].point)  # First to middle
+        valid2, diff2 = inspect_line_by_point(trend_line2, pivots[2].point.index,
+                                              direction, zigzag)
+
+        trend_line3 = Line(pivots[1].point, pivots[2].point)  # Middle to last
+        valid3, diff3 = inspect_line_by_point(trend_line3, pivots[0].point.index,
+                                              direction, zigzag)
+
+        if not valid1 and not valid2 and not valid3:
+            return False, None
+
+        # Find the best line
+        if valid1:
+            trendline = trend_line1
+        elif valid2 and diff2 < diff1:
+            trendline = trend_line2
+        elif valid3 and diff3 < min(diff1, diff2):
+            trendline = trend_line3
+
+        return True, trendline
+    else:
+        # For 2 points, simply create one trend line
+        trend_line = Line(pivots[0].point, pivots[1].point)
+        valid = check_if_line_cross_candle_body(
+            trend_line, direction, zigzag, last_pivot.point.index) <= \
+            properties.max_candle_body_crosses
+        return valid, trend_line
+
+def find_trend_lines(zigzag: Zigzag, offset: int, properties: TrendLineProperties,
+                patterns: List[TrendLinePattern]) -> bool:
+    """
+    Find patterns using DataFrame price data
+
+    Args:
+        zigzag: ZigZag calculator instance
+        offset: Offset to start searching for pivots
+        properties: Scan properties
+        patterns: List to store found patterns
+
+    Returns:
+        int: Index of the pivot that was used to find the pattern
+    """
+    # Get pivots
+    if properties.number_of_pivots < 4 or properties.number_of_pivots > 6:
+        raise ValueError("Number of pivots must be between 4 and 6")
+
+    pivots = []
+    min_pivots = get_pivots_from_zigzag(zigzag, pivots, offset, properties.number_of_pivots)
+    if min_pivots != properties.number_of_pivots:
+        return False
+
+    # Validate pattern
+    # Create point arrays for trend lines
+    trend_pivots1 = ([pivots[0], pivots[2]]
+                      if properties.number_of_pivots == 4
+                      else [pivots[0], pivots[2], pivots[4]])
+    trend_pivots2 = ([pivots[1], pivots[3], pivots[5]]
+                      if properties.number_of_pivots == 6
+                      else [pivots[1], pivots[3]])
+
+    if not is_aligned(trend_pivots1, pivots, properties.align_ratio,
+                      properties.flat_ratio) or \
+        not is_aligned(trend_pivots2, pivots, properties.align_ratio,
+                       properties.flat_ratio):
+        return False
+
+    # Validate trend lines using DataFrame
+    valid1, trend_line1 = inspect_pivots(trend_pivots1,
+                                        np.sign(trend_pivots1[0].direction),
+                                        properties, pivots[-1], zigzag)
+    valid2, trend_line2 = inspect_pivots(trend_pivots2,
+                                        np.sign(trend_pivots2[0].direction),
+                                        properties, pivots[-1], zigzag)
+
+    if valid1 and valid2:
+        index_delta = pivots[-1].point.index - pivots[0].point.index + 1
+        if index_delta < properties.min_periods_lapsed and \
+            properties.number_of_pivots >= 5:
+            # only consider patterns with enough time lapsed
+            return False
+
+        # Create pattern
+        pattern = TrendLinePattern(
+            pivots=pivots,
+            trend_line1=trend_line1,
+            trend_line2=trend_line2,
+        ).resolve(properties)
+
+        # Process pattern (resolve type, check if allowed, etc.)
+        return pattern.process_pattern(properties, patterns)
+    else:
+        return False

auto_chart_patterns/zigzag.py

@@ -0,0 +1,228 @@
+from dataclasses import dataclass
+from typing import List, Optional
+import numpy as np
+import pandas as pd
+
+from .line import Pivot, Point
+
+import logging
+logger = logging.getLogger(__name__)
+
+@dataclass
+class Zigzag:
+    def __init__(self, backcandles: int = 5, forwardcandles: int = 5,
+                 pivot_limit: int = 20, offset: int = 0, level: int = 0):
+        self.backcandles = backcandles
+        self.forwardcandles = forwardcandles
+        self.pivot_limit = pivot_limit
+        self.offset = offset
+        self.level = level
+        self.zigzag_pivots: List[Pivot] = []
+        self.df = None
+
+    def update_pivot_properties(self, pivot: Pivot) -> 'Zigzag':
+        """
+        Update the properties of the pivot
+        """
+        if len(self.zigzag_pivots) > 1:
+            dir = np.sign(pivot.direction)
+            value = pivot.point.price
+            last_pivot = self.zigzag_pivots[1]
+            last_value = last_pivot.point.price
+            if last_pivot.point.index == pivot.point.index:
+                raise ValueError(f"Last pivot index {last_pivot.point.index} "
+                                 f"is the same as current pivot index {pivot.point.index}")
+            pivot.index_diff = pivot.point.index - last_pivot.point.index
+
+            # Calculate difference between last and current pivot
+            pivot.diff = value - last_value
+            if len(self.zigzag_pivots) > 2:
+                llast_pivot = self.zigzag_pivots[2]
+                llast_value = llast_pivot.point.price
+                # Calculate slope between last and current pivot
+                pivot.cross_diff = value - llast_value
+                # Determine if trend is strong (2) or weak (1)
+                new_dir = dir * 2 if dir * value > dir * llast_value else dir
+                pivot.direction = int(new_dir)
+
+    def add_new_pivot(self, pivot: Pivot) -> 'Zigzag':
+        """
+        Add a new pivot to the zigzag
+
+        Args:
+            pivot: Pivot object to add
+
+        Returns:
+            self: Returns zigzag object for method chaining
+
+        Raises:
+            ValueError: If direction mismatch with last pivot
+        """
+        if len(self.zigzag_pivots) >= 1:
+            # Check direction mismatch
+            if np.sign(self.zigzag_pivots[0].direction) == np.sign(pivot.direction):
+                raise ValueError('Direction mismatch')
+
+        # Insert at beginning and maintain max size
+        self.zigzag_pivots.insert(0, pivot)
+        self.update_pivot_properties(pivot)
+
+        if len(self.zigzag_pivots) > self.pivot_limit:
+            logger.warning(f"Warning: pivots exceeded limit {self.pivot_limit}, "
+                           f"popping pivot {self.zigzag_pivots[-1].point.index}")
+            self.zigzag_pivots.pop()
+
+        return self
+
+    def calculate(self, df: pd.DataFrame, offset: Optional[int] = None) -> 'Zigzag':
+        """
+        Calculate zigzag pivots from DataFrame
+
+        Args:
+            df: DataFrame with 'high' and 'low' columns
+            offset: Offset to apply to the dataframe index
+        Returns:
+            self: Returns zigzag object for method chaining
+        """
+        if offset is not None:
+            self.offset = offset
+
+        # rescale the dataframe using the max and low prices in the range
+        if df.get('high') is None or df.get('low') is None:
+            raise ValueError("High and low prices not found in dataframe")
+
+        self.zigzag_pivots = []
+
+        highs, lows = window_peaks(df, self.backcandles, self.forwardcandles)
+
+        # Calculate pivot highs
+        pivot_highs = df['high'].where((df['high'] == highs))
+
+        # Calculate pivot lows
+        pivot_lows = df['low'].where((df['low'] == lows))
+
+        # Process pivot points into zigzag
+        last_pivot_price = None
+        last_pivot_direction = 0
+
+        for i in range(len(df)):
+            if not (pd.isna(pivot_highs.iloc[i]) and pd.isna(pivot_lows.iloc[i])):
+                current_index = i + self.offset
+                current_time = df.index[i]
+                take_high = True
+                if not pd.isna(pivot_highs.iloc[i]) and not pd.isna(pivot_lows.iloc[i]):
+                    # both high and low pivot, take the more extreme one
+                    if last_pivot_price is not None:
+                        assert last_pivot_direction != 0
+                        if last_pivot_direction == 1:
+                            if pivot_highs.iloc[i] <= last_pivot_price:
+                                # the current pivot high is lower than the last pivot high, take low instead
+                                take_high = False
+                        else:
+                            if pivot_lows.iloc[i] < last_pivot_price:
+                                # the current pivot low is lower than the last pivot low, take low instead
+                                take_high = False
+                elif pd.isna(pivot_highs.iloc[i]):
+                    take_high = False
+
+                if take_high:
+                    current_price = pivot_highs.iloc[i]
+                    current_direction = 1 # bullish
+                else:
+                    current_price = pivot_lows.iloc[i]
+                    current_direction = -1 # bearish
+
+                # Create and add pivot if valid
+                if last_pivot_price is None or last_pivot_direction != current_direction:
+                    new_pivot = Pivot(
+                        point=Point(
+                            price=current_price,
+                            index=current_index,
+                            time=current_time
+                        ),
+                        direction=current_direction
+                    )
+
+                    self.add_new_pivot(new_pivot)
+                    last_pivot_price = current_price
+                    last_pivot_direction = current_direction
+
+                # Update last pivot if same direction but more extreme
+                elif ((current_direction == 1 and current_price > last_pivot_price) or
+                    (current_direction == -1 and current_price < last_pivot_price)):
+                    # Update the last pivot
+                    last_pivot = self.zigzag_pivots[0]
+                    last_pivot.point.price = current_price
+                    last_pivot.point.index = current_index
+                    last_pivot.point.time = current_time
+                    self.update_pivot_properties(last_pivot)
+                    last_pivot_price = current_price
+
+        # record the dataframe
+        self.df = df
+
+        return self
+
+    def get_pivot_by_index(self, index: int) -> Optional[Pivot]:
+        """Get pivot at specific index"""
+        for i in range(len(self.zigzag_pivots)):
+            current_pivot = self.zigzag_pivots[len(self.zigzag_pivots) - i - 1]
+            if current_pivot.point.index == index:
+                return current_pivot
+        return None
+
+    def get_pivot(self, offset: int) -> Optional[Pivot]:
+        """Get pivot at specific index"""
+        if 0 <= offset < len(self.zigzag_pivots):
+            return self.zigzag_pivots[offset]
+        return None
+
+    def get_last_pivot(self) -> Optional[Pivot]:
+        """Get the most recent pivot"""
+        return self.zigzag_pivots[0] if self.zigzag_pivots else None
+
+    def get_df_data_by_index(self, index: int) -> pd.Series:
+        """Get the dataframe data at a specific index"""
+        if self.df is not None:
+            if index < self.offset or index - self.offset >= len(self.df):
+                raise ValueError(f"Index {index} is out of bounds")
+            return self.df.iloc[index - self.offset]
+        raise ValueError("DataFrame not calculated")
+
+def window_peaks(data, before: int, after: int) -> tuple[pd.Series, pd.Series]:
+    """
+    Faster version using numpy's stride tricks
+
+    Args:
+        df: DataFrame with 'high' and 'low' columns
+        before: Number of bars before the current bar
+        after: Number of bars after the current bar
+
+    Returns:
+        pd.Series: Series of highs and lows
+    """
+    if isinstance(data, pd.DataFrame):
+        values_high = data["high"].values
+    elif isinstance(data, pd.Series):
+        values_high = data.values
+    else:
+        raise ValueError("Unsupported dataframe type")
+
+    if isinstance(data, pd.DataFrame):
+        values_low = data["low"].values
+    elif isinstance(data, pd.Series):
+        values_low = data.values
+    result_high = np.zeros(len(values_high))
+    result_low = np.zeros(len(values_low))
+
+    # Handle edges with padding
+    padded_high = np.pad(values_high, (before, after), mode='edge')
+    padded_low = np.pad(values_low, (before, after), mode='edge')
+
+    # Create rolling window view
+    windows_high = np.lib.stride_tricks.sliding_window_view(padded_high, before + after + 1)
+    windows_low = np.lib.stride_tricks.sliding_window_view(padded_low, before + after + 1)
+    result_high = np.max(windows_high, axis=1)
+    result_low = np.min(windows_low, axis=1)
+
+    return pd.Series(result_high, index=data.index), pd.Series(result_low, index=data.index)

auto_chart_patterns-0.1.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.3
+Name: auto-chart-patterns
+Version: 0.1.0
+Summary: Automatically identify chart patterns from OHLC data
+Project-URL: Homepage, https://github.com/FanM/auto-chart-patterns
+Project-URL: Bug Tracker, https://github.com/FanM/auto-chart-patterns/issues
+Author-email: Fan Mao <maofan@xsmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: pandas>=1.0.0
+Description-Content-Type: text/markdown
+
+# auto-chart-patterns
+Automatically identify chart patterns from OHLC data

auto_chart_patterns-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+auto_chart_patterns/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+auto_chart_patterns/chart_pattern.py,sha256=Lt2Et8bqR6xsenCu0lLD2me0RF4UAUNPsRLSmtWVH30,6276
+auto_chart_patterns/line.py,sha256=6Vftr-Ok3_UESoRUqjr8JDKbxyDjQztcn-_CkFHm5Fo,2383
+auto_chart_patterns/reversal_patterns.py,sha256=8LX6Adz6xOsn9-3cx3dHbIW7DenDxwt4V2QSA7zp3ww,9017
+auto_chart_patterns/rsi_div_patterns.py,sha256=gkDYcHysypfLaPSEpg9-yldxYqKy-kDjj9g2RFGhwWo,5876
+auto_chart_patterns/trendline_patterns.py,sha256=Dmnmx0dXcsBN1kUizyiKEtwbOVp_Qb5sQJIF_L5LmuM,18811
+auto_chart_patterns/zigzag.py,sha256=i9hjKyY9omeIU5DL1Mzpm08L2YM9k9bSJH6J04r6kRA,9107
+auto_chart_patterns-0.1.0.dist-info/METADATA,sha256=jZ4weSPNIqxe0RDgK-1Z6JNlmf876GRXnPhpjvHzU9c,654
+auto_chart_patterns-0.1.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+auto_chart_patterns-0.1.0.dist-info/licenses/LICENSE,sha256=1YoFL1mg5DVYt9jUfKKxbE98PX8YjvrPoIGhHx4RV8w,1061
+auto_chart_patterns-0.1.0.dist-info/RECORD,,

auto_chart_patterns-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

auto_chart_patterns-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FanM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.