Bobby/stock_system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gpt fix

Browse Source
This commit is contained in:
Bobby 2025-02-08 11:33:09 -08:00
parent 316ce608b6
commit 6be64ebe03
1 changed files with 69 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
src/screener/t_atr_ema_v2.py
View File

@ -1,34 +1,35 @@
from screener.user_input import get_interval_choice
import os
import pandas as pd
from datetime import datetime, timedelta
import pandas as pd
from db.db_connection import create_client
from indicators.three_atr_ema import ThreeATREMAIndicator
from trading.position_calculator import PositionCalculator
from screener.t_sunnyband import get_stock_data
from indicators.three_atr_ema import ThreeATREMAIndicator
def run_atr_ema_target_scanner(min_price: float, max_price: float, min_volume: int, portfolio_size: float = None):
print(f"\n🔍 Scanning for stocks ${min_price:.2f}-${max_price:.2f} with min volume {min_volume:,}")
# Set time range
interval = get_interval_choice()
end_date = datetime.now()
start_date = end_date - timedelta(days=90) # Expanded from 30 to 90 days
market_days = pd.bdate_range(start=start_date.date(), end=end_date.date())
if len(market_days) < 50:
start_date = end_date - timedelta(days=50*1.5) # Ensure 50 trading days coverage
start_ts = int(start_date.timestamp() * 1000000000)
end_ts = int(end_date.timestamp() * 1000000000)
start_date = end_date - timedelta(days=1) # Last trading day
start_ts = int(start_date.timestamp() * 1e9) # Convert to nanoseconds
end_ts = int(end_date.timestamp() * 1e9)
client = create_client()
try:
# Fetch stock prices within the defined range
query = f"""
WITH latest_data AS (
SELECT
ticker,
argMax(close, window_start) AS last_close,
sum(volume) AS total_volume,
max(window_start) AS last_update
argMax(open, window_start) AS last_open,
argMax(close, window_start) AS last_close,
argMax(high, window_start) AS last_high,
argMax(low, window_start) AS last_low,
max(window_start) AS last_update,
sum(transactions) AS transaction_count
FROM stock_db.stock_prices
WHERE window_start BETWEEN {start_ts} AND {end_ts}
GROUP BY ticker
@ -37,93 +38,73 @@ def run_atr_ema_target_scanner(min_price: float, max_price: float, min_volume: i
)
SELECT
ticker,
last_close,
total_volume,
last_update
last_open,
last_close,
last_high,
last_low,
last_update,
transaction_count
FROM latest_data
ORDER BY ticker
"""
result = client.query(query)
stocks = [(row[0], row[1], row[2], row[3]) for row in result.result_rows]
stocks = result.result_rows
if not stocks:
print("❌ No stocks found matching criteria.")
return
print("\n🔍 Verifying data availability...")
valid_query = f"""
SELECT ticker
FROM (
SELECT ticker, count() as cnt
FROM (
SELECT
ticker,
toDate(window_start) as date
FROM stock_db.stock_prices
WHERE window_start BETWEEN {start_ts} AND {end_ts}
GROUP BY ticker, date
)
GROUP BY ticker
HAVING count() >= 50
UNION ALL
SELECT ticker, count() as cnt
FROM stock_db.stock_prices_daily
WHERE date BETWEEN '{start_date.date()}' AND '{end_date.date()}'
GROUP BY ticker
HAVING cnt >= 50
)
GROUP BY ticker
HAVING sum(cnt) >= 50
"""
valid_result = client.query(valid_query)
valid_symbols = {row[0] for row in valid_result.result_rows}
qualified_stocks = [s for s in stocks if s[0] in valid_symbols]
# Enhanced validation check
for ticker in list(qualified_stocks):
test_df = get_stock_data(ticker[0], start_date, end_date, "1d")
if test_df.empty or len(test_df) < 50:
print(f"🚫 Removing {ticker[0]} - insufficient initial data")
qualified_stocks.remove(ticker)
print(f"\n✅ Found {len(qualified_stocks)} stocks with sufficient historical data")
print(f"\n✅ Found {len(stocks)} stocks matching criteria")
# **Correct column order as per ClickHouse output**
columns = ["ticker", "volume", "open", "close", "high", "low", "window_start", "transactions"]
df_stocks = pd.DataFrame(stocks, columns=columns)
# **Convert timestamps from nanoseconds to readable datetime**
df_stocks["window_start"] = pd.to_datetime(df_stocks["window_start"], unit="ns")
# Debugging: Check if columns exist
print("\n📊 Data Sample from ClickHouse Query:")
print(df_stocks.head())
indicator = ThreeATREMAIndicator()
calculator = PositionCalculator(portfolio_size, risk_percentage=1.0, stop_loss_percentage=7.0) if portfolio_size else None
bullish_signals = []
for ticker, current_price, current_volume, last_update in stocks:
for _, row in df_stocks.iterrows():
ticker = row["ticker"]
current_price = row["close"]
current_volume = row["volume"]
last_update = row["window_start"]
try:
# Validate interval and fetch data
VALID_INTERVALS = ["1d", "5m", "15m", "30m", "1h", "4h", "1w"]
try:
df = get_stock_data(ticker, start_date, end_date, "1d")
if df.empty or len(df) < 50:
df = get_stock_data(ticker, start_date - timedelta(days=30), end_date, "1d") # Try wider range
if df.empty or len(df) < 50:
print(f"⚠️ {ticker}: No valid data in extended timeframe")
continue
except Exception as e:
print(f"❌ Data fetch failed for {ticker}: {str(e)[:100]}")
df = get_stock_data(ticker, start_date, end_date, interval)
# **Check if DataFrame has expected columns**
if df.empty:
print(f"⚠️ No data found for {ticker}. Skipping.")
continue
results = indicator.calculate(df).dropna().tail(30) # Use only most recent valid data
missing_cols = [col for col in ["close", "open", "high", "low", "volume"] if col not in df.columns]
if missing_cols:
print(f"⚠️ {ticker} data is missing columns: {missing_cols}. Skipping.")
print(df.head()) # Debugging output
continue
results = indicator.calculate(df)
last_row = results.iloc[-1]
prev_row = results.iloc[-2]
# Check if entry condition is met
bullish_entry = (
last_row['close'] < last_row['ema'] and
prev_row['close'] <= prev_row['lower_band'] and
last_row['close'] > prev_row['close']
last_row["close"] < last_row["ema"] and
prev_row["close"] <= prev_row["lower_band"] and
last_row["close"] > prev_row["close"]
)
if bullish_entry:
entry_price = last_row['close']
entry_price = last_row["close"]
target_1 = entry_price * 1.10 # 10% profit
target_2 = entry_price * 1.20 # 20% profit
@ -131,25 +112,25 @@ def run_atr_ema_target_scanner(min_price: float, max_price: float, min_volume: i
trail_stop = None
trail_active = False
if last_row['close'] >= last_row['upper_band']:
if last_row["close"] >= last_row["upper_band"]:
trail_active = True
highest_price = max(results['high'].iloc[-5:]) # Last 5 days
highest_price = max(results["high"].iloc[-5:]) # Last 5 days
trail_stop = highest_price * 0.98 # 2% below high
# Position sizing
position = calculator.calculate_position_size(entry_price, target_2) if calculator else None
position_size = position['position_value'] if position else None
position_size = position["position_value"] if position else None
# Save signal
signal_data = {
'ticker': ticker,
'entry_price': entry_price,
'target_1': target_1,
'target_2': target_2,
'volume': current_volume,
'last_update': datetime.fromtimestamp(last_update / 1000000000),
'trail_stop': trail_stop,
'position_size': position_size
"ticker": ticker,
"entry_price": entry_price,
"target_1": target_1,
"target_2": target_2,
"volume": current_volume,
"last_update": last_update,
"trail_stop": trail_stop,
"position_size": position_size
}
bullish_signals.append(signal_data)
@ -165,13 +146,13 @@ def run_atr_ema_target_scanner(min_price: float, max_price: float, min_volume: i
# Save results
if bullish_signals:
output_dir = 'reports'
output_dir = "reports"
os.makedirs(output_dir, exist_ok=True)
output_file = f'{output_dir}/atr_ema_targets_{datetime.now().strftime("%Y%m%d_%H%M")}.csv'
output_file = f"{output_dir}/atr_ema_targets_{datetime.now().strftime('%Y%m%d_%H%M')}.csv"
pd.DataFrame(bullish_signals).to_csv(output_file, index=False)
print(f"\n📁 Saved bullish signals to {output_file}")
else:
print("❌ No bullish signals found.")
except Exception as e:
print(f"❌ Error during scan: {e}")
print(f"❌ Error during scan: {e}")