From e8bf5282cd07278df7a3bfafba98ea0c900684c8 Mon Sep 17 00:00:00 2001
From: "Bobby (aider)" <bobby@abellana.work>
Date: Wed, 19 Feb 2025 22:30:39 -0800
Subject: [PATCH] refactor: Remove position sizing, stops, and targets from
 candlestick scanner

---
 src/screener/t_candlestick.py | 55 ++++++++++-------------------------
 1 file changed, 16 insertions(+), 39 deletions(-)

diff --git a/src/screener/t_candlestick.py b/src/screener/t_candlestick.py
index d6cb447..c3085dc 100644
--- a/src/screener/t_candlestick.py
+++ b/src/screener/t_candlestick.py
@@ -44,14 +44,11 @@ def check_entry_signal(df: pd.DataFrame, selected_patterns: list = None) -> list
     Returns:
         list: List of tuples (signal, date, signal_data) for each signal found
     """
-    if len(df) < 14:  # Need at least 14 bars for ATR calculation
+    if len(df) < 14:  # Need minimum bars for pattern recognition
         return []
     
     signals = []
     
-    # Calculate ATR first
-    atr = talib.ATR(df['high'].values, df['low'].values, df['close'].values, timeperiod=14)
-    
     # Use selected patterns or all patterns if none selected
     patterns_to_scan = {k: v for k, v in CANDLESTICK_PATTERNS.items() 
                        if selected_patterns is None or k in selected_patterns}
@@ -67,7 +64,7 @@ def check_entry_signal(df: pd.DataFrame, selected_patterns: list = None) -> list
         )
     
     # Look for signals across all candles
-    for i in range(14, len(df)):  # Start after ATR lookback period
+    for i in range(14, len(df)):  # Start after lookback period
         found_patterns = []
         
         for pattern_name, pattern_values in pattern_signals.items():
@@ -76,25 +73,10 @@ def check_entry_signal(df: pd.DataFrame, selected_patterns: list = None) -> list
                 found_patterns.append(CANDLESTICK_PATTERNS[pattern_name]['description'])
         
         if found_patterns:
-            # Calculate basic target and stop levels using recent price action
-            current_price = df.iloc[i]['close']
-            recent_low = df.iloc[max(0, i-5):i+1]['low'].min()  # Look back 5 bars for stop
-            
-            # Default to percentage-based calculations
-            atr_value = atr[i]
-            if pd.isna(atr_value):
-                target_price = current_price * 1.02  # 2% target
-                stop_loss = current_price * 0.99    # 1% stop
-            else:
-                target_price = current_price + (2 * atr_value)
-                stop_loss = max(recent_low, current_price - atr_value)
-            
             signal_data = {
-                'price': current_price,
+                'price': df.iloc[i]['close'],
                 'patterns': ', '.join(found_patterns),
-                'pattern_count': len(found_patterns),
-                'target_price': target_price,
-                'stop_loss': stop_loss
+                'pattern_count': len(found_patterns)
             }
             signals.append((True, df.iloc[i]['date'], signal_data))
     
@@ -106,16 +88,6 @@ def run_candlestick_scanner(min_price: float, max_price: float, min_volume: int,
                            selected_patterns: list = None) -> None:
     """
     Run candlestick pattern scanner to find bullish patterns
-    
-    Args:
-        min_price (float): Minimum stock price
-        max_price (float): Maximum stock price
-        min_volume (int): Minimum volume
-        portfolio_size (float, optional): Portfolio size for position sizing
-        interval (str, optional): Time interval for data. Defaults to "1d"
-        start_date (datetime, optional): Start date for scanning
-        end_date (datetime, optional): End date for scanning
-        selected_patterns (list, optional): List of patterns to scan for
     """
     try:
         # Initialize scanner components
@@ -138,16 +110,21 @@ def run_candlestick_scanner(min_price: float, max_price: float, min_volume: int,
             try:
                 df = get_stock_data(ticker, start_date, end_date, interval)
                 
-                if df.empty or len(df) < 5:  # Need at least 5 bars
+                if df.empty or len(df) < 14:  # Need minimum bars
                     continue
                     
-                signals = check_entry_signal(df, selected_patterns)  # Pass selected_patterns here
+                signals = check_entry_signal(df, selected_patterns)
                 for signal, signal_date, signal_data in signals:
-                    signal_data['date'] = signal_date
-                    entry_data = process_signal_data(
-                        ticker, signal_data, current_volume, 
-                        last_update, stock_type, calculator
-                    )
+                    entry_data = {
+                        'ticker': ticker,
+                        'date': signal_date,
+                        'entry_price': signal_data['price'],
+                        'patterns': signal_data['patterns'],
+                        'pattern_count': signal_data['pattern_count'],
+                        'volume': current_volume,
+                        'last_update': last_update,
+                        'type': stock_type
+                    }
                     bullish_signals.append(entry_data)
                     print_signal(entry_data, "🕯️")  # Candlestick emoji