yfinance-ta-patterns 0.1.1__tar.gz

yfinance_ta_patterns-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 eminsk
+
+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.

yfinance_ta_patterns-0.1.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: yfinance-ta-patterns
+Version: 0.1.1
+Summary: CLI and helpers to scan yfinance data for TA-Lib candlestick patterns.
+Author: eminsk
+License: MIT License
+        
+        Copyright (c) 2025 eminsk
+        
+        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.
+        
+Project-URL: Repository, https://github.com/eminsk/yfinance-ta-patterns
+Project-URL: Homepage, https://github.com/eminsk/yfinance-ta-patterns
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ta-lib>=0.6.8
+Requires-Dist: yfinance>=0.2.66
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: pytz>=2024.1
+Requires-Dist: numpy>=1.26
+Dynamic: license-file
+
+## Forex Candlestick Scanner
+
+Python package + CLI that downloads Yahoo Finance data via `yfinance` and runs TA-Lib candlestick detectors for your symbol, timeframe, and date filters.
+
+### Quick start
+```bash
+# create env
+python -m venv .venv
+.\.venv\Scripts\activate  # PowerShell; adjust for your shell
+
+# install the package (editable for local dev)
+pip install -e .
+
+# run CLI (two entrypoints)
+yfinance-ta-patterns --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+# or
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+`pyproject.toml` targets Python `>=3.12`.
+
+### CLI usage
+```
+yfinance-ta-patterns [--pattern NAME | --all-patterns]
+                     [--symbol EURUSD] [--period 60d]
+                     [--timeframe 15m] [--date YYYY-MM-DD]
+                     [--start-date YYYY-MM-DD] [--end-date YYYY-MM-DD]
+```
+- `--pattern`: Single candlestick name (with or without `CDL` prefix).
+- `--all-patterns`: Scan every TA-Lib candlestick detector.
+- `--symbol`: Ticker without suffix; `=X` is appended automatically for Forex (default `EURUSD`).
+- `--period`: History window passed to `yfinance` (e.g., `60d`, `1mo`).
+- `--timeframe`: Use `M1/M5/M15/M30/H1/D1` or raw `yfinance` intervals (`1m`, `5m`, `1h`, `1d`, etc.).
+- `--date`: Filter signals for a single day.
+- `--start-date` / `--end-date`: Inclusive range filter (cannot be combined with `--date`).
+
+### Examples
+- All patterns for a single day:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+- All patterns across a range:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --start-date 2025-04-01 --end-date 2025-04-10
+```
+- One pattern without date filter:
+```bash
+yftp --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+```
+
+### Data loader
+`yfinance_ta_patterns/forex_data_loader.py` fetches and normalizes OHLC data. It appends `=X` to symbols when missing and converts timestamps to UTC before shifting to the configured timezone (`Europe/Moscow` by default).
+
+### Pattern analysis
+`yfinance_ta_patterns/pattern_analyzer.py` wraps TA-Lib's `CDL*` functions, returning non-zero signals and applying optional date filters. When `--all-patterns` is used, it iterates over the full catalog and prints hits per pattern.
+
+### Pattern ranking helper (optional)
+`yfinance_ta_patterns/pattern_tester.py` contains a backtesting-style ranking tool. It depends on `utils.pattern_helper.PatternHelper` to enumerate patterns; add that helper before running comparisons or exports.
+
+### Project layout
+- `yfinance_ta_patterns/cli.py`: CLI entry point and argument parsing.
+- `yfinance_ta_patterns/forex_data_loader.py`: Data download and timezone normalization.
+- `yfinance_ta_patterns/pattern_analyzer.py`: Candlestick signal extraction.
+- `yfinance_ta_patterns/pattern_tester.py`: Experimental ranking/backtest utilities.
+- `main.py`: Thin wrapper to launch the CLI.
+
+### Packaging and releases
+- Nightly GitHub Actions workflow builds onefile Nuitka binaries for Windows/macOS/Linux and publishes nightly prereleases.
+- A PyPI publish workflow can be enabled by adding a secret `PYPI_API_TOKEN`; tags like `v0.1.0` will build sdist/wheel and upload.
+- TA-Lib is installed from PyPI on Windows; Linux/macOS CI builds the TA-Lib C library from source for the binaries. For local installs, PyPI wheels (`ta-lib` >=0.6.8) cover CPython 3.9–3.14.

yfinance_ta_patterns-0.1.1/README.md

@@ -0,0 +1,69 @@
+## Forex Candlestick Scanner
+
+Python package + CLI that downloads Yahoo Finance data via `yfinance` and runs TA-Lib candlestick detectors for your symbol, timeframe, and date filters.
+
+### Quick start
+```bash
+# create env
+python -m venv .venv
+.\.venv\Scripts\activate  # PowerShell; adjust for your shell
+
+# install the package (editable for local dev)
+pip install -e .
+
+# run CLI (two entrypoints)
+yfinance-ta-patterns --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+# or
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+`pyproject.toml` targets Python `>=3.12`.
+
+### CLI usage
+```
+yfinance-ta-patterns [--pattern NAME | --all-patterns]
+                     [--symbol EURUSD] [--period 60d]
+                     [--timeframe 15m] [--date YYYY-MM-DD]
+                     [--start-date YYYY-MM-DD] [--end-date YYYY-MM-DD]
+```
+- `--pattern`: Single candlestick name (with or without `CDL` prefix).
+- `--all-patterns`: Scan every TA-Lib candlestick detector.
+- `--symbol`: Ticker without suffix; `=X` is appended automatically for Forex (default `EURUSD`).
+- `--period`: History window passed to `yfinance` (e.g., `60d`, `1mo`).
+- `--timeframe`: Use `M1/M5/M15/M30/H1/D1` or raw `yfinance` intervals (`1m`, `5m`, `1h`, `1d`, etc.).
+- `--date`: Filter signals for a single day.
+- `--start-date` / `--end-date`: Inclusive range filter (cannot be combined with `--date`).
+
+### Examples
+- All patterns for a single day:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+- All patterns across a range:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --start-date 2025-04-01 --end-date 2025-04-10
+```
+- One pattern without date filter:
+```bash
+yftp --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+```
+
+### Data loader
+`yfinance_ta_patterns/forex_data_loader.py` fetches and normalizes OHLC data. It appends `=X` to symbols when missing and converts timestamps to UTC before shifting to the configured timezone (`Europe/Moscow` by default).
+
+### Pattern analysis
+`yfinance_ta_patterns/pattern_analyzer.py` wraps TA-Lib's `CDL*` functions, returning non-zero signals and applying optional date filters. When `--all-patterns` is used, it iterates over the full catalog and prints hits per pattern.
+
+### Pattern ranking helper (optional)
+`yfinance_ta_patterns/pattern_tester.py` contains a backtesting-style ranking tool. It depends on `utils.pattern_helper.PatternHelper` to enumerate patterns; add that helper before running comparisons or exports.
+
+### Project layout
+- `yfinance_ta_patterns/cli.py`: CLI entry point and argument parsing.
+- `yfinance_ta_patterns/forex_data_loader.py`: Data download and timezone normalization.
+- `yfinance_ta_patterns/pattern_analyzer.py`: Candlestick signal extraction.
+- `yfinance_ta_patterns/pattern_tester.py`: Experimental ranking/backtest utilities.
+- `main.py`: Thin wrapper to launch the CLI.
+
+### Packaging and releases
+- Nightly GitHub Actions workflow builds onefile Nuitka binaries for Windows/macOS/Linux and publishes nightly prereleases.
+- A PyPI publish workflow can be enabled by adding a secret `PYPI_API_TOKEN`; tags like `v0.1.0` will build sdist/wheel and upload.
+- TA-Lib is installed from PyPI on Windows; Linux/macOS CI builds the TA-Lib C library from source for the binaries. For local installs, PyPI wheels (`ta-lib` >=0.6.8) cover CPython 3.9–3.14.

yfinance_ta_patterns-0.1.1/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "yfinance-ta-patterns"
+version = "0.1.1"
+description = "CLI and helpers to scan yfinance data for TA-Lib candlestick patterns."
+readme = "README.md"
+requires-python = ">=3.12"
+license = { file = "LICENSE" }
+authors = [
+    { name = "eminsk" },
+]
+dependencies = [
+    "ta-lib>=0.6.8",
+    "yfinance>=0.2.66",
+    "pandas>=2.2.0",
+    "pytz>=2024.1",
+    "numpy>=1.26",
+]
+
+[project.scripts]
+yfinance-ta-patterns = "yfinance_ta_patterns.cli:main"
+yftp = "yfinance_ta_patterns.cli:main"
+
+[project.urls]
+Repository = "https://github.com/eminsk/yfinance-ta-patterns"
+Homepage = "https://github.com/eminsk/yfinance-ta-patterns"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["yfinance_ta_patterns*"]

yfinance_ta_patterns-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yfinance_ta_patterns-0.1.1/tests/test_cli.py

@@ -0,0 +1,15 @@
+from yfinance_ta_patterns.cli import normalize_timeframe
+
+
+def test_normalize_timeframe_aliases():
+    assert normalize_timeframe("M5") == "5m"
+    assert normalize_timeframe("h1") == "1h"
+
+
+def test_normalize_timeframe_invalid():
+    try:
+        normalize_timeframe("invalid")
+    except ValueError as exc:
+        assert "Unsupported timeframe" in str(exc)
+    else:
+        raise AssertionError("Expected ValueError for invalid timeframe")

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns/__init__.py

@@ -0,0 +1,13 @@
+"""YFinance TA Patterns package."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("yfinance-ta-patterns")
+except PackageNotFoundError:  # pragma: no cover - during editable installs
+    __version__ = "0.0.0"
+
+from .forex_data_loader import ForexDataLoader
+from .pattern_analyzer import PatternAnalyzer
+
+__all__ = ["ForexDataLoader", "PatternAnalyzer", "__version__"]

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns/cli.py

@@ -0,0 +1,160 @@
+import argparse
+
+from .forex_data_loader import ForexDataLoader
+from .pattern_analyzer import PatternAnalyzer
+
+
+TIMEFRAME_MAP = {
+    "M1": "1m",
+    "M5": "5m",
+    "M15": "15m",
+    "M30": "30m",
+    "H1": "1h",
+    "D1": "1d",
+}
+VALID_INTERVALS = {
+    "1m",
+    "2m",
+    "5m",
+    "15m",
+    "30m",
+    "60m",
+    "90m",
+    "1h",
+    "1d",
+    "5d",
+    "1wk",
+    "1mo",
+    "3mo",
+}
+
+
+def normalize_timeframe(timeframe: str) -> str:
+    """Convert human-friendly timeframe names into yfinance intervals."""
+    tf = timeframe.upper()
+    interval = TIMEFRAME_MAP.get(tf, timeframe.lower())
+    if interval not in VALID_INTERVALS:
+        allowed = ", ".join(sorted(VALID_INTERVALS))
+        raise ValueError(f"Unsupported timeframe '{timeframe}'. Allowed: {allowed}")
+    return interval
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Show TA-Lib candlestick pattern signals for a symbol.",
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  # All patterns on a single day\n"
+            "  python main.py --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01\n\n"
+            "  # All patterns over a date range\n"
+            "  python main.py --all-patterns --symbol EURUSD --timeframe 5m --period 60d "
+            "--start-date 2025-04-01 --end-date 2025-04-10\n\n"
+            "  # Single pattern without date filter\n"
+            "  python main.py --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d\n"
+        ),
+    )
+    parser.add_argument(
+        "--symbol",
+        default="EURUSD",
+        help="Ticker without suffix (e.g. EURUSD, GBPUSD); '=X' will be appended automatically.",
+    )
+    parser.add_argument("--period", default="60d", help="History period, e.g. 60d")
+    parser.add_argument(
+        "--timeframe",
+        default="15m",
+        help="Timeframe (M1, M5, M15, M30, H1, D1) or raw yfinance interval (1m, 5m, 15m, 1h, 1d...).",
+    )
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--pattern",
+        help="Single candlestick pattern, e.g. KICKING (CDL prefix optional).",
+    )
+    group.add_argument(
+        "--all-patterns",
+        action="store_true",
+        help="Scan and show signals for all TA-Lib candlestick patterns.",
+    )
+    parser.add_argument(
+        "--date",
+        help="Optional filter by date (YYYY-MM-DD). If omitted, show all signals.",
+    )
+    parser.add_argument(
+        "--start-date",
+        help="Optional start date (YYYY-MM-DD) for range filter (inclusive).",
+    )
+    parser.add_argument(
+        "--end-date",
+        help="Optional end date (YYYY-MM-DD) for range filter (inclusive).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    interval = normalize_timeframe(args.timeframe)
+
+    if args.date and (args.start_date or args.end_date):
+        raise ValueError("Use either --date or --start-date/--end-date, not both.")
+
+    data = ForexDataLoader(
+        args.symbol,
+        period=args.period,
+        interval=interval,
+    ).get_data()
+
+    analyzer = PatternAnalyzer(data)
+    range_info = ""
+    if args.date:
+        range_info = f" on {args.date}"
+    elif args.start_date or args.end_date:
+        range_info = f" from {args.start_date or 'beginning'} to {args.end_date or 'end'}"
+
+    if args.pattern:
+        signals = analyzer.get_signals(
+            args.pattern,
+            date=args.date,
+            start_date=args.start_date,
+            end_date=args.end_date,
+        )
+
+        if signals.empty:
+            print(
+                f"No signals for pattern {args.pattern} "
+                f"on period {args.period} timeframe {interval}{range_info}"
+            )
+        else:
+            print(f"Found signals for {args.pattern} ({interval}, {args.period}){range_info}:")
+            print(signals.to_string())
+    else:
+        print(
+            f"Scanning all patterns for {args.symbol} "
+            f"({interval}, {args.period}){range_info}..."
+        )
+        found_any = False
+        for pattern in sorted(analyzer.pattern_functions):
+            signals = analyzer.get_signals(
+                pattern,
+                date=args.date,
+                start_date=args.start_date,
+                end_date=args.end_date,
+            )
+            pattern_name = pattern.replace("CDL", "")
+            if signals.empty:
+                print(f"{pattern_name}: no signals")
+                continue
+
+            found_any = True
+            print(f"{pattern_name}:")
+            print(signals.to_string())
+            print("-" * 40)
+
+        if not found_any:
+            print(
+                f"No signals for any pattern on period {args.period} "
+                f"timeframe {interval}{range_info}"
+            )
+
+
+if __name__ == "__main__":
+    main()

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns/forex_data_loader.py

@@ -0,0 +1,53 @@
+import pandas as pd
+import yfinance as yf
+import pytz
+
+class ForexDataLoader:
+    """
+    Generic Data Loader for Yahoo Finance tickers (forex, stocks, crypto, etc.).
+    """
+
+    def __init__(
+        self,
+        symbol: str,
+        period: str = '60d',
+        interval: str = '15m',
+        timezone: str = 'Europe/Moscow'
+    ):
+        # Allow full tickers or append suffix if missing
+        self.ticker = symbol if symbol.endswith(suffix := '=X') else f"{symbol}{suffix}"
+        self.period = period
+        self.interval = interval
+        self.timezone = timezone
+
+    def fetch(self) -> pd.DataFrame:
+        """Fetch raw data via yfinance."""
+        return yf.download(
+            self.ticker,
+            period=self.period,
+            interval=self.interval,
+            auto_adjust=True
+        )
+
+    def process(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Normalize columns and timezone."""
+        # Drop extra MultiIndex level if present
+        data.columns = data.columns.droplevel(1) if data.columns.nlevels > 1 else data.columns
+
+        if data.index.tz is None:
+            data.index = data.index.tz_localize(pytz.UTC)
+        else:
+            data.index = data.index.tz_convert(pytz.UTC)
+        # Потом конвертируем в нужную зону
+        data.index = data.index.tz_convert(self.timezone)
+        return data
+
+    def get_data(self) -> pd.DataFrame:
+        """Full pipeline: fetch then process."""
+        return self.process(self.fetch())
+
+if __name__ == "__main__":
+    # Example usage
+    loader = ForexDataLoader("EURUSD=X")
+    data = loader.get_data()
+    print(data)

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns/pattern_analyzer.py

@@ -0,0 +1,101 @@
+from typing import Iterable, Optional, Tuple
+
+import pandas as pd
+import talib
+
+
+class PatternAnalyzer:
+    def __init__(self, data: pd.DataFrame):
+        self.data = data
+        self.pattern_functions = [f for f in dir(talib) if f.startswith("CDL")]
+
+    def _normalize_pattern(self, pattern: str) -> str:
+        pattern_upper = pattern.upper()
+        return pattern_upper if pattern_upper.startswith("CDL") else f"CDL{pattern_upper}"
+
+    def _normalize_dates(
+        self, date: Optional[str], start_date: Optional[str], end_date: Optional[str]
+    ) -> Tuple[Optional[pd.Timestamp], Optional[pd.Timestamp], Optional[pd.Timestamp]]:
+        tz = self.data.index.tz
+
+        def convert(dt: Optional[str]) -> Optional[pd.Timestamp]:
+            if dt is None:
+                return None
+            parsed = pd.to_datetime(dt)
+            if parsed.tzinfo is None:
+                parsed = parsed.tz_localize(tz)
+            else:
+                parsed = parsed.tz_convert(tz)
+            return parsed.normalize()
+
+        return convert(date), convert(start_date), convert(end_date)
+
+    def get_signals(
+        self,
+        pattern: str,
+        date: Optional[str] = None,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+    ) -> pd.Series:
+        """Return non-zero signals for a single candlestick pattern with optional date filters."""
+        normalized = self._normalize_pattern(pattern)
+        if normalized not in self.pattern_functions:
+            available = ", ".join(p.replace("CDL", "") for p in self.pattern_functions)
+            raise ValueError(f"Unknown pattern '{pattern}'. Available: {available}")
+
+        pattern_func = getattr(talib, normalized)
+        result = pattern_func(
+            self.data["Open"],
+            self.data["High"],
+            self.data["Low"],
+            self.data["Close"],
+        )
+        series = pd.Series(result, index=self.data.index, name=normalized)
+        signals = series[series != 0]
+
+        target_date, start_dt, end_dt = self._normalize_dates(date, start_date, end_date)
+
+        if target_date:
+            day_index = signals.index.normalize()
+            signals = signals[day_index == target_date]
+
+        if start_dt or end_dt:
+            day_index = signals.index.normalize()
+            mask = pd.Series(True, index=signals.index)
+            if start_dt:
+                mask &= day_index >= start_dt
+            if end_dt:
+                mask &= day_index <= end_dt
+            signals = signals[mask]
+
+        return signals
+
+    def analyze_all_for_date(self, date: str) -> Iterable[str]:
+        """Keep legacy all-patterns behavior for a specific date."""
+        messages = []
+        for pattern in self.pattern_functions:
+            pattern_func = getattr(talib, pattern)
+            try:
+                result = pattern_func(
+                    self.data["Open"],
+                    self.data["High"],
+                    self.data["Low"],
+                    self.data["Close"],
+                )
+                values = result.loc[date]
+                values_series = (
+                    values
+                    if isinstance(values, pd.Series)
+                    else pd.Series([values], index=[pd.Timestamp(date)])
+                )
+                non_zero = values_series[values_series != 0]
+                messages.append(
+                    f"{pattern} on {date} (non-zero values):\n{non_zero.to_string()}"
+                    if not non_zero.empty
+                    else f"{pattern} on {date}: all values are 0"
+                )
+            except KeyError:
+                messages.append(f"{pattern}: No data available for {date}")
+            except Exception as e:
+                messages.append(f"Error in {pattern}: {e}")
+        return messages

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns/pattern_tester.py

@@ -0,0 +1,258 @@
+"""Pattern ranking tester - find best performing candlestick patterns."""
+
+import pandas as pd
+import numpy as np
+import talib
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from utils.pattern_helper import PatternHelper
+
+
+@dataclass
+class PatternResult:
+    """Result for a single pattern test."""
+    pattern_name: str
+    total_signals: int
+    winning_trades: int
+    losing_trades: int
+    win_rate: float
+    total_pnl: float
+    avg_pnl: float
+    max_profit: float
+    max_loss: float
+    sharpe_ratio: float
+
+
+class PatternRankingTester:
+    """
+    Test all candlestick patterns and rank them by performance.
+    Can filter by economic news events.
+    """
+    
+    __slots__ = ('_data', '_initial_capital', '_position_size', '_results', '_news_dates')
+    
+    def __init__(
+        self,
+        data: pd.DataFrame,
+        initial_capital: float = 10000.0,
+        position_size: float = 100.0,
+        news_dates: Optional[List[str]] = None
+    ):
+        """
+        Initialize pattern tester.
+        
+        Parameters:
+        -----------
+        data : pd.DataFrame
+            OHLCV data
+        initial_capital : float
+            Initial capital
+        position_size : float
+            Position size per trade
+        news_dates : list, optional
+            List of dates with important news (YYYY-MM-DD)
+        """
+        self._data = data
+        self._initial_capital = initial_capital
+        self._position_size = position_size
+        self._results: List[PatternResult] = []
+        self._news_dates = set(news_dates) if news_dates else set()
+    
+    def test_all_patterns(self, filter_news: bool = False) -> List[PatternResult]:
+        """
+        Test all patterns and return ranked results.
+        
+        Parameters:
+        -----------
+        filter_news : bool
+            If True, exclude trades during news events
+        
+        Returns:
+        --------
+        list : Ranked pattern results
+        """
+        self._results = []
+        
+        # Get all patterns dynamically from TA-Lib
+        all_patterns = PatternHelper.get_all_patterns()
+        
+        for pattern_name in all_patterns:
+            try:
+                result = self._test_single_pattern(pattern_name, filter_news)
+                if result and result.total_signals > 0:
+                    self._results.append(result)
+            except Exception as e:
+                print(f"Error testing {pattern_name}: {e}")
+                continue
+        
+        # Sort by win rate, then by total PnL
+        self._results.sort(key=lambda x: (x.win_rate, x.total_pnl), reverse=True)
+        
+        return self._results
+    
+    def _test_single_pattern(
+        self,
+        pattern_name: str,
+        filter_news: bool
+    ) -> Optional[PatternResult]:
+        """Test a single pattern."""
+        # Detect pattern
+        pattern_func = getattr(talib, pattern_name, None)
+        if not pattern_func:
+            print(f"Pattern function not found: {pattern_name}")
+            return None
+        
+        try:
+            pattern_values = pattern_func(
+                self._data['Open'].values,
+                self._data['High'].values,
+                self._data['Low'].values,
+                self._data['Close'].values
+            )
+        except Exception as e:
+            print(f"Error detecting pattern {pattern_name}: {e}")
+            return None
+        
+        # Generate signals
+        signals = np.zeros(len(self._data))
+        for i in range(len(pattern_values)):
+            if pattern_values[i] > 0:  # Bullish pattern
+                signals[i] = 1
+            elif pattern_values[i] < 0:  # Bearish pattern
+                signals[i] = -1
+        
+        # Filter by news if requested
+        if filter_news and self._news_dates:
+            for i in range(len(signals)):
+                date_str = self._data.index[i].strftime('%Y-%m-%d')
+                if date_str in self._news_dates:
+                    signals[i] = 0
+        
+        # Calculate trades
+        trades = self._calculate_trades(signals)
+        
+        # Return None if no trades or too few signals
+        if not trades:
+            # Check if there were any signals at all
+            total_signals = int(np.sum(signals != 0))
+            if total_signals == 0:
+                print(f"{pattern_name}: No signals generated")
+            else:
+                print(f"{pattern_name}: {total_signals} signals but no completed trades")
+            return None
+        
+        # Calculate statistics
+        winning_trades = [t for t in trades if t['pnl'] > 0]
+        losing_trades = [t for t in trades if t['pnl'] <= 0]
+        
+        total_pnl = sum(t['pnl'] for t in trades)
+        avg_pnl = total_pnl / len(trades) if trades else 0
+        win_rate = len(winning_trades) / len(trades) * 100 if trades else 0
+        
+        max_profit = max([t['pnl'] for t in trades]) if trades else 0
+        max_loss = min([t['pnl'] for t in trades]) if trades else 0
+        
+        # Calculate Sharpe ratio
+        pnls = [t['pnl'] for t in trades]
+        sharpe = (np.mean(pnls) / np.std(pnls)) * np.sqrt(252) if len(pnls) > 1 and np.std(pnls) > 0 else 0
+        
+        return PatternResult(
+            pattern_name=pattern_name.replace('CDL', ''),
+            total_signals=int(np.sum(signals != 0)),
+            winning_trades=len(winning_trades),
+            losing_trades=len(losing_trades),
+            win_rate=win_rate,
+            total_pnl=total_pnl,
+            avg_pnl=avg_pnl,
+            max_profit=max_profit,
+            max_loss=max_loss,
+            sharpe_ratio=sharpe
+        )
+    
+    def _calculate_trades(self, signals: np.ndarray) -> List[Dict]:
+        """Calculate trades from signals."""
+        trades = []
+        position = 0
+        entry_idx = None
+        
+        closes = self._data['Close'].values
+        times = self._data.index.to_numpy()
+        
+        for i in range(len(signals)):
+            signal = signals[i]
+            
+            # BUY signal
+            if signal == 1 and position == 0:
+                entry_idx = i
+                position = self._position_size / closes[i]
+            
+            # SELL signal
+            elif signal == -1 and position > 0 and entry_idx is not None:
+                exit_price = closes[i]
+                entry_price = closes[entry_idx]
+                pnl = position * (exit_price - entry_price)
+                
+                trades.append({
+                    'entry_time': times[entry_idx],
+                    'exit_time': times[i],
+                    'entry_price': entry_price,
+                    'exit_price': exit_price,
+                    'pnl': pnl
+                })
+                
+                position = 0
+                entry_idx = None
+        
+        return trades
+    
+    def get_top_patterns(self, n: int = 10) -> List[PatternResult]:
+        """Get top N patterns by performance."""
+        return self._results[:n]
+    
+    def get_comparison_report(self) -> pd.DataFrame:
+        """Get comparison report with/without news filter."""
+        # Test without news filter
+        results_no_filter = self.test_all_patterns(filter_news=False)
+        
+        # Test with news filter
+        results_with_filter = self.test_all_patterns(filter_news=True)
+        
+        # Create comparison DataFrame
+        data = []
+        for r_no, r_yes in zip(results_no_filter[:20], results_with_filter[:20]):
+            data.append({
+                'Pattern': r_no.pattern_name,
+                'Win Rate (No News Filter)': f"{r_no.win_rate:.1f}%",
+                'Win Rate (With News Filter)': f"{r_yes.win_rate:.1f}%",
+                'Total PnL (No Filter)': f"${r_no.total_pnl:.2f}",
+                'Total PnL (With Filter)': f"${r_yes.total_pnl:.2f}",
+                'Signals (No Filter)': r_no.total_signals,
+                'Signals (With Filter)': r_yes.total_signals,
+                'Sharpe (No Filter)': f"{r_no.sharpe_ratio:.2f}",
+                'Sharpe (With Filter)': f"{r_yes.sharpe_ratio:.2f}"
+            })
+        
+        return pd.DataFrame(data)
+    
+    def export_results(self, filename: str = 'pattern_ranking.csv') -> None:
+        """Export results to CSV."""
+        data = []
+        for result in self._results:
+            data.append({
+                'Rank': len(data) + 1,
+                'Pattern': result.pattern_name,
+                'Total Signals': result.total_signals,
+                'Winning Trades': result.winning_trades,
+                'Losing Trades': result.losing_trades,
+                'Win Rate %': f"{result.win_rate:.2f}",
+                'Total PnL': f"{result.total_pnl:.2f}",
+                'Avg PnL': f"{result.avg_pnl:.2f}",
+                'Max Profit': f"{result.max_profit:.2f}",
+                'Max Loss': f"{result.max_loss:.2f}",
+                'Sharpe Ratio': f"{result.sharpe_ratio:.2f}"
+            })
+        
+        df = pd.DataFrame(data)
+        df.to_csv(filename, index=False)
+        print(f"Results exported to {filename}")

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: yfinance-ta-patterns
+Version: 0.1.1
+Summary: CLI and helpers to scan yfinance data for TA-Lib candlestick patterns.
+Author: eminsk
+License: MIT License
+        
+        Copyright (c) 2025 eminsk
+        
+        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.
+        
+Project-URL: Repository, https://github.com/eminsk/yfinance-ta-patterns
+Project-URL: Homepage, https://github.com/eminsk/yfinance-ta-patterns
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ta-lib>=0.6.8
+Requires-Dist: yfinance>=0.2.66
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: pytz>=2024.1
+Requires-Dist: numpy>=1.26
+Dynamic: license-file
+
+## Forex Candlestick Scanner
+
+Python package + CLI that downloads Yahoo Finance data via `yfinance` and runs TA-Lib candlestick detectors for your symbol, timeframe, and date filters.
+
+### Quick start
+```bash
+# create env
+python -m venv .venv
+.\.venv\Scripts\activate  # PowerShell; adjust for your shell
+
+# install the package (editable for local dev)
+pip install -e .
+
+# run CLI (two entrypoints)
+yfinance-ta-patterns --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+# or
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+`pyproject.toml` targets Python `>=3.12`.
+
+### CLI usage
+```
+yfinance-ta-patterns [--pattern NAME | --all-patterns]
+                     [--symbol EURUSD] [--period 60d]
+                     [--timeframe 15m] [--date YYYY-MM-DD]
+                     [--start-date YYYY-MM-DD] [--end-date YYYY-MM-DD]
+```
+- `--pattern`: Single candlestick name (with or without `CDL` prefix).
+- `--all-patterns`: Scan every TA-Lib candlestick detector.
+- `--symbol`: Ticker without suffix; `=X` is appended automatically for Forex (default `EURUSD`).
+- `--period`: History window passed to `yfinance` (e.g., `60d`, `1mo`).
+- `--timeframe`: Use `M1/M5/M15/M30/H1/D1` or raw `yfinance` intervals (`1m`, `5m`, `1h`, `1d`, etc.).
+- `--date`: Filter signals for a single day.
+- `--start-date` / `--end-date`: Inclusive range filter (cannot be combined with `--date`).
+
+### Examples
+- All patterns for a single day:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --date 2025-04-01
+```
+- All patterns across a range:
+```bash
+yftp --all-patterns --symbol EURUSD --timeframe 5m --period 60d --start-date 2025-04-01 --end-date 2025-04-10
+```
+- One pattern without date filter:
+```bash
+yftp --pattern KICKING --symbol EURUSD --timeframe 5m --period 60d
+```
+
+### Data loader
+`yfinance_ta_patterns/forex_data_loader.py` fetches and normalizes OHLC data. It appends `=X` to symbols when missing and converts timestamps to UTC before shifting to the configured timezone (`Europe/Moscow` by default).
+
+### Pattern analysis
+`yfinance_ta_patterns/pattern_analyzer.py` wraps TA-Lib's `CDL*` functions, returning non-zero signals and applying optional date filters. When `--all-patterns` is used, it iterates over the full catalog and prints hits per pattern.
+
+### Pattern ranking helper (optional)
+`yfinance_ta_patterns/pattern_tester.py` contains a backtesting-style ranking tool. It depends on `utils.pattern_helper.PatternHelper` to enumerate patterns; add that helper before running comparisons or exports.
+
+### Project layout
+- `yfinance_ta_patterns/cli.py`: CLI entry point and argument parsing.
+- `yfinance_ta_patterns/forex_data_loader.py`: Data download and timezone normalization.
+- `yfinance_ta_patterns/pattern_analyzer.py`: Candlestick signal extraction.
+- `yfinance_ta_patterns/pattern_tester.py`: Experimental ranking/backtest utilities.
+- `main.py`: Thin wrapper to launch the CLI.
+
+### Packaging and releases
+- Nightly GitHub Actions workflow builds onefile Nuitka binaries for Windows/macOS/Linux and publishes nightly prereleases.
+- A PyPI publish workflow can be enabled by adding a secret `PYPI_API_TOKEN`; tags like `v0.1.0` will build sdist/wheel and upload.
+- TA-Lib is installed from PyPI on Windows; Linux/macOS CI builds the TA-Lib C library from source for the binaries. For local installs, PyPI wheels (`ta-lib` >=0.6.8) cover CPython 3.9–3.14.

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_cli.py
+yfinance_ta_patterns/__init__.py
+yfinance_ta_patterns/cli.py
+yfinance_ta_patterns/forex_data_loader.py
+yfinance_ta_patterns/pattern_analyzer.py
+yfinance_ta_patterns/pattern_tester.py
+yfinance_ta_patterns.egg-info/PKG-INFO
+yfinance_ta_patterns.egg-info/SOURCES.txt
+yfinance_ta_patterns.egg-info/dependency_links.txt
+yfinance_ta_patterns.egg-info/entry_points.txt
+yfinance_ta_patterns.egg-info/requires.txt
+yfinance_ta_patterns.egg-info/top_level.txt

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+yfinance-ta-patterns = yfinance_ta_patterns.cli:main
+yftp = yfinance_ta_patterns.cli:main

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/requires.txt

@@ -0,0 +1,5 @@
+ta-lib>=0.6.8
+yfinance>=0.2.66
+pandas>=2.2.0
+pytz>=2024.1
+numpy>=1.26

yfinance_ta_patterns-0.1.1/yfinance_ta_patterns.egg-info/top_level.txt

@@ -0,0 +1 @@
+yfinance_ta_patterns