Track binaries via Git LFS (analysedata.xlsx, TA_Lib wheel)

.dockerignore

@@ -0,0 +1,69 @@
+# -----------------------
+# VCS / metadata
+# -----------------------
+.git
+.gitignore
+
+# -----------------------
+# Python build artefacts
+# -----------------------
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+*.coverage
+.pytest_cache/
+pytest_cache/
+htmlcov/
+.tox/
+
+# -----------------------
+# Virtual environments
+# -----------------------
+.venv/
+venv/
+env/
+ENV/
+
+# -----------------------
+# OS / Editor files
+# -----------------------
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+*.iml
+
+# -----------------------
+# App caches / local data
+# -----------------------
+cache/
+wheels/
+logs/
+tmp/
+temp/
+
+# Optional large/local data (uncomment if not needed in image)
+# data/
+# datasets/
+# models/
+# checkpoints/
+# nltk_data/
+# *.pt
+# *.pth
+# *.pkl
+# *.joblib
+# *.sqlite
+# *.db
+
+# -----------------------
+# Node (if present)
+# -----------------------
+node_modules/
+
+# -----------------------
+# Env files / secrets
+# -----------------------
+.env
+.env.*

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.xlsx filter=lfs diff=lfs merge=lfs -text
+TA_Lib-*.whl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,107 @@
+# -----------------------
+# Python / Flask basics
+# -----------------------
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual envs
+.venv/
+venv/
+env/
+ENV/
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Testing / coverage
+.pytest_cache/
+pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# Logs & PIDs
+logs/
+*.log
+*.pid
+
+# OS-specific
+.DS_Store
+Thumbs.db
+
+# IDE / Editor
+.vscode/
+.idea/
+*.iml
+*.code-workspace
+
+# -----------------------
+# App-specific
+# -----------------------
+
+# Local environment files (keep examples if you want)
+.env
+.env.*
+!.env.example
+
+# Credentials / keys (VERY IMPORTANT)
+*.pem
+*.p12
+*.key
+*.crt
+*.cer
+*.der
+*.pfx
+*.enc
+*service-account*.json
+*credentials*.json
+*credential*.json
+*-sa.json
+*secret*.json
+learnenglish-ai-*.json
+gcloud*.json
+
+# Media / generated assets
+static/videos/
+static/audio/
+static/transcripts/
+uploads/
+tmp/
+temp/
+*.tmp
+
+# MoviePy / temp renders (keep source code, ignore big artifacts)
+# (If you actually want to commit sample media, remove these)
+*.moviepy_temp*
+
+
+
+# Build caches / wheels
+cache/
+wheels/
+
+# Data / models you don’t want in git
+data/
+datasets/
+models/
+checkpoints/
+*.pt
+*.pth
+*.pkl
+*.joblib
+*.sqlite
+*.db
+
+# NLTK and similar local data
+nltk_data/
+
+# Node stuff (in case)
+node_modules/
+

Dockerfile

@@ -0,0 +1,40 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# System deps for builds (lxml, numpy/scipy), plus tools
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl wget git \
+    libxml2-dev libxslt1-dev zlib1g-dev \
+    libjpeg-dev libpng-dev \
+    libopenblas-dev liblapack-dev gfortran \
+    ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build and install TA-Lib (C library) so python TA-Lib will work
+RUN curl -L -o ta-lib-0.4.0-src.tar.gz http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz && \
+    tar -xzf ta-lib-0.4.0-src.tar.gz && cd ta-lib-0.4.0 && \
+    ./configure --prefix=/usr && make && make install && \
+    cd .. && rm -rf ta-lib-0.4.0 ta-lib-0.4.0-src.tar.gz
+
+WORKDIR /app
+
+# Python deps first (better layer caching)
+COPY requirements.txt /app/requirements.txt
+RUN python -m pip install --upgrade pip && \
+    pip install --no-cache-dir -r /app/requirements.txt
+
+# PyTorch (CPU wheels from official index)
+RUN pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu \
+    torch torchvision torchaudio
+
+# Pre-fetch NLTK data used by your code (VADER)
+RUN python - <<'PY'\nimport nltk;nltk.download('vader_lexicon')\nPY
+
+# Copy the application code
+COPY . /app
+
+# Start with gunicorn; HF provides $PORT
+# If your app object is named "app" in "pytrade.py", this is correct.
+CMD bash -lc "gunicorn -w 1 -k gthread -b 0.0.0.0:${PORT:-7860} pytrade:app --timeout 180"

README.md

@@ -1,10 +0,0 @@
----
-title: Pytrade Backend
-emoji: 👁
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

TA_Lib-0.4.29-cp312-cp312-win_amd64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:234d0aa150039b2263de0cc2828882db52e759bd9d785f46be52ddc9e9299a39
+size 531318

adxstrategies.py

@@ -0,0 +1,143 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+import datetime
+
+# Calculate ADX, +DI, and -DI values
+def calculate_adx(data, period=14):
+    high_prices = data['high']
+    low_prices = data['low']
+    close_prices = data['close']
+
+    adx = talib.ADX(high_prices, low_prices, close_prices, timeperiod=period)
+    plus_di = talib.PLUS_DI(high_prices, low_prices, close_prices, timeperiod=period)
+    minus_di = talib.MINUS_DI(high_prices, low_prices, close_prices, timeperiod=period)
+
+    return adx, plus_di, minus_di
+
+# Detect ADX crossover (directional indicators +DI and -DI)
+def adx_di_crossover_strategy(plus_di, minus_di, adx, threshold=20, lookback_days=5):
+    # We will loop over the last `lookback_days` to check for crossovers
+    for i in range(-lookback_days, 0):
+        # Check if ADX is above the threshold
+        if adx[i] > threshold:
+            # Bullish condition: +DI crosses above -DI and ADX is above threshold
+            if plus_di[i] > minus_di[i] and plus_di[i - 1] <= minus_di[i - 1]:
+                return "Bullish"
+            # Bearish condition: -DI crosses above +DI and ADX is above threshold
+            elif minus_di[i] > plus_di[i] and minus_di[i - 1] <= plus_di[i - 1]:
+                return "Bearish"
+    
+    return "Neutral"
+
+#ADX Breakout strategy
+def adx_breakout_strategy(data, adx, threshold=25):
+   
+    # Detect breakout condition (ADX above 25, price breaking resistance/support)
+    if adx[-1] > threshold:
+        if data['close'][-1] > data['high'][-2]:  # Bullish breakout
+            return "Bullish"
+        elif data['close'][-1] < data['low'][-2]:  # Bearish breakout
+            return "Bearish"
+    
+    return "Neutral"
+
+# ADX Slope Strategy
+def get_adx_slope_signal(adx, days=5, threshold=0.1):    
+    total_slope = 0
+
+    # Calculate slope for each of the last `days`
+    for i in range(-days, -1):
+        slope = adx[i + 1] - adx[i]
+        total_slope += slope
+
+    # Average slope
+    avg_slope = total_slope / (days - 1)
+
+    if avg_slope > threshold:
+        return "Bullish"
+    elif avg_slope < -threshold:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+# ADX Divergence Strategy
+def adx_divergence_strategy(data, adx, threshold=25):
+    """
+    Detects divergence between price and ADX.
+    A divergence occurs when price makes a new high/low, but ADX does not follow the same direction.
+    """
+    price_high = data['high']
+    price_low = data['low']
+
+    # Checking for divergence
+    price_divergence_bullish = price_high[-1] > price_high[-2] and adx[-1] < adx[-2]
+    price_divergence_bearish = price_low[-1] < price_low[-2] and adx[-1] > adx[-2]
+
+    if price_divergence_bullish:
+        return "Bullish"
+    elif price_divergence_bearish:
+        return "Bearish"
+    return "Neutral"
+
+
+# Main ADX strategy function
+def adx_strategies(data):
+   
+    # Calculate ADX, +DI, and -DI
+    adx, plus_di, minus_di = calculate_adx(data)
+
+    signals = {
+        "ADX": round(adx.iloc[-1], 2),        
+        "ADX + DI Crossover": adx_di_crossover_strategy(plus_di, minus_di, adx),
+        "ADX Breakout": adx_breakout_strategy(data, adx),       
+        "ADX Slope": get_adx_slope_signal(adx[-5:]),
+        "ADX Divergence": adx_divergence_strategy(data, adx)
+    }
+
+    weights = {
+        "ADX + DI Crossover": 35,
+        "ADX Breakout": 30,     
+        "ADX Slope": 20,
+        "ADX Divergence": 15        
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal,adx, plus_di, minus_di
+
+
+def extract_series(data, series, days=100):
+    series = pd.Series(series).dropna().tail(days)
+    series.index = data.index[-len(series):]
+    series.index = series.index.strftime('%Y-%m-%d')
+    return series.round(2).to_dict()
+
+# API-style function
+def get_adx_trade_signal(data):
+    adx_signals, overallscore, final_signal,adx, plus_di, minus_di = adx_strategies(data)
+    return {
+        "adx_signals": adx_signals,
+        "adx_score": overallscore,
+        "adx_final_signal": final_signal,
+        "ADX_Indicator": extract_series(data, adx),
+        "PLUS_DI": extract_series(data, plus_di),
+        "MINUS_DI": extract_series(data, minus_di) 
+    }

analysedata.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22de367d4c7376a90da9e3d4a11bf2aab4de907541695b1042427f76f526b272
+size 5787301

analysestock.py

@@ -0,0 +1,316 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+import math
+import requests
+import time
+import datetime
+from datetime import timedelta
+from collections import OrderedDict
+
+from rsistrategies import get_rsi_trade_signal
+from macdstrategies import get_macd_trade_signal
+from emastrategies import get_ema_trade_signal
+from atrstrategies import get_atr_trade_signal
+from adxstrategies import get_adx_trade_signal
+from fibostrategies import get_fibonacci_trade_signal
+from priceactionstrategies import get_priceaction_trade_signal
+from srstrategies import get_support_resistance_signal
+from bbstrategies import get_bollinger_trade_signal
+from fundamental import get_fundamental_details
+from news import get_latest_news_with_sentiment
+
+from prediction import (
+    load_or_train_highlow_model,
+    build_current_features_row_23k,
+    predict_high_low_for_current_row,
+)
+import os, numpy as np, pandas as pd
+
+TRAIN_XLSX_PATH = r"D:\PY-Trade\backend alone\analysedata.xlsx"
+MODEL_BUNDLE_PATH = r"C:\VIJI\pytrade-app\backend\models\gps_highlow_extratrees.pkl"
+
+
+from predictedchart import run_stock_prediction
+
+# ===================== TA scoring =====================
+def calculate_technical_analysis_score(indicator_scores):
+    indicator_weights = {
+        'RSI': 13,
+        'MACD': 13,
+        'ATR': 5,
+        'ADX': 4,
+        'EMA': 13,
+        'PriceAction': 14,
+        'Bollinger': 10,
+        'Fibonacci': 4,
+        'SR': 9
+    }
+    weight_values = list(indicator_weights.values())
+    weighted_score = sum(score * weight for score, weight in zip(indicator_scores, weight_values))
+    total_weight = sum(weight_values)
+    technical_analysis_score = (weighted_score / (total_weight * 100)) * 85    
+    return technical_analysis_score
+
+# ================== Pivot levels & trade ==================
+def calculate_pivot_points(ticker, score, live_price, atr_period=14):
+    data = yf.download(ticker, period="2mo", interval="1wk")
+    df = yf.download(ticker, period="2mo", interval="1d")
+
+    if score < 50:
+        return {
+            "remarks": "Score is below 50%, avoid trading. No trade recommendation",
+            "pivot_point": "N/A", "resistance1": "N/A", "support1": "N/A",
+            "resistance2": "N/A", "support2": "N/A",
+            "resistance3": "N/A", "support3": "N/A",
+            "entry_point": "N/A", "stop_loss": "N/A", "target_price": "N/A",
+            "s1_pect": "N/A", "s2_pect": "N/A", "s3_pect": "N/A",
+            "r1_pect": "N/A", "r2_pect": "N/A", "r3_pect": "N/A", "p1_pect": "N/A"
+        }
+
+    if 50 <= score < 65:
+        stoploss_multiplier, risk_reward_ratio = 1.2, 1.5
+        remarks = "Neutral confidence - Monitor the price for further confirmation."
+    elif 65 <= score < 70:
+        stoploss_multiplier, risk_reward_ratio = 1.5, 2.0
+        remarks = "Moderate confidence - Conservative stop loss and reward."
+    elif 70 <= score < 80:
+        stoploss_multiplier, risk_reward_ratio = 1.8, 2.5
+        remarks = "Good confidence - Balanced approach."
+    else:
+        stoploss_multiplier, risk_reward_ratio = 2.0, 3.0
+        remarks = "High confidence - Aggressive approach."
+
+    close_prices = df['Close'].to_numpy().flatten()
+    high_prices = df['High'].to_numpy().flatten()
+    low_prices = df['Low'].to_numpy().flatten()
+    df['ATR'] = talib.ATR(high_prices, low_prices, close_prices, timeperiod=atr_period)
+
+    latest_atr = df['ATR'].iloc[-1]
+    entry_point = live_price
+    stop_loss = entry_point - (stoploss_multiplier * latest_atr)
+    target_price = entry_point + ((entry_point - stop_loss) * risk_reward_ratio)
+
+    previous_week = data.iloc[-2]
+    high, low, close = previous_week["High"], previous_week["Low"], previous_week["Close"]
+
+    P = (high + low + close) / 3
+    R1 = (2 * P) - low
+    S1 = (2 * P) - high
+    R2 = P + (high - low)
+    S2 = P - (high - low)
+    R3 = high + 2 * (P - low)
+    S3 = low - 2 * (high - P)
+
+    p1_pect = ((P - live_price) / P) * 100
+    s1_pect = ((S1 - live_price) / S1) * 100
+    s2_pect = ((S2 - live_price) / S2) * 100
+    s3_pect = ((S3 - live_price) / S3) * 100
+    r1_pect = ((R1 - live_price) / R1) * 100
+    r2_pect = ((R2 - live_price) / R2) * 100
+    r3_pect = ((R3 - live_price) / R3) * 100
+
+    return {
+        "pivot_point": round(float(P), 2),
+        "resistance1": round(float(R1), 2),
+        "support1": round(float(S1), 2),
+        "resistance2": round(float(R2), 2),
+        "support2": round(float(S2), 2),
+        "resistance3": round(float(R3), 2),
+        "support3": round(float(S3), 2),
+        "entry_point": round(float(entry_point), 2),
+        "stop_loss": round(float(stop_loss), 2),
+        "target_price": round(float(target_price), 2),
+        "s1_pect": round(float(s1_pect), 2),
+        "s2_pect": round(float(s2_pect), 2),
+        "s3_pect": round(float(s3_pect), 2),
+        "r1_pect": round(float(r1_pect), 2),
+        "r2_pect": round(float(r2_pect), 2),
+        "r3_pect": round(float(r3_pect), 2),
+        "p1_pect": round(float(p1_pect), 2),
+        "remarks": remarks
+    }
+
+
+
+# =================== Main: short-term swing ===================
+def analysestock(ticker):
+   
+    stock_data = yf.download(ticker, start="2023-01-01", end="2025-09-01", interval="1d") 
+    stock_data.columns = [col.lower() if isinstance(col, str) else col[0].lower() for col in stock_data.columns]
+    stockdetail = yf.Ticker(ticker)
+    company_name = stockdetail.info.get("longName", "Company name not found")
+    live_price = stockdetail.info["regularMarketPrice"]
+    price_change = stockdetail.info['regularMarketChange']
+    percentage_change = stockdetail.info['regularMarketChangePercent']
+
+    recentdays = stock_data.tail(20)
+    ohlc_data = []
+    for index, row in recentdays.iterrows():
+        ohlc_data.append({
+            "x": index.strftime('%Y-%m-%d'),
+            "y": [round(row['open'], 2), round(row['high'], 2), round(row['low'], 2), round(row['close'], 2)]
+        })
+
+    # TA Strategy signals
+    rsi_trade_signal = get_rsi_trade_signal(stock_data)
+    macd_trade_signal = get_macd_trade_signal(stock_data)
+    ema_trade_signal = get_ema_trade_signal(stock_data)
+    atr_trade_signal = get_atr_trade_signal(stock_data)
+    adx_trade_signal = get_adx_trade_signal(stock_data)
+    fibo_trade_signal = get_fibonacci_trade_signal(stock_data)
+    priceaction_trade_signal = get_priceaction_trade_signal(stock_data)
+    bb_trade_signal = get_bollinger_trade_signal(stock_data)
+    sr_trade_signal = get_support_resistance_signal(stock_data)
+
+    final_trade_signal = OrderedDict([
+        ("RSI", rsi_trade_signal['rsi_final_signal']),
+        ("MACD", macd_trade_signal['macd_final_signal']),
+        ("ATR", atr_trade_signal['atr_final_signal']),
+        ("EMA", ema_trade_signal['ema_final_signal']),
+        ("ADX", adx_trade_signal['adx_final_signal']),
+        ("Fibo", fibo_trade_signal['fib_final_signal']),
+        ("BB", bb_trade_signal['bollinger_final_signal']),
+        ("SR", sr_trade_signal['sr_final_signal']),
+        ("PA_MS", priceaction_trade_signal['priceaction_final_signal']),
+    ])
+
+    indicator_score = [
+        rsi_trade_signal["rsi_score"],
+        macd_trade_signal['macd_score'],
+        atr_trade_signal['atr_score'],
+        adx_trade_signal['adx_score'],
+        ema_trade_signal['ema_score'],
+        priceaction_trade_signal['priceaction_score'],
+        bb_trade_signal['bollinger_score'],
+        fibo_trade_signal['fib_score'],
+        sr_trade_signal['sr_score']
+    ]
+
+    overall_ta_score = calculate_technical_analysis_score(indicator_score)
+
+    #FA signals
+
+    fundamental_analysis = get_fundamental_details(ticker)
+
+    #news   
+    
+    news_payload = get_latest_news_with_sentiment(
+        company_name,
+        period="1d",      
+        max_results=10,
+        language="en",
+        country="US"      
+    )
+
+    #overallscore
+
+    overall_fa_score = fundamental_analysis["overall_fa_score"]
+    overall_news_score = news_payload['overall_news_score']
+    combined_overall_score = overall_ta_score + overall_fa_score + overall_news_score
+    combined_overall_signal = np.where(combined_overall_score > 65, 'Buy',
+                                       np.where(combined_overall_score > 50, 'Neutral', 'DBuy'))
+
+
+    #trade recommendation
+
+    pivot_levels = calculate_pivot_points(ticker, combined_overall_score, live_price)
+
+
+    #prediiction
+    predictions = run_stock_prediction(ticker)
+    predictions_float = [float(pred) for pred in predictions['Predicted Close']]
+    prediction_dates = pd.to_datetime(predictions['Date']).dt.strftime('%d-%m-%Y').tolist()
+    model_error = None
+    pred_high, pred_low = np.nan, np.nan
+    try:
+        bundle = load_or_train_highlow_model(TRAIN_XLSX_PATH, MODEL_BUNDLE_PATH)
+
+        current_feat_row = build_current_features_row_23k(
+            ticker=ticker,
+            stock_data=stock_data,
+            rsi_trade_signal=rsi_trade_signal,
+            macd_trade_signal=macd_trade_signal,
+            ema_trade_signal=ema_trade_signal,
+            atr_trade_signal=atr_trade_signal,
+            adx_trade_signal=adx_trade_signal,
+            bb_trade_signal=bb_trade_signal,
+            sr_trade_signal=sr_trade_signal,
+            priceaction_trade_signal=priceaction_trade_signal,
+            fibo_trade_signal=fibo_trade_signal,
+            overall_ta_score=overall_ta_score,
+        )
+
+        pred_high, pred_low = predict_high_low_for_current_row(
+            bundle=bundle,
+            current_row_df=current_feat_row,
+            live_close=stock_data['close'].iloc[-1]
+        )
+    except Exception as ex:
+        model_error = f"{type(ex).__name__}: {ex}"
+        print(f"[WARN] High/Low prediction failed: {model_error}")
+
+
+
+
+    response = {        
+        "ticker": ticker,
+        "company_name": company_name,
+        "live_price": round(live_price, 2),
+        "price_change": round(price_change, 2),
+        "percentage_change": round(percentage_change, 2),
+        "ohlc_data":ohlc_data,
+        "RSI": rsi_trade_signal['rsi_signals'],
+        "MACD": macd_trade_signal['macd_signals'],
+        "EMA": ema_trade_signal['ema_signals'],
+        "ATR": atr_trade_signal['atr_signals'],
+        "ADX": adx_trade_signal['adx_signals'],
+        "Fibo": fibo_trade_signal['fib_signals'],
+        "SR": sr_trade_signal['support_resistance_signals'],
+        "BB": bb_trade_signal['bollinger_signals'],
+        "PA_MS": priceaction_trade_signal['priceaction_signals'],
+        "final_trade_signal": final_trade_signal,
+        "overall_ta_score": round(overall_ta_score, 2),        
+        "fundamental_analysis": fundamental_analysis,
+        "overall_fa_score": overall_fa_score,
+        "news_overall_score": overall_news_score,
+        "news": news_payload["items"],
+        "combined_overall_score": round(combined_overall_score, 2),
+        "combined_overall_signal": str(combined_overall_signal),
+        "tradingInfo": pivot_levels,
+
+        "RSI 14": rsi_trade_signal['rsi_14_last_2_years'],
+        "RSI 5": rsi_trade_signal['rsi_5_last_2_years'],
+        "MA_20": rsi_trade_signal['ma'],
+        "Close": rsi_trade_signal['close'],
+        "LowerBB": rsi_trade_signal['lowerbb'],
+        "UpperBB": rsi_trade_signal['upperbb'],
+        "MACDLine": macd_trade_signal['macd_line'],
+        "MACDSignalLine": macd_trade_signal['macd_signal_line'],
+        "MACDHistogram": macd_trade_signal['macd_histogram'],
+        "ATRValue": atr_trade_signal['atr_values'],
+        "EMA 5": ema_trade_signal['EMA_5'],
+        "EMA 20": ema_trade_signal['EMA_20'],
+        "EMA 50": ema_trade_signal['EMA_50'],
+        "ADX_Indicator": adx_trade_signal['ADX_Indicator'],
+        "PLUS_DI": adx_trade_signal['PLUS_DI'],
+        "MINUS_DI": adx_trade_signal['MINUS_DI'],
+        "prediction_prices": predictions_float,
+        "prediction_dates": prediction_dates,
+    }  
+
+
+    response.update({
+        "ai_predicted_highest_price": pred_high,
+        "ai_predicted_lowest_price": pred_low,
+        "ai_model_meta": {
+            "model": "ExtraTreesRegressor (multi-output capable, native)",
+            "bundle_path": MODEL_BUNDLE_PATH,
+            "trained_rows": (bundle.get("trained_rows") if 'bundle' in locals() else None),
+            "sklearn_version": (bundle.get("sklearn_version") if 'bundle' in locals() else None)
+        },
+        "ai_model_error": model_error
+    })
+
+    return response

atrstrategies.py

@@ -0,0 +1,157 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import datetime
+import talib
+
+
+# Calculate ATR values
+def calculate_atr(data):
+    atr = talib.ATR(data['high'], data['low'], data['close'], timeperiod=14)      
+    return atr
+
+# ATR Breakout Strategy (Price crossing ATR threshold)
+def atr_breakout_strategy(data, atr, multiplier=2):
+    latest_close = data['close'].iloc[-2]
+    previous_close = data['close'].iloc[-1]
+    latest_atr = atr.iloc[-2]
+    threshold_up = latest_close + (multiplier * latest_atr)
+    threshold_down = latest_close - (multiplier * latest_atr)
+
+    # Bullish breakout (price moves above ATR threshold)
+    if previous_close > threshold_up:
+        return "Bullish"
+    # Bearish breakout (price moves below ATR threshold)
+    elif previous_close < threshold_down:
+        return "Bearish"
+    # No breakout, neutral
+    else:
+        return "Neutral"
+
+def calculate_dynamic_threshold(atr, period=14):
+   
+    atr_change = atr.pct_change(periods=period)  
+    atr_std = atr_change.std()  
+    dynamic_threshold = 2 * atr_std  
+    return dynamic_threshold
+
+# ATR Expansion Strategy (Confirming trend continuation)
+def atr_expansion_strategy(data, atr, period=14, days_to_check=5):
+   
+   
+    dynamicthreshold = calculate_dynamic_threshold(atr, period)
+   
+ 
+    atr_last = atr.iloc[-days_to_check:]  
+    atr_expansion = atr_last[-1] > atr_last.mean() + dynamicthreshold  
+    
+    if atr_expansion:
+        
+        if data['close'].iloc[-1] > data['close'].iloc[-2]:
+            return "Bullish"  
+        elif data['close'].iloc[-1] < data['close'].iloc[-2]:
+            return "Bearish"  
+        else:
+            return "Neutral" 
+
+  
+    return "Neutral"  
+
+# ATR Squeeze/Compression Strategy (Confirming trend continuation)
+def atr_squeeze_strategy(data, atr, period=14, days_to_check=5):   
+   
+    dynamicthreshold = calculate_dynamic_threshold(atr, period)   
+ 
+    atr_last = atr.iloc[-days_to_check:]  
+    atr_compression = atr_last[-1] < atr_last.mean() - dynamicthreshold  
+    resistance = data['high'].iloc[-days_to_check:].max() 
+    support = data['low'].iloc[-days_to_check:].min() 
+
+    if atr_compression:
+
+        if data['close'].iloc[-1] > resistance:
+            return "Bullish"            
+       
+        elif data['close'].iloc[-1] < support:
+            return "Bearish"       
+       
+        else:
+            return "Neutral" 
+
+  
+    return "Neutral" 
+
+# ATR Trend Reversal Strategy (ATR rising during price reversal)
+def atr_trend_reversal_strategy(atr, price, days=5):
+    # Look at the change in price and ATR
+    price_diff = price.iloc[-1] - price.iloc[-days]
+    atr_diff = atr.iloc[-1] - atr.iloc[-days]
+    
+    # If price is reversing (uptrend to downtrend or vice versa), and ATR is increasing
+    if price_diff > 0 and atr_diff > 0:
+        return "Bullish"
+    elif price_diff < 0 and atr_diff > 0:
+        return "Bearish"
+    return "Neutral"
+
+# Main strategy function using ATR strategy
+def atr_strategies(data):
+    
+    atr = calculate_atr(data)
+    
+    atr_breakout = atr_breakout_strategy(data, atr)    
+   
+    atr_expansion = atr_expansion_strategy(data,atr)
+
+    atr_squeeze = atr_squeeze_strategy(data,atr)  
+    
+    atr_trend_reversal = atr_trend_reversal_strategy(atr, data['close'])
+
+    # Collect signals
+    signals = {
+        "ATR": round(atr.iloc[-1], 2),
+        "ATR Breakout": atr_breakout,
+        "ATR Expansion": atr_expansion,    
+        "ATR Squeeze": atr_squeeze,    
+        "ATR Trend Reversal": atr_trend_reversal
+    }
+
+    weights = {
+        "ATR Breakout": 45,
+        "ATR Expansion": 15, 
+        "ATR Squeeze": 15,
+        "ATR Trend Reversal": 25       
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal,atr
+
+# API-style function to fetch ATR signals
+def get_atr_trade_signal(data):
+    atr_signals, overallscore, final_signal,atr = atr_strategies(data)
+    atr_series = pd.Series(atr, index=data.index).dropna().tail(100)
+    atr_series.index = atr_series.index.strftime('%Y-%m-%d')
+    return {
+        "atr_signals": atr_signals,
+        "atr_score": overallscore,
+        "atr_final_signal": final_signal,
+        "atr_values": atr_series.round(2).to_dict()
+
+    }

bbstrategies.py

@@ -0,0 +1,129 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+import datetime
+
+# Bollinger Band Calculation
+def calculate_bollinger(data, period=20, stddev=2):
+    close = data['close']
+    upper, middle, lower = talib.BBANDS(close, timeperiod=period, nbdevup=stddev, nbdevdn=stddev, matype=0)
+    return upper, middle, lower
+
+
+#BB Squeeze  breakout/fade after low volatility
+def detect_bb_squeeze(close, upper, lower, middle, lookback=20, perc=20):
+    bandwidth = (upper - lower) / middle
+    # 20th percentile over the lookback window
+    thresh = np.percentile(bandwidth.iloc[-lookback:], perc)
+    if bandwidth.iloc[-1] < thresh:
+        return "Neutral"
+    # otherwise fall back to a breakout rule
+    if close.iloc[-1] > upper.iloc[-1]:
+        return "Bullish"
+    elif close.iloc[-1] < lower.iloc[-1]:
+        return "Bearish"
+    return "Neutral"
+
+
+# BB Breakout Detection
+def detect_bb_breakout(close, upper, lower):
+    if close.iloc[-1] > upper.iloc[-1]:
+        return "Bullish"
+    elif close.iloc[-1] < lower.iloc[-1]:
+        return "Bearish"
+    return "Neutral"
+
+
+# BB Breakout Reversal
+def detect_bb_breakout_reversal(data, upper, lower, middle, lookahead=3):
+    
+    i = len(data) - lookahead - 1  
+
+    if i < 0:
+        return "Neutral"
+
+    row = data.iloc[i]
+    # Bullish Reversal
+    if row['close'] > upper.iloc[i]:
+        for j in range(1, lookahead + 1):
+            next_row = data.iloc[i + j]
+            if next_row['close'] < upper.iloc[i + j] and next_row['close'] > middle.iloc[i + j]:
+                return "Bullish"
+
+    # Bearish Reversal
+    elif row['close'] < lower.iloc[i]:
+        for j in range(1, lookahead + 1):
+            next_row = data.iloc[i + j]
+            if next_row['close'] > lower.iloc[i + j] and next_row['close'] < middle.iloc[i + j]:
+                return "Bearish"
+
+    return "Neutral"
+
+
+
+# Middle Band Pullback
+def detect_middle_band_pullback(close, middle, upper, lower, threshold=0.10, trend_lookback=3):
+    band_width = upper.iloc[-1] - lower.iloc[-1]
+    if abs(close.iloc[-1] - middle.iloc[-1]) < band_width * threshold:
+        trend_above = all(close.iloc[-i] > middle.iloc[-i] for i in range(2, 2 + trend_lookback))
+        trend_below = all(close.iloc[-i] < middle.iloc[-i] for i in range(2, 2 + trend_lookback))
+        if trend_above:
+            return "Bullish"
+        elif trend_below:
+            return "Bearish"
+    return "Neutral"
+
+
+
+# Master strategy function
+def bollinger_strategies(data):
+    
+    upper, middle, lower = calculate_bollinger(data)
+
+    signals = {
+        "UpperBand": round(upper.iloc[-1], 2),
+        "MiddleBand": round(middle.iloc[-1], 2),
+        "LowerBand": round(lower.iloc[-1], 2),
+        "BB Squeeze": detect_bb_squeeze(data['close'], upper, lower, middle),
+        "BB Breakout": detect_bb_breakout(data['close'], upper, lower),
+        "BB Breakout Reversal": detect_bb_breakout_reversal(data, upper, lower, middle),
+        "Middle Band Pullback": detect_middle_band_pullback(data['close'], middle, upper, lower)       
+        
+    }
+
+    weights = {
+        "BB Squeeze": 30,
+        "BB Breakout": 25,
+        "BB Breakout Reversal": 25,
+        "Middle Band Pullback": 20        
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if "Bullish" in signal or "Breakout Up" in signal or "Squeeze" in signal or "Pullback" in signal:
+            total_score += weight
+        elif "Neutral" in signal or "No Breakout" in signal:
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal
+
+# API-style function
+def get_bollinger_trade_signal(data):
+    bb_signals, overall_score, final_signal = bollinger_strategies(data)
+    return {
+        "bollinger_signals": bb_signals,
+        "bollinger_score": overall_score,
+        "bollinger_final_signal": final_signal
+    }

companies.py

@@ -0,0 +1,50 @@
+# utils.py
+import csv
+import io
+import requests
+from typing import List, Dict
+from requests.exceptions import RequestException
+import time
+
+# List of URLs for NIFTY50 and NIFTY100
+NIFTY_URLS = {
+    "NIFTY50": "https://www.niftyindices.com/IndexConstituent/ind_nifty50list.csv",
+    "NIFTY100": "https://www.niftyindices.com/IndexConstituent/ind_nifty100list.csv"
+}
+
+def fetch_nifty_companies(index_code: str, retries: int = 3, delay: int = 5) -> List[Dict[str, str]]:
+    # Get the URL for the given index_code
+    url = NIFTY_URLS.get(index_code)
+    
+    if not url:
+        raise ValueError(f"Unknown index code: {index_code}")
+    
+    # Retry logic
+    for attempt in range(retries):
+        try:
+            # Fetch the CSV data
+            response = requests.get(url)
+            # Ensure the request was successful
+            response.raise_for_status()
+            # Read CSV data from the response text
+            return parse_nifty_csv(response.text)
+        
+        except RequestException as e:
+            print(f"Attempt {attempt + 1} failed: {e}")
+            if attempt < retries - 1:
+                time.sleep(delay)  # Wait before retrying
+            else:
+                raise Exception(f"Failed to fetch data after {retries} attempts.") from e
+
+# Function to fetch companies for both NIFTY50 and NIFTY100
+def get_companies_from_indices() -> Dict[str, List[Dict[str, str]]]:
+    nifty50_companies = fetch_nifty_companies("NIFTY50")
+    nifty100_companies = fetch_nifty_companies("NIFTY100")
+    
+    # Combine both lists and return
+    all_companies = {
+        "NIFTY50": nifty50_companies,
+        "NIFTY100": nifty100_companies
+    }
+    
+    return all_companies

emastrategies.py

@@ -0,0 +1,147 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+import datetime
+
+
+
+# Calculate EMA values
+def calculate_ema(data, short_period=5, medium_period=20, long_period=50):
+    close_prices = data['close']
+    ema_short = talib.EMA(close_prices, timeperiod=short_period)
+    ema_medium = talib.EMA(close_prices, timeperiod=medium_period)
+    ema_long = talib.EMA(close_prices, timeperiod=long_period)
+    return ema_short,ema_medium, ema_long
+
+def detect_ema_crossover(ema20, ema50):    
+    
+    for i in range(len(ema20) - 1):
+        older_ema20 = ema20[i]
+        newer_ema20 = ema20[i + 1]
+        older_ema50 = ema50[i]
+        newer_ema50 = ema50[i + 1]
+        
+        # Bullish crossover - EMA 20 above EMA 50
+        if older_ema20 <= older_ema50 and newer_ema20 > newer_ema50:
+            return "Bullish"
+        # Bearish crossover EMA 20 below EMA 50
+        elif older_ema20 >= older_ema50 and newer_ema20 < newer_ema50:
+            return "Bearish"
+    
+    return "Neutral"
+
+
+def detect_ema_price_crossover(ema20, price, days=5):
+    bullish_days = 0
+    bearish_days = 0
+
+    # Check the last N days
+    for i in range(-days, 0):
+        if price[i] > ema20[i]:
+            bullish_days += 1
+        elif price[i] < ema20[i]:
+            bearish_days += 1
+
+    # Final decision
+    if bullish_days == days:
+        return "Bullish"
+    elif bearish_days == days:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+def get_ema_average_slope_signal(ema_series, days=5, threshold=0.1):    
+
+    total_slope = 0
+
+    # Calculate slope for each of the last `days`
+    for i in range(-days, -1):
+        slope = ema_series[i + 1] - ema_series[i]
+        total_slope += slope
+
+    # Average slope
+    avg_slope = total_slope / (days - 1)
+
+    if avg_slope > threshold:
+        return "Bullish"
+    elif avg_slope < -threshold:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+def triple_ema_strategy(ema_short, ema_medium, ema_long):
+    
+    if ema_short > ema_medium and ema_short > ema_long:
+        return "Bullish"
+    
+    # Bearish condition: Short-term EMA crosses below medium and long-term EMAs
+    elif ema_short < ema_medium and ema_short < ema_long:
+        return "Bearish"
+    
+    # Neutral condition: EMAs are not aligned
+    else:
+        return "Neutral"
+
+
+# Main strategy function using EMA crossover
+def ema_strategies(data):
+   
+    ema5, ema_20, ema_50 = calculate_ema(data, short_period=5, medium_period=20, long_period=50)
+    
+    signals = {
+        "EMA 20": round(ema_20.iloc[-1], 2),
+        "EMA 50": round(ema_50.iloc[-1], 2),
+        "EMA Crossover": detect_ema_crossover(ema_20[-5:], ema_50[-5:]),
+        "EMA Price Crossover": detect_ema_price_crossover(ema_20[-5:], data['close'][-5:]),
+        "EMA Slope": get_ema_average_slope_signal(ema_20[-5:]),
+        "Triple EMA": triple_ema_strategy(ema5.iloc[-1], ema_20.iloc[-1], ema_50.iloc[-1])
+    }
+
+    weights = {
+        "EMA Crossover": 30,
+        "EMA Price Crossover": 25,
+        "EMA Slope": 20,
+        "Triple EMA": 25
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal,ema5, ema_20, ema_50
+
+# API-style function
+def get_ema_trade_signal(data):
+    ema_signals, overallscore, final_signal,ema5, ema_20, ema_50 = ema_strategies(data)
+
+    ema5_series = pd.Series(ema5, index=data.index).dropna().tail(100)
+    ema5_series.index = ema5_series.index.strftime('%Y-%m-%d')
+    ema_20_series = pd.Series(ema_20, index=data.index).dropna().tail(100)
+    ema_20_series.index = ema_20_series.index.strftime('%Y-%m-%d')
+    ema_50_series = pd.Series(ema_50, index=data.index).dropna().tail(100)
+    ema_50_series.index = ema_50_series.index.strftime('%Y-%m-%d')
+    return {
+        "ema_signals": ema_signals,
+        "ema_score": overallscore,
+        "ema_final_signal": final_signal,
+        "EMA_5": ema5_series.round(2).to_dict(),
+        "EMA_20": ema_20_series.round(2).to_dict(),
+        "EMA_50": ema_50_series.round(2).to_dict()
+
+    }

fibostrategies.py

@@ -0,0 +1,233 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+import datetime
+
+
+# Detect recent trend (uptrend or downtrend)
+def detect_trend(data, lookback_days=7):
+    recent_data = data.iloc[-lookback_days:]
+    closes = recent_data['close'].values
+
+    if closes[-1] > closes[0]:
+        return "Uptrend"
+    elif closes[-1] < closes[0]:
+        return "Downtrend"
+    else:
+        return "Sideways"
+
+# Fibonacci Retracement Pullback Strategy
+def fibonacci_retracement_bounce(data, fib_levels=[0.382, 0.5, 0.618], tolerance=0.005, lookback_days=7):
+    last_close = data['close'].iloc[-1]
+
+    # Detect recent trend
+    trend = detect_trend(data, lookback_days)
+
+    # Use recent high/low
+    recent_data = data.iloc[-lookback_days:]
+    swing_high = recent_data['high'].max()
+    swing_low = recent_data['low'].min()
+
+    retracement_levels = {level: swing_high - (swing_high - swing_low) * level for level in fib_levels}
+
+    nearest_level = None
+    min_deviation = float('inf')
+
+    for level, price_level in retracement_levels.items():
+        deviation = abs(last_close - price_level) / price_level
+        if deviation < min_deviation:
+            min_deviation = deviation
+            nearest_level = (level, price_level)
+
+    if nearest_level:
+        _, level_price = nearest_level
+        if min_deviation <= tolerance:
+            if trend == "Uptrend" and last_close > level_price:
+                return "Bullish"
+            elif trend == "Downtrend" and last_close < level_price:
+                return "Bearish"
+
+    return "Neutral"
+
+# 2. Fibonacci Breakout (Retracement Break) Strategy
+
+def fibonacci_breakout(data, fib_threshold=0.618, lookback_days=7, check_candles=3, tolerance=0.005):
+    recent_data = data.iloc[-lookback_days:]
+    last_data = data.iloc[-check_candles:]
+
+    swing_high = recent_data['high'].max()
+    swing_low = recent_data['low'].min()
+
+    fib_level_price = swing_high - (swing_high - swing_low) * fib_threshold
+
+    # Check last few candles
+    crossed_above = 0
+    crossed_below = 0
+
+    for i in range(len(last_data)):
+        close_price = last_data['close'].iloc[i]
+        if close_price > fib_level_price * (1 + tolerance):
+            crossed_above += 1
+        elif close_price < fib_level_price * (1 - tolerance):
+            crossed_below += 1
+
+    # Decision
+    if crossed_above == check_candles:
+        return "Bullish"
+    elif crossed_below == check_candles:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+# 3. Golden Pocket Reversal Strategy
+
+def calculate_fib_levels(high, low):
+    """Calculate Fibonacci retracement levels"""
+    diff = high - low
+    return {
+        '23.6%': high - 0.236 * diff,
+        '38.2%': high - 0.382 * diff,
+        '50%': high - 0.5 * diff,
+        '61.8%': high - 0.618 * diff,
+        '65%': high - 0.65 * diff,
+        '78.6%': high - 0.786 * diff
+    }
+
+def golden_pocket_reversal_strategy(data, lookback_period=7):
+    """
+    Golden Pocket Reversal Strategy (61.8% - 65%)
+    
+    Parameters:
+    - data: DataFrame with columns ['high', 'low', 'close']
+    - lookback_period: Number of periods to consider for swing high/low
+    
+    Returns:
+    - 'bullish' if bullish reversal signal detected
+    - 'bearish' if bearish reversal signal detected
+    - 'neutral' if no clear signal
+    """
+    
+    if len(data) < lookback_period + 1:
+        return "neutral"
+    
+    # Get recent swing high and low
+    recent_high = data['high'].rolling(lookback_period).max().iloc[-1]
+    recent_low = data['low'].rolling(lookback_period).min().iloc[-1]
+    
+    # Calculate Fibonacci levels
+    fib_levels = calculate_fib_levels(recent_high, recent_low)
+    golden_zone_low = fib_levels['65%']
+    golden_zone_high = fib_levels['61.8%']
+    
+    # Get recent price action
+    recent_close = data['close'].iloc[-1]
+    prev_close = data['close'].iloc[-2]
+    
+    # Check if price is in the golden pocket zone (61.8% - 65%)
+    in_golden_zone = golden_zone_low <= recent_close <= golden_zone_high
+    
+    if not in_golden_zone:
+        return "Neutral"
+    
+    # Check for bullish reversal (price coming from below)
+    if recent_close > prev_close and prev_close < golden_zone_low:
+        # Additional confirmation - price closed above previous candle's high
+        if recent_close > data['high'].iloc[-2]:
+            return "Bullish"
+    
+    # Check for bearish reversal (price coming from above)
+    elif recent_close < prev_close and prev_close > golden_zone_high:
+        # Additional confirmation - price closed below previous candle's low
+        if recent_close < data['low'].iloc[-2]:
+            return "Bearish"
+    
+    return "Neutral" 
+    
+# 4. Fibonacci Confluence Strategy
+
+def fibonacci_confluence_signal(data, fib_level=0.618, lookback_days=5, ema_period=9, tolerance=0.005):
+   
+    # Calculate EMA9
+    data['EMA9'] = talib.EMA(data['close'], timeperiod=ema_period)
+
+    # Get recent data for swing high/low
+    recent = data.iloc[-lookback_days:]
+    swing_high = recent['high'].max()
+    swing_low = recent['low'].min()
+
+    # Calculate Fibonacci level
+    fib_price = swing_high - (swing_high - swing_low) * fib_level
+
+    # Get latest candle data
+    current_close = data.iloc[-1]['close']
+    current_ema = data.iloc[-1]['EMA9']
+
+    # Check if price is within tolerance of Fibonacci level
+    if abs(current_close - fib_price) / fib_price <= tolerance:
+        if current_close > current_ema:
+            return 'Bullish'
+        elif current_close < current_ema:
+            return 'Bearish'
+    
+    return 'Neutral'
+
+
+
+
+
+
+# ======================
+# Main Fibonacci Strategy Aggregator
+# ======================
+
+def fibonacci_strategies(data):
+   
+    signals = {
+        "Fibonacci Retracement Bounce": fibonacci_retracement_bounce(data),
+        "Fibonacci Breakout": fibonacci_breakout(data),
+        "Golden Pocket Reversal": golden_pocket_reversal_strategy(data),
+        "Fibonacci Confluence": fibonacci_confluence_signal(data)
+    }
+
+    weights = {
+        "Fibonacci Retracement Bounce": 30,
+        "Fibonacci Breakout": 25,
+        "Golden Pocket Reversal": 30,
+        "Fibonacci Confluence": 15
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal
+
+
+
+# ======================
+# API-style Function
+# ======================
+
+def get_fibonacci_trade_signal(data):
+    fib_signals, overallscore, final_signal = fibonacci_strategies(data)
+    return {
+        "fib_signals": fib_signals,
+        "fib_score": overallscore,
+        "fib_final_signal": final_signal
+    }

fundamental.py

@@ -0,0 +1,292 @@
+from flask import Flask, jsonify
+import pandas as pd
+import yfinance as yf
+import numpy as np
+
+def get_fundamental_details(ticker):
+    # Fetch the stock data using yfinance
+    stock = yf.Ticker(ticker)
+
+    # Fetch fundamental data and financial statements
+    fundamental_data = stock.info   
+    income_statement = stock.financials
+    balance_sheet = stock.balance_sheet
+    cash_flow_statement = stock.cashflow
+
+   
+    current_net_income = income_statement.loc['Net Income'].iloc[0]  
+    previous_net_income = income_statement.loc['Net Income'].iloc[1] 
+
+    earnings_growth_yoy = 'N/A'
+    # Calculate Earnings Growth (YoY)
+    if current_net_income is not None and previous_net_income is not None:
+        earnings_growth_yoy = ((current_net_income - previous_net_income) / previous_net_income) * 100       
+     
+    current_assets = balance_sheet.loc['Current Assets'].iloc[0] if 'Current Assets' in balance_sheet.index else None
+    current_liabilities = balance_sheet.loc['Current Liabilities'].iloc[0] if 'Current Liabilities' in balance_sheet.index else None
+
+    current_ratio = 'N/A'
+    # Calculate Earnings Growth (YoY)
+    if current_assets is not None and current_liabilities is not None:
+       current_ratio =  current_assets/current_liabilities   
+
+    # Ensure data is transposed for proper indexing
+    balance_sheet = balance_sheet.T
+
+    # Get the latest non-null Debt-to-Equity Ratio
+    debt_to_equity = "N/A"
+    total_liabilities_series = total_equity_series = None
+
+    if "Total Liabilities Net Minority Interest" in balance_sheet.columns and "Ordinary Shares Number" in balance_sheet.columns:
+        total_liabilities_series = balance_sheet["Total Liabilities Net Minority Interest"].dropna()
+        total_equity_series = balance_sheet["Ordinary Shares Number"].dropna()
+
+        if not total_liabilities_series.empty and not total_equity_series.empty:
+            total_liabilities = total_liabilities_series.iloc[0]  # Get the latest non-null value
+            total_equity = total_equity_series.iloc[0]  # Get the latest non-null value
+
+            if total_liabilities is not None and total_equity is not None and total_equity != 0:
+                debt_to_equity = total_liabilities / total_equity
+
+
+
+
+    fundamental_metrics = {
+    'EPS': fundamental_data.get('epsTrailingTwelveMonths', None),
+    'P/E Ratio': fundamental_data.get('trailingPE', None),
+    'Revenue Growth': fundamental_data.get('revenueGrowth', None),
+    'Debt-to-Equity Ratio': debt_to_equity,  
+    'Earnings Growth(YoY)': earnings_growth_yoy             
+   
+}
+    
+    eps = fundamental_metrics['EPS']
+    pe_ratio = fundamental_metrics['P/E Ratio']
+    revenue_growth = fundamental_metrics['Revenue Growth']
+    debt_to_equity = fundamental_metrics['Debt-to-Equity Ratio']
+    earnings_growth_yoy = fundamental_metrics['Earnings Growth(YoY)']
+  
+      
+    
+    # Initialize status variables
+    earnings_growth_status = "none"
+    debt_to_equity_status = "none"
+    pe_ratio_status = "none"
+    revenue_growth_status = "none"   
+    eps_status = "none"
+
+      # Updated Thresholds
+    earnings_growth_threshold = 0.12      # Earnings Growth > 12% (good)
+    debt_to_equity_threshold = 1.5        # D/E < 1.5 (good)
+    pe_ratio_threshold = 25               # P/E < 25 (good)
+    revenue_growth_threshold = 0.12       # Revenue Growth > 12% (good)
+    eps_threshold = 0                     # EPS > 0 (good)
+
+    # Updated Weightages
+    earnings_growth_weight = 2       # 3.5% weight for earnings growth
+    debt_to_equity_weight = 1.5          # 2.75% weight for debt-to-equity ratio
+    pe_ratio_weight = 1.5                 # 2.5% weight for P/E ratio
+    revenue_growth_weight = 2         # 3.5% weight for revenue growth
+    eps_weight = 3                   # 3.75% weight for EPS
+
+    # Check and assign status for EPS, if available
+    if eps is not None:
+        if eps > eps_threshold:
+            eps_status = "good"
+        else:
+            eps_status = "bad"
+
+    # Check and assign status for earnings growth, if available
+    if earnings_growth_yoy is not None:
+        if earnings_growth_yoy >= earnings_growth_threshold:
+            earnings_growth_status = "good"
+        else:
+            earnings_growth_status = "bad"
+
+    # Check and assign status for debt-to-equity, if available
+    if debt_to_equity is not None:
+        if debt_to_equity <= debt_to_equity_threshold:
+            debt_to_equity_status = "good"
+        else:
+            debt_to_equity_status = "bad"
+
+    # Check and assign status for P/E ratio, if available
+    if pe_ratio is not None:
+        if pe_ratio <= pe_ratio_threshold:
+            pe_ratio_status = "good"
+        else:
+            pe_ratio_status = "bad"
+
+    # Check and assign status for revenue growth, if available
+    if revenue_growth is not None:
+        if revenue_growth >= revenue_growth_threshold:
+            revenue_growth_status = "good"
+        else:
+            revenue_growth_status = "bad"
+
+    
+
+    # Calculate overall score
+    overall_fa_score = 0
+    overall_fa_score += eps_weight if eps_status == "good" else 0
+    overall_fa_score += earnings_growth_weight if earnings_growth_status == "good" else 0
+    overall_fa_score += debt_to_equity_weight if debt_to_equity_status == "good" else 0
+    overall_fa_score += pe_ratio_weight if pe_ratio_status == "good" else 0
+    overall_fa_score += revenue_growth_weight if revenue_growth_status == "good" else 0
+  
+
+    earnings_growth = stock.info.get('earningsGrowth', None)
+
+    peg_ratio = None
+    if pe_ratio is not None and earnings_growth is not None and earnings_growth != 0:
+        peg_ratio = pe_ratio / earnings_growth
+
+
+    # Financial Metrics (Valuation, Profitability, etc.)
+    financialMetrics = {
+        'Market Cap': fundamental_data.get('marketCap', None),       
+        'Price-to-Book (P/B) Ratio': fundamental_data.get('priceToBook', None),
+        'Price-to-Sales (P/S) Ratio': fundamental_data.get('priceToSalesTrailing12Months', None),
+        'PEG Ratio': peg_ratio,
+        'EV/EBITDA': fundamental_data.get('enterpriseToEbitda', None)                  
+    }
+
+    # Balance Sheet Data
+    balanceSheetInformation = {
+        'Total Assets': balance_sheet.loc['Total Assets'].iloc[0] if 'Total Assets' in balance_sheet.index else None,
+        'Total Liabilities': balance_sheet.loc['Total Liabilities Net Minority Interest'].iloc[0] if 'Total Liabilities Net Minority Interest' in balance_sheet.index else None,
+        'Total Stockholder Equity': (balance_sheet.loc['Total Assets'].iloc[0] - balance_sheet.loc['Total Liabilities Net Minority Interest'].iloc[0]) 
+        if 'Total Assets' in balance_sheet.index and 'Total Liabilities Net Minority Interest' in balance_sheet.index else None,
+        'Long Term Debt': balance_sheet.loc['Long Term Debt'].iloc[0] if 'Long Term Debt' in balance_sheet.index else None,
+        'Current Assets': balance_sheet.loc['Current Assets'].iloc[0] if 'Current Assets' in balance_sheet.index else None,
+        'Current Liabilities': balance_sheet.loc['Current Liabilities'].iloc[0] if 'Current Liabilities' in balance_sheet.index else None,
+        'Inventory': balance_sheet.loc['Inventory'].iloc[0] if 'Inventory' in balance_sheet.index else None       
+    }
+
+
+    # Income Statement Data
+    incomeStatement = {
+        'Total Revenue': income_statement.loc['Total Revenue'].iloc[0] if 'Total Revenue' in income_statement.index else None,
+        'Operating Income': income_statement.loc['Operating Income'].iloc[0] if 'Operating Income' in income_statement.index else None,
+        'Net Income': income_statement.loc['Net Income'].iloc[0] if 'Net Income' in income_statement.index else None,
+        'Gross Profit': income_statement.loc['Gross Profit'].iloc[0] if 'Gross Profit' in income_statement.index else None             
+    }
+
+    # Growth Indicators
+    growthIndicators = {
+         'Revenue Growth (YoY)': income_statement.loc['Revenue Growth'].iloc[0] if 'Revenue Growth' in income_statement.index else None,        
+        'Profit Margins': (incomeStatement['Net Income'] / incomeStatement['Total Revenue']) * 100 if incomeStatement['Total Revenue'] else None,
+        'ROE (Return on Equity)': balanceSheetInformation.get('Return on Equity (ROE)', None),
+        'ROA (Return on Assets)': balanceSheetInformation.get('Return on Assets (ROA)', None)
+    }
+
+    # Assuming your original cashFlowStatement dict is defined here
+    cashFlowStatement = {
+        'Operating Cash Flow': cash_flow_statement.loc['Operating Cash Flow'].iloc[0] if 'Operating Cash Flow' in cash_flow_statement.index else None,
+        'Investing Cash Flow': cash_flow_statement.loc['Investing Cash Flow'].iloc[0] if 'Investing Cash Flow' in cash_flow_statement.index else None,
+        'Financing Cash Flow': cash_flow_statement.loc['Financing Cash Flow'].iloc[0] if 'Financing Cash Flow' in cash_flow_statement.index else None,
+        'Cash Flow to Debt Ratio': (
+            cash_flow_statement.loc['Operating Cash Flow'].iloc[0] / balance_sheet.loc['Long Term Debt'].iloc[0]
+            if 'Operating Cash Flow' in cash_flow_statement.index and 'Long Term Debt' in balance_sheet.index
+            else None
+        )
+    }
+
+    # Replace NaN or None values with 'N/A'
+    cashFlowStatement = {k: ('N/A' if pd.isna(v) else v) for k, v in cashFlowStatement.items()}
+
+    # Company Overview Data
+    companyOverview = {
+        'Company Name': fundamental_data.get('longName', None),
+        'Sector': fundamental_data.get('sector', None),
+        'Industry': fundamental_data.get('industry', None)
+    }
+
+    # Risk Indicators
+    riskIndicators = {
+        'Debt-to-Equity Ratio(Risk)': balanceSheetInformation.get('Long Term Debt', None) / balanceSheetInformation.get('Total Stockholder Equity', None) 
+        if balanceSheetInformation.get('Long Term Debt') and balanceSheetInformation.get('Total Stockholder Equity') else None,
+        'Interest Coverage Ratio': income_statement.loc['Interest Coverage'].iloc[0] if 'Interest Coverage' in income_statement.index else None,
+        'Beta (Stock Volatility)': fundamental_data.get('beta', None),       
+        'Quick Ratio': (balanceSheetInformation.get('Current Assets', None) - balanceSheetInformation.get('Inventory', None)) / balanceSheetInformation.get('Current Liabilities', None)
+        if balanceSheetInformation.get('Current Assets') and balanceSheetInformation.get('Inventory') and balanceSheetInformation.get('Current Liabilities') else None
+    }
+
+    # Dividends
+    dividends = {
+        'Payout Ratio': fundamental_data.get('payoutRatio', None),
+        'Dividend Growth Rate': fundamental_data.get('dividendGrowthRate', None)
+    }
+
+     # Profitability Indicators
+    profitabilityIndicators = {
+        'Gross Margin': (income_statement.loc['Gross Profit'].iloc[0] / income_statement.loc['Total Revenue'].iloc[0]) * 100 
+                         if 'Gross Profit' in income_statement.index and 'Total Revenue' in income_statement.index else None,
+        'Operating Margin': (income_statement.loc['Operating Income'].iloc[0] / income_statement.loc['Total Revenue'].iloc[0]) * 100 
+                            if 'Operating Income' in income_statement.index and 'Total Revenue' in income_statement.index else None,
+        'Net Margin': (income_statement.loc['Net Income'].iloc[0] / income_statement.loc['Total Revenue'].iloc[0]) * 100 
+                      if 'Net Income' in income_statement.index and 'Total Revenue' in income_statement.index else None
+    }
+
+    # Liquidity Indicators
+    liquidityIndicators = {
+        'Cash Ratio': balance_sheet.loc['Cash And Cash Equivalents'].iloc[0] / balance_sheet.loc['Current Liabilities'].iloc[0] 
+                      if 'Cash And Cash Equivalents' in balance_sheet.index and 'Current Liabilities' in balance_sheet.index else None,
+        'Working Capital': balance_sheet.loc['Current Assets'].iloc[0] - balance_sheet.loc['Current Liabilities'].iloc[0] 
+                           if 'Current Assets' in balance_sheet.index and 'Current Liabilities' in balance_sheet.index else None
+    }
+
+    investorInsightMetrics = {                
+     'EPS': eps,
+     'P/E Ratio': pe_ratio,
+     'Revenue Growth': revenue_growth,
+     'Debt-to-Equity Ratio': debt_to_equity,  
+     'Earnings Growth(YoY)': earnings_growth_yoy            
+           }
+
+    result = {   
+
+     'EPS': eps_status,
+     'P/E Ratio': pe_ratio_status,
+     'Revenue Growth': revenue_growth_status,
+     'Debt-to-Equity Ratio': debt_to_equity_status,  
+     'Earnings Growth(YoY)': earnings_growth_status 
+    }
+
+    def replace_nan_with_na(data):
+        if isinstance(data, dict):
+            return {k: replace_nan_with_na(v) for k, v in data.items()}
+        elif isinstance(data, list):
+            return [replace_nan_with_na(v) for v in data]
+        elif pd.isna(data):
+            return 'N/A'
+        else:
+            return data
+
+
+
+
+    return replace_nan_with_na({
+    "fa_strategy": result,
+    "overall_fa_score": round(overall_fa_score, 2),
+    "Investor Insight Metrics": investorInsightMetrics,
+    "Company Overview": companyOverview,
+    "Growth Indicators": growthIndicators,
+    "Risk Indicators": riskIndicators,
+    "Dividends": dividends,
+    "Cash Flow Statement": cashFlowStatement,
+    "Financial Metrics": financialMetrics,
+    "Income Statement": incomeStatement,
+    "BalanceSheet Information": balanceSheetInformation,
+    "Profitability Indicators": profitabilityIndicators,
+    "Liquidity Indicators": liquidityIndicators,
+    })
+
+
+
+    
+
+
+
+
+

list.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+"""
+Minimal API for PY-Trade filters & companies
+- /getfilters                      -> countries -> exchanges -> indices
+- /getcompanies?code=NIFTY50       -> { code, asOf, count, constituents[] }
+"""
+
+from __future__ import annotations
+import csv, io, json, time
+from typing import Dict, List, Any
+from pathlib import Path
+
+import requests
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+# ---------- configuration ----------
+UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127 Safari/537.36"
+REFERER = "https://www.niftyindices.com/indices/equity/broad-based-indices"
+TTL_SECONDS = 60 * 60 * 12  # 12h cache
+CACHE_DIR = Path(__file__).with_name("cache")
+CACHE_DIR.mkdir(exist_ok=True)
+
+# Official CSV endpoints for NSE indices
+NIFTY_URLS: Dict[str, str] = {
+    "NIFTY50":      "https://www.niftyindices.com/IndexConstituent/ind_nifty50list.csv",
+    "NIFTY100":     "https://www.niftyindices.com/IndexConstituent/ind_nifty100list.csv",
+    "NIFTY200":     "https://www.niftyindices.com/IndexConstituent/ind_nifty200list.csv",
+    "NIFTYMID100":  "https://www.niftyindices.com/IndexConstituent/ind_niftymidcap100list.csv",
+    "NIFTY500":     "https://www.niftyindices.com/IndexConstituent/ind_nifty500list.csv",
+}
+
+# Filters payload for the UI (add more countries/exchanges here later)
+MARKETS: Dict[str, Dict[str, List[Dict[str, str]]]] = {
+    "India": {
+        "NSE (National Stock Exchange)": [
+            {"code": "NIFTY50",     "name": "NIFTY 50"},
+            {"code": "NIFTY100",    "name": "NIFTY 100"},
+            {"code": "NIFTY200",    "name": "NIFTY 200"},
+            {"code": "NIFTYMID100", "name": "NIFTY Midcap 100"},
+            {"code": "NIFTY500",    "name": "NIFTY 500"},
+        ]
+    }
+}
+
+# ---------- utilities ----------
+def http_get_text(url: str) -> str:
+    sess = requests.Session()
+    sess.headers.update({"User-Agent": UA, "Referer": REFERER, "Accept": "text/csv,*/*"})
+    r = sess.get(url, timeout=25)
+    r.raise_for_status()
+    r.encoding = r.encoding or "utf-8"
+    return r.text
+
+def parse_nifty_csv(text: str) -> List[Dict[str, str]]:
+    # Columns: Company Name, Industry, Symbol, Series, ISIN Code
+    out: List[Dict[str, str]] = []
+    rdr = csv.DictReader(io.StringIO(text))
+    for row in rdr:
+        sym = (row.get("Symbol") or "").strip()
+        name = (row.get("Company Name") or "").strip()
+        if sym and name:
+            out.append({"symbol": f"{sym}.NS", "company": name})
+    return out
+
+def cache_path(code: str) -> Path:
+    return CACHE_DIR / f"{code.lower()}.json"
+
+def load_cache(code: str) -> Any | None:
+    fp = cache_path(code)
+    if not fp.exists():
+        return None
+    age = time.time() - fp.stat().st_mtime
+    if age > TTL_SECONDS:
+        return None
+    with fp.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+def save_cache(code: str, payload: Any) -> None:
+    fp = cache_path(code)
+    with fp.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+
+def build_companies_payload(code: str) -> Dict[str, Any]:
+    code = code.upper()
+    # 1) try cache
+    cached = load_cache(code)
+    if cached:
+        return cached
+
+    # 2) fetch official CSV
+    url = NIFTY_URLS.get(code)
+    if not url:
+        raise ValueError(f"Unknown index code: {code}")
+    text = http_get_text(url)
+    rows = parse_nifty_csv(text)
+
+    payload = {
+        "code": code,
+        "exchange": "NSE",
+        "country": "IN",
+        "currency": "INR",
+        "asOf": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "count": len(rows),
+        "constituents": rows,
+        "source": url,
+    }
+    save_cache(code, payload)
+    return payload
+

macdstrategies.py

@@ -0,0 +1,239 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+from collections import OrderedDict
+import datetime
+
+    
+# Calculate MACD, Signal and Histogram
+def calculate_macdvalue(data, fast=12, slow=26, signal=9):
+    
+    close_prices = data['close']
+
+    # Calculate MACD
+    macd_line, signal_line, histogram = talib.MACD(
+        close_prices,
+        fastperiod=fast,
+        slowperiod=slow,
+        signalperiod=signal
+    )
+
+    return macd_line, signal_line, histogram
+
+# MACD Line Crossover - completed
+def get_macd_line_crossover_signal(macd, signal):    
+    
+    for i in range(len(macd) - 1):
+        older_macd = macd[i]
+        newer_macd = macd[i + 1]
+        older_signal = signal[i]
+        newer_signal = signal[i + 1]
+        
+        # Bullish crossover (MACD crosses above Signal)
+        if older_macd <= older_signal and newer_macd > newer_signal:
+            return "Bullish"
+        # Bearish crossover (MACD crosses below Signal)
+        elif older_macd >= older_signal and newer_macd < newer_signal:
+            return "Bearish"
+    
+    return "Neutral"
+
+# Zero Line Crossover - completed
+def get_macd_zero_line_crossover_signal(macd):   
+    
+    for i in range(len(macd) - 1):
+        older = macd[i]
+        newer = macd[i + 1]
+        
+        if older <= 0 and newer > 0:
+            return "Bullish"
+        elif older >= 0 and newer < 0:
+            return "Bearish"
+    
+    return "Neutral"
+
+# MACD Momentum Signal - completed
+def get_macd_momentum_signal(macd, signal, hist):
+
+    for i in range(len(macd) - 1):
+        older_macd = macd[i]
+        newer_macd = macd[i + 1]
+        older_signal = signal[i]
+        newer_signal = signal[i + 1]
+        current_hist = hist[i + 1]  # Use the histogram of the newer point
+
+        # Bullish crossover (MACD crosses above Signal) with positive histogram
+        if older_macd <= older_signal and newer_macd > newer_signal and current_hist > 0:
+            return "Bullish"
+
+        # Bearish crossover (MACD crosses below Signal) with negative histogram
+        elif older_macd >= older_signal and newer_macd < newer_signal and current_hist < 0:
+            return "Bearish"
+
+    return "Neutral"
+
+# MACD Volume Signal - completed
+def get_macd_volume_signal(data, macd, signal):
+   
+    avg_volume = data['volume'].rolling(window=10).mean()
+    recent_volume = data['volume'].values[-1:]
+    recent_avg_volume = avg_volume.values[-1:]
+    volume_confirm = recent_volume > recent_avg_volume
+   
+   
+    for i in range(len(macd) - 1):
+        older_macd = macd[i]
+        newer_macd = macd[i + 1]
+        older_signal = signal[i]
+        newer_signal = signal[i + 1]
+        
+        if (older_macd <= older_signal and 
+            newer_macd > newer_signal and 
+            volume_confirm):
+            return "Bullish"
+        elif (older_macd >= older_signal and 
+              newer_macd < newer_signal and 
+              volume_confirm):
+            return "Bearish"
+    
+    return "Neutral"
+
+# MACD Multi-Timeframe - completed
+def get_macd_multi_timeframe_confirmation(macd, signal,macd_hr, signal_hr):
+    for i in range(len(macd) - 1):
+        older_macd = macd[i]
+        newer_macd = macd[i + 1]
+        older_signal = signal[i]
+        newer_signal = signal[i + 1]
+        older_macd_hr = macd_hr[i]
+        newer_macd_hr = macd_hr[i + 1]
+        older_signal_hr = signal_hr[i]
+        newer_signal_hr = signal_hr[i + 1]
+        
+        # Bullish crossover (MACD crosses above Signal)
+        if older_macd <= older_signal and newer_macd > newer_signal and older_macd_hr <= older_signal_hr and newer_macd_hr > newer_signal_hr:
+            return "Bullish"
+        # Bearish crossover (MACD crosses below Signal)
+        elif older_macd >= older_signal and newer_macd < newer_signal and older_macd_hr >= older_signal_hr and newer_macd_hr < newer_signal_hr:
+            return "Bearish"
+    
+    return "Neutral"
+
+# Price and MACD Divergence - completed
+def get_macd_divergence_signal(macd, price):    
+    
+    # Bullish Divergence: Price makes lower lows, but MACD makes higher lows
+    bullish_divergence = None
+    for i in range(10, len(price)):  # Look at the last 5 candles
+        if price[i] < price[i-1] and macd[i] > macd[i-1]:
+            bullish_divergence = "Bullish"
+            break
+
+    # Bearish Divergence: Price makes higher highs, but MACD makes lower highs
+    bearish_divergence = None
+    for i in range(10, len(price)):  # Look at the last 5 candles
+        if price[i] > price[i-1] and macd[i] < macd[i-1]:
+            bearish_divergence = "Bearish"
+            break
+    
+    if bullish_divergence:
+        return bullish_divergence
+    elif bearish_divergence:
+        return bearish_divergence
+    else:
+        return "Neutral"
+
+# MACD Hidden Divergence - completed
+def get_macd_hidden_divergence_signal(macd, price):    
+    
+    # Bullish Hidden Divergence: Price makes a higher low, but MACD makes a lower low
+    bullish_hidden_divergence = None
+    for i in range(10, len(price)):  # Look at the last 5 candles
+        if price[i] > price[i-10] and macd[i] < macd[i-10]:
+            bullish_hidden_divergence = "Bullish"
+            break
+
+    # Bearish Hidden Divergence: Price makes a lower high, but MACD makes a higher high
+    bearish_hidden_divergence = None
+    for i in range(10, len(price)):  # Look at the last 5 candles
+        if price[i] < price[i-10] and macd[i] > macd[i-10]:
+            bearish_hidden_divergence = "Bearish"
+            break
+    
+    if bullish_hidden_divergence:
+        return bullish_hidden_divergence
+    elif bearish_hidden_divergence:
+        return bearish_hidden_divergence
+    else:
+        return "Neutral"
+
+
+# macd_strategies and get_macd_trade_signal functions
+def macd_strategies(data):     
+
+    macd, signal, hist = calculate_macdvalue(data)    
+    
+    latest_macd = macd[-1]   
+    signals = { 
+        "MACD": round(latest_macd,2),
+        "MACD Line Crossover": get_macd_line_crossover_signal(macd[-5:],signal[-5:]),
+        "MACD Zero-Line Crossover": get_macd_zero_line_crossover_signal(macd[-5:]),
+        "MACD Divergence": get_macd_divergence_signal(macd[-10:], data['close'][-10:]),
+        "Hidden Divergence": get_macd_hidden_divergence_signal(macd[-10:], data['close'][-10:]),
+        "MACD Volume": get_macd_volume_signal(data, macd[-5:],signal[-5:]),
+        "MACD Momentum": get_macd_momentum_signal(macd[-5:],signal[-5:],hist[-5:]),
+        
+    }
+
+    macd_signal_weights = {
+        "MACD Line Crossover": 25,
+        "MACD Zero-Line Crossover": 15, 
+        "MACD Divergence": 20,
+        "Hidden Divergence": 10,
+        "MACD Volume": 15,
+        "MACD Momentum": 15,
+        
+    }
+    
+    total_score = 0
+    for strategy, weight in macd_signal_weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(macd_signal_weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+    
+    return signals, overall_percentage, final_signal
+
+
+def get_macd_trade_signal(data):    
+    macd_signals, overallscore, final_signal = macd_strategies(data)
+    macd_line, signal_line, hist = calculate_macdvalue(data)
+    # Format and convert MACD and Signal Line for last 100 days
+    macd_series = pd.Series(macd_line, index=data.index).dropna().tail(100)
+    signal_series = pd.Series(signal_line, index=data.index).dropna().tail(100)
+
+    macd_series.index = macd_series.index.strftime('%Y-%m-%d')
+    signal_series.index = signal_series.index.strftime('%Y-%m-%d')
+    hist_series = pd.Series(hist, index=data.index).dropna().tail(100)
+    hist_series.index = hist_series.index.strftime('%Y-%m-%d')
+
+    return {
+        "macd_signals": macd_signals,
+        "macd_score": overallscore,
+        "macd_final_signal": final_signal,
+        "macd_line": macd_series.round(2).to_dict(),
+        "macd_signal_line": signal_series.round(2).to_dict(),
+        "macd_histogram": hist_series.round(2).to_dict()
+    }

news.py

@@ -0,0 +1,107 @@
+# news_sentiment.py
+# pip install gnews nltk rapidfuzz
+
+from __future__ import annotations
+from datetime import datetime, timezone
+import time
+from typing import List, Dict, Any
+
+from gnews import GNews
+from rapidfuzz import fuzz
+from nltk.sentiment import SentimentIntensityAnalyzer
+import nltk
+
+# Ensure VADER is available (safe to call multiple times)
+try:
+    nltk.data.find("sentiment/vader_lexicon.zip")
+except LookupError:
+    nltk.download("vader_lexicon")
+
+# Keep one analyzer instance
+_SIA = SentimentIntensityAnalyzer()
+
+
+def _sentiment_label(compound: float) -> str:
+    if compound > 0.05:
+        return "Positive"
+    elif compound < -0.05:
+        return "Negative"
+    return "Neutral"
+
+
+def _is_similar(title: str, seen_titles: List[str], threshold: int = 60) -> bool:
+    for t in seen_titles:
+        if fuzz.ratio(title, t) > threshold:
+            return True
+    return False
+
+
+def get_latest_news_with_sentiment(
+    query: str,
+    *,
+    period: str = "1d",          
+    max_results: int = 20,
+    language: str = "en",
+    country: str = "US",        
+    retries: int = 3,
+    backoff_seconds: int = 3
+) -> Dict[str, Any]:
+   
+   
+    seen_titles: List[str] = []
+    results = []
+
+    for attempt in range(retries):
+        try:
+            g = GNews(language=language, country=country, period=period, max_results=max_results)
+            results = g.get_news(query) or []
+            if results:
+                break
+        except Exception as e:
+            print(f"[Attempt {attempt+1}] GNews error: {e}")
+        time.sleep(backoff_seconds * (attempt + 1))
+
+    if not results:
+        return {"overall_news_score": 0.0, "count": 0, "items": []}
+
+    items: List[Dict[str, Any]] = []
+    total_compound = 0.0
+
+    for art in results:
+        title = (art.get("title") or "").strip()
+        if not title:
+            continue
+        if _is_similar(title, seen_titles, threshold=60):
+            continue
+        seen_titles.append(title)
+
+        url = (art.get("url")
+               or art.get("link")
+               or art.get("source", {}).get("url")
+               or "")
+
+        published_raw = (art.get("published date")
+                         or art.get("publishedDate")
+                         or art.get("datetime")
+                         or "")
+        if isinstance(published_raw, datetime):
+            if published_raw.tzinfo is None:
+                published_raw = published_raw.replace(tzinfo=timezone.utc)
+            published = published_raw.strftime("%Y-%m-%d %H:%M")
+        else:
+            published = str(published_raw)
+
+        compound = _SIA.polarity_scores(title)["compound"]
+        items.append({
+            "title": title,
+            "url": url,
+            "published": published,
+            "sentiment": _sentiment_label(compound),
+            "compound": round(compound, 3),
+        })
+        total_compound += compound
+
+    n = len(items)
+    overall = round(((total_compound / n) + 1) * 2.5, 2) if n else 0.0
+
+    return {"overall_news_score": overall, "count": n, "items": items}

predictedchart.py

@@ -0,0 +1,126 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+from sklearn.preprocessing import MinMaxScaler
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+
+# Step 1: Download data with TA indicators
+def fetch_stock_data_with_indicators(ticker, start="2020-01-01", end="2025-09-03"):
+    df = yf.download(ticker, start=start, end=end)
+    actualdata = yf.download(ticker, start=start, end="2025-09-04")
+    df = df[["Open", "High", "Low", "Close", "Volume"]]
+    close_prices = df['Close'].to_numpy().flatten()
+    low_prices = df['Low'].to_numpy().flatten()
+    high_prices = df['High'].to_numpy().flatten()
+    # Add indicators
+    #df["RSI"] = talib.RSI(close_prices, timeperiod=14)
+    #df["MACD"], df["MACD_signal"], _ = talib.MACD(close_prices)
+    df["EMA_20"] = talib.EMA(close_prices, timeperiod=20)
+    df["ATR"] = talib.ATR(high_prices, low_prices, close_prices, timeperiod=14)
+
+    df.dropna(inplace=True)
+    return df
+
+def fetch_originaldata(ticker, start="2020-01-01", end="2025-01-03"):    
+    actualdata = yf.download(ticker, start=start, end="2025-01-24")
+    return actualdata
+
+# Step 2: Custom Dataset
+class StockDataset(Dataset):
+    def __init__(self, series, window_size):
+        self.data = []
+        for i in range(len(series) - window_size):
+            self.data.append((series[i:i+window_size], series[i+window_size][3]))
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        x, y = self.data[idx]
+        return torch.tensor(x, dtype=torch.float32), torch.tensor(y, dtype=torch.float32)
+
+# Step 3: Transformer model
+class TransformerPredictor(nn.Module):
+    def __init__(self, input_size, d_model=64, nhead=4, num_layers=2, dropout=0.1):
+        super(TransformerPredictor, self).__init__()
+        self.linear_in = nn.Linear(input_size, d_model)
+        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, dropout=dropout)
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        self.linear_out = nn.Linear(d_model, 1)
+
+    def forward(self, src):
+        x = self.linear_in(src)         # [seq, batch, d_model]
+        x = self.transformer(x)         # [seq, batch, d_model]
+        out = self.linear_out(x[-1])    # [batch, 1]
+        return out.squeeze()
+
+# Step 4: Training function
+def train_model(model, dataloader, epochs, lr=0.001):
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    loss_fn = nn.MSELoss()
+    for epoch in range(epochs):
+        for x, y in dataloader:
+            x = x.permute(1, 0, 2)  # [batch, seq, features] -> [seq, batch, features]
+            pred = model(x)
+            loss = loss_fn(pred, y)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+        print("Epoch {}/{} - Loss: {:.4f}".format(epoch+1, epochs, loss.item()))
+
+# Step 5: Run pipeline
+def run_stock_prediction(ticker):
+    df = fetch_stock_data_with_indicators(ticker)
+    scaler = MinMaxScaler()
+    scaled_data = scaler.fit_transform(df.values)
+
+    window_size = 20
+    dataset = StockDataset(scaled_data, window_size)
+    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
+
+    input_size = scaled_data.shape[1]
+    model = TransformerPredictor(input_size=input_size)
+    train_model(model, dataloader, epochs=2)
+
+       
+    # Predict next 15 days
+    predictions = []
+    input_seq = scaled_data[-window_size:].copy()  # shape: [20, features]
+
+    for i in range(15):
+        seq_tensor = torch.tensor(input_seq, dtype=torch.float32).unsqueeze(1)  # [seq_len, 1, features]
+
+        with torch.no_grad():
+            predicted_scaled = model(seq_tensor).item()
+
+        # Create new row based on last row, replace only Close price (index 3)
+        new_row = input_seq[-1].copy()
+        new_row[3] = predicted_scaled
+
+        # Inverse scale to get actual Close price
+        predicted_row = scaler.inverse_transform([new_row])[0]
+        predicted_close = predicted_row[3]
+        predictions.append(predicted_close)
+
+        # Slide window: remove first row, append new row
+        input_seq = np.vstack([input_seq[1:], [new_row]])
+
+    # Get the last date from the dataset
+    last_date = df.index[-1]
+    predicted_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=15, freq='B')  # Business days
+
+   
+    prediction_results = pd.DataFrame({
+        'Date': predicted_dates,
+        'Predicted Close': predictions,
+       
+       
+    })  
+
+    return prediction_results
+
+
+

prediction.py

@@ -0,0 +1,257 @@
+import os, re, joblib, numpy as np, pandas as pd, sklearn
+from sklearn.ensemble import ExtraTreesRegressor
+
+PRICE_COLS = ["Close Price", "Highest Price", "Lowest Price"]
+
+def _drop_unnamed(df: pd.DataFrame) -> pd.DataFrame:
+    to_drop = [c for c in df.columns if str(c).startswith("Unnamed")]
+    return df.drop(columns=to_drop) if to_drop else df
+
+def _read_excel_loose_header(xlsx_path: str) -> pd.DataFrame:
+   
+    raw = pd.read_excel(xlsx_path, engine='openpyxl', header=None)
+    first_row = [str(x) for x in raw.iloc[0].tolist()]
+    header_row = 0 if any("Close Price" in s for s in first_row) else 1
+    return pd.read_excel(xlsx_path, engine='openpyxl', header=header_row)
+
+def _map_training_indicators(df: pd.DataFrame) -> pd.DataFrame:
+   
+    def map_series(s: pd.Series):
+        if s.dtype == 'O':
+            cleaned = s.astype(str).str.strip()
+            cleaned = cleaned.replace({'nan': np.nan, 'NaN': np.nan, 'None': np.nan, '': np.nan})
+            return cleaned.map({'Red': 0, 'Yellow': 1, 'Green': 2})
+        return s
+    out = df.copy()
+    for col in out.columns:
+        if col not in PRICE_COLS:
+            out[col] = map_series(out[col])
+    return out
+
+def _map_testing_indicators(df: pd.DataFrame) -> pd.DataFrame:
+   
+    def map_series(s: pd.Series):
+        if s.dtype == 'O':
+            cleaned = s.astype(str).str.strip()
+            cleaned = cleaned.replace({'nan': np.nan, 'NaN': np.nan, 'None': np.nan, '': np.nan})
+            return cleaned.map({'Red': 0, 'Yellow': 1, 'Green': 2})
+      
+        return s.replace({10: 2, 5: 1, 0: 0})
+    out = df.copy()
+    for col in out.columns:
+        if col not in PRICE_COLS:
+            out[col] = map_series(out[col])
+    return out
+
+def _find_target_cols(df: pd.DataFrame):
+    if "Highest Price" not in df.columns or "Lowest Price" not in df.columns:
+        raise ValueError("Excel must contain 'Highest Price' and 'Lowest Price' columns.")
+    return "Highest Price", "Lowest Price"
+
+def load_or_train_highlow_model(xlsx_path: str, model_path: str):
+    
+    def _is_cache_fresh():
+        return os.path.exists(model_path) and os.path.getmtime(model_path) >= os.path.getmtime(xlsx_path)
+
+    if os.path.exists(model_path) and _is_cache_fresh():
+        obj = joblib.load(model_path)
+        if isinstance(obj, dict) and {'model','features','medians'} <= set(obj.keys()):
+            return obj 
+
+    if not os.path.exists(xlsx_path):
+        raise FileNotFoundError(f"Training Excel not found at: {xlsx_path}")
+
+    df = _read_excel_loose_header(xlsx_path)
+    df = _drop_unnamed(df)
+
+    y_high, y_low = _find_target_cols(df)
+    df_mapped = _map_training_indicators(df)
+
+    X = df_mapped.drop(columns=[y_high, y_low]).apply(pd.to_numeric, errors='coerce')
+    y = df_mapped[[y_high, y_low]].apply(pd.to_numeric, errors='coerce')
+
+    med = X.median(numeric_only=True)
+    X = X.fillna(med)
+    y = y.fillna(y.median(numeric_only=True))
+
+    model = ExtraTreesRegressor(
+        n_estimators=300,
+        random_state=42,
+        n_jobs=-1,
+        max_depth=None,
+        min_samples_leaf=2,
+    )
+    model.fit(X.values, y.values)
+
+    bundle = {
+        'model': model,
+        'features': X.columns.tolist(),
+        'medians': med.to_dict(),
+        'sklearn_version': sklearn.__version__,
+        'trained_rows': int(X.shape[0]),
+    }
+    os.makedirs(os.path.dirname(model_path), exist_ok=True)
+    joblib.dump(bundle, model_path)
+    return bundle
+
+def _to_num(v):
+    import pandas as pd
+    if isinstance(v, (list, tuple, pd.Series, np.ndarray)):
+        if len(v) == 0:
+            return 0.0
+        return _to_num(v[-1])
+    if isinstance(v, dict):
+        numeric_vals = [vv for vv in v.values() if isinstance(vv, (int, float, np.number))]
+        if numeric_vals:
+            best = max(numeric_vals)
+            return 1.0 if float(best) > 0 else 0.0
+        return 1.0 if any(bool(vv) for vv in v.values()) else 0.0
+    if isinstance(v, (bool, int, float, np.number)):
+        try:
+            return float(v)
+        except Exception:
+            return 0.0
+    if isinstance(v, str):
+        s = v.strip().lower()
+        if s in {"buy", "bullish", "long", "breakout", "yes", "true", "dbuy"}:
+            return 1.0
+        if s in {"sell", "bearish", "short", "no", "false"}:
+            return 0.0
+        try:
+            return float(v)
+        except Exception:
+            return 0.0
+    try:
+        return float(v)
+    except Exception:
+        return 0.0
+
+def build_current_features_row_23k(
+    ticker: str,
+    stock_data: pd.DataFrame,
+    rsi_trade_signal: dict,
+    macd_trade_signal: dict,
+    ema_trade_signal: dict,
+    atr_trade_signal: dict,
+    adx_trade_signal: dict,
+    bb_trade_signal: dict,
+    sr_trade_signal: dict,
+    priceaction_trade_signal: dict,
+    fibo_trade_signal: dict,
+    overall_ta_score: float,
+) -> pd.DataFrame:
+    
+    last_close = _to_num(stock_data['close'].iloc[-1])
+
+    rsi_sig = rsi_trade_signal.get('rsi_signals', {}) or {}
+    macd_sig = macd_trade_signal.get('macd_signals', {}) or {}
+    atr_sig = atr_trade_signal.get('atr_signals', {}) or {}
+    ema_sig = ema_trade_signal.get('ema_signals', {}) or {}
+    adx_sig = adx_trade_signal.get('adx_signals', {}) or {}
+    bb_sig  = bb_trade_signal.get('bollinger_signals', {}) or {}
+    sr_sig  = sr_trade_signal.get('support_resistance_signals', {}) or {}
+    pa_sig  = priceaction_trade_signal.get('priceaction_signals', {}) or {}
+    fib_sig = priceaction_trade_signal.get('fib_signals') or fibo_trade_signal.get('fib_signals', {})
+
+    def sig_num(d, key): return _to_num(d.get(key, 0))
+
+    row = {
+        "TA Score": _to_num(overall_ta_score),
+        "Close Price": last_close,
+
+        # RSI
+        "RSI": _to_num(rsi_trade_signal.get('rsi_score', 0)),
+        "Overbought/Oversold": sig_num(rsi_sig, "Overbought/Oversold"),
+        "RSI Swing Rejection": sig_num(rsi_sig, "RSI Swing Rejection"),
+        "RSI Divergence": sig_num(rsi_sig, "RSI Divergence"),
+        "RSI_Bollinger Band": sig_num(rsi_sig, "RSI_Bollinger Band"),
+        "RSI 5/14 Crossover": sig_num(rsi_sig, "RSI 5/14 Crossover"),
+        "RSI Trend 50 Confirmation": sig_num(rsi_sig, "RSI Trend 50 Confirmation"),
+        "RSI_MA": _to_num(rsi_sig.get("RSI_MA", rsi_trade_signal.get("ma", 0))),
+        "Mean Reversion": sig_num(rsi_sig, "Mean Reversion"),
+
+        # MACD
+        "MACD": _to_num(macd_trade_signal.get('macd_score', 0)),
+        "MACD Line Crossover": sig_num(macd_sig, "MACD Line Crossover"),
+        "MACD Zero-Line Crossover": sig_num(macd_sig, "MACD Zero-Line Crossover"),
+        "MACD Divergence": sig_num(macd_sig, "MACD Divergence"),
+        "Hidden Divergence": sig_num(macd_sig, "Hidden Divergence"),
+        "MACD Volume": sig_num(macd_sig, "MACD Volume"),
+        "MACD Momentum": sig_num(macd_sig, "MACD Momentum"),
+
+        # ATR
+        "ATR": _to_num(atr_trade_signal.get('atr_score', 0)),
+        "ATR Breakout": sig_num(atr_sig, "ATR Breakout"),
+        "ATR Expansion": sig_num(atr_sig, "ATR Expansion"),
+        "ATR Squeeze": sig_num(atr_sig, "ATR Squeeze"),
+        "ATR Trend Reversal": sig_num(atr_sig, "ATR Trend Reversal"),
+
+        # EMA
+        "EMA": _to_num(ema_trade_signal.get('ema_score', 0)),
+        "EMA Crossover": sig_num(ema_sig, "EMA Crossover"),
+        "EMA Price Crossover": sig_num(ema_sig, "EMA Price Crossover"),
+        "EMA Slope": sig_num(ema_sig, "EMA Slope"),
+        "Triple EMA": sig_num(ema_sig, "Triple EMA"),
+
+        # ADX
+        "ADX": _to_num(adx_trade_signal.get('adx_score', 0)),
+        "ADX + DI Crossover": sig_num(adx_sig, "ADX + DI Crossover"),
+        "ADX Breakout": sig_num(adx_sig, "ADX Breakout"),
+        "ADX Slope": sig_num(adx_sig, "ADX Slope"),
+        "ADX Divergence": sig_num(adx_sig, "ADX Divergence"),
+
+        # Fibonacci
+        "Fibo": _to_num(fibo_trade_signal.get('fib_score', 0)),
+        "Fibonacci Retracement Bounce": sig_num(fib_sig, "Fibonacci Retracement Bounce"),
+        "Fibonacci Breakout": sig_num(fib_sig, "Fibonacci Breakout"),
+        "Golden Pocket Reversal": sig_num(fib_sig, "Golden Pocket Reversal"),
+        "Fibonacci Confluence": sig_num(fib_sig, "Fibonacci Confluence"),
+
+        # Bollinger
+        "BB": _to_num(bb_trade_signal.get('bollinger_score', 0)),
+        "BB Squeeze": sig_num(bb_sig, "BB Squeeze"),
+        "BB Breakout": sig_num(bb_sig, "BB Breakout"),
+        "BB Breakout Reversal": sig_num(bb_sig, "BB Breakout Reversal"),
+        "Middle Band Pullback": sig_num(bb_sig, "Middle Band Pullback"),
+
+       
+        "SR": _to_num(sr_trade_signal.get('sr_score', 0)),
+        "Breakout": sig_num(sr_sig, "Breakout"),
+        "Reversal": sig_num(sr_sig, "Reversal"),
+        "Flip": sig_num(sr_sig, "Flip"),
+        "SR_Retest": sig_num(sr_sig, "SR_Retest"),
+
+       
+        "PA_MS": _to_num(priceaction_trade_signal.get('priceaction_score', 0)),
+        "Candlestick Pattern": sig_num(pa_sig, "Candlestick Pattern"),
+        "HH_HL_LL_LH": sig_num(pa_sig, "HH_HL_LL_LH"),
+        "Triangle Breakout": sig_num(pa_sig, "Triangle Breakout"),
+        "Fair Value Gap": sig_num(pa_sig, "Fair Value Gap"),
+        "BOS": sig_num(pa_sig, "BOS"),
+        "CHoCH": sig_num(pa_sig, "CHoCH"),
+        "Order_Block": sig_num(pa_sig, "Order_Block"),
+    }
+
+    return pd.DataFrame([row]).replace([np.inf, -np.inf], np.nan)
+
+def _prepare_test_currentrow(current_row_df: pd.DataFrame, feature_cols, train_medians: dict):
+    df = _map_testing_indicators(current_row_df.copy())
+    X = df.reindex(columns=feature_cols).apply(pd.to_numeric, errors='coerce')
+    X = X.fillna(pd.Series(train_medians))
+    return X
+
+def predict_high_low_for_current_row(bundle: dict, current_row_df: pd.DataFrame, live_close: float):
+   
+    feature_cols = bundle['features']
+    medians = bundle['medians']
+    model: ExtraTreesRegressor = bundle['model']
+
+    X = _prepare_test_currentrow(current_row_df, feature_cols, medians)
+    preds = model.predict(X.values)
+    high_pred, low_pred = float(preds[0, 0]), float(preds[0, 1])
+
+    if not np.isnan(live_close):
+        high_pred = max(high_pred, float(live_close))
+        low_pred  = min(low_pred,  float(live_close))
+
+    return round(high_pred, 2), round(low_pred, 2)

priceactionstrategies.py

@@ -0,0 +1,271 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import datetime
+import talib
+
+
+# Candlestick Pattern Detection Strategy
+def candlestick_pattern_strategy(data):
+    open_ = data['open']
+    high = data['high']
+    low = data['low']
+    close = data['close']
+
+    # Bullish Patterns
+    bullish_patterns = [
+        talib.CDLENGULFING(open_, high, low, close),
+        talib.CDLHAMMER(open_, high, low, close),
+        talib.CDLMORNINGSTAR(open_, high, low, close),
+        talib.CDLPIERCING(open_, high, low, close),
+        talib.CDLINVERTEDHAMMER(open_, high, low, close),
+        talib.CDL3WHITESOLDIERS(open_, high, low, close)
+    ]
+
+    # Bearish Patterns
+    bearish_patterns = [
+        talib.CDLENGULFING(open_, high, low, close),
+        talib.CDLSHOOTINGSTAR(open_, high, low, close),
+        talib.CDLEVENINGSTAR(open_, high, low, close),
+        talib.CDLDARKCLOUDCOVER(open_, high, low, close),
+        talib.CDLHANGINGMAN(open_, high, low, close),
+        talib.CDL3BLACKCROWS(open_, high, low, close)
+    ]
+
+    # Neutral Patterns
+    neutral_patterns = [
+    talib.CDLDOJI(open_, high, low, close),
+    talib.CDLSPINNINGTOP(open_, high, low, close),
+    talib.CDLLONGLEGGEDDOJI(open_, high, low, close),
+    talib.CDLHIGHWAVE(open_, high, low, close)
+    ]
+
+
+    # Check Bullish
+    for pattern in bullish_patterns:
+        if pattern.iloc[-1] > 0:
+            return "Bullish"
+
+    # Check Bearish
+    for pattern in bearish_patterns:
+        if pattern.iloc[-1] < 0:
+            return "Bearish"
+
+    # Check Neutral
+    for pattern in neutral_patterns:
+        if pattern.iloc[-1] != 0:
+            return "Neutral"
+
+    return "Neutral"
+
+#first day high value is higher than the second day and third day should be higher than second day
+def three_bar_triangle_breakout(data):   
+
+    high = data['high']
+    low = data['low']
+    close = data['close']
+    open_ = data['open']
+
+    # Bullish entry condition
+    ENTRYLONG = (
+        close.iloc[-1] > open_.iloc[-1] and
+        close.iloc[-1] > close.iloc[-2] and
+        close.iloc[-1] > high.iloc[-2] and
+        low.iloc[-2] > low.iloc[-4] and
+        low.iloc[-3] > low.iloc[-4] and
+        high.iloc[-2] < high.iloc[-4] and
+        high.iloc[-3] < high.iloc[-4]
+    )
+
+    # Bearish entry condition
+    ENTRYSHORT = (
+        close.iloc[-1] < open_.iloc[-1] and
+        close.iloc[-1] < close.iloc[-2] and
+        close.iloc[-1] < low.iloc[-2] and
+        low.iloc[-2] > low.iloc[-4] and
+        low.iloc[-3] > low.iloc[-4] and
+        high.iloc[-2] < high.iloc[-4] and
+        high.iloc[-3] < high.iloc[-4]
+    )
+
+    if ENTRYLONG:
+        return "Bullish"
+    elif ENTRYSHORT:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+def hh_ll_price_action_strategy(data, lookback_days=5):
+   
+    data = data.tail(lookback_days)
+
+    is_higher_high = True
+    is_higher_low = True
+    is_lower_high = True
+    is_lower_low = True
+
+    for i in range(1, len(data)):
+        if data['high'].iloc[i] <= data['high'].iloc[i - 1]:
+            is_higher_high = False
+        if data['low'].iloc[i] <= data['low'].iloc[i - 1]:
+            is_higher_low = False
+        if data['high'].iloc[i] >= data['high'].iloc[i - 1]:
+            is_lower_high = False
+        if data['low'].iloc[i] >= data['low'].iloc[i - 1]:
+            is_lower_low = False
+
+    if is_higher_high and is_higher_low:
+        return "Bullish"
+    elif is_lower_high and is_lower_low:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+def fvg_strategy(data, lookback_days=5):
+    
+    data = data.tail(lookback_days)
+
+    for i in range(2, len(data)):
+        high_candle1 = data['high'].iloc[i - 2]
+        low_candle1 = data['low'].iloc[i - 2]
+        high_candle3 = data['high'].iloc[i]
+        low_candle3 = data['low'].iloc[i]
+
+        # Bullish FVG: Gap between high of candle 1 and low of candle 3
+        if low_candle3 > high_candle1:
+            return "Bullish"
+
+        # Bearish FVG: Gap between low of candle 1 and high of candle 3
+        if high_candle3 < low_candle1:
+            return "Bearish"
+
+    return "Neutral"
+
+def bos_strategy(data, lookback_days=10):
+   
+    data = data.tail(lookback_days)
+    highs = data['high'].tolist()
+    lows = data['low'].tolist()
+
+   
+    # Recent high/low
+    recent_high = highs[-1]
+    previous_high = max(highs[:-1])  # Highest in previous candles
+
+    recent_low = lows[-1]
+    previous_low = min(lows[:-1])    # Lowest in previous candles
+
+    # Check for bullish BOS (new high formed)
+    if recent_high > previous_high:
+        return "Bullish"
+
+    # Check for bearish BOS (new low formed)
+    if recent_low < previous_low:
+        return "Bearish"
+
+    return "Neutral"
+
+def choch_strategy(data, lookback_period=14):   
+    data = data.copy()
+
+    # Calculate recent rolling highs and lows
+    data['recent_high'] = data['high'].rolling(window=lookback_period).max()
+    data['recent_low'] = data['low'].rolling(window=lookback_period).min()   
+
+
+    # Check for Bullish or Bearish CHoCH using the most recent candle
+    if (data['high'].iloc[-1] < data['high'].iloc[-2]) and (data['low'].iloc[-1] < data['recent_low'].iloc[-2]):
+        return "Bearish"
+
+    elif (data['low'].iloc[-1] > data['low'].iloc[-2]) and (data['high'].iloc[-1] > data['recent_high'].iloc[-2]):
+        return "Bullish"    
+
+    return "Neutral"
+
+
+def order_block_strategy(data, lookback_days=2):
+   
+    data = data.tail(lookback_days)
+    
+    previous = data.iloc[-2]
+    current = data.iloc[-1]
+
+        # Bullish Order Block: last bearish candle followed by a strong bullish move
+    if previous['close'] < previous['open'] and current['close'] > current['open'] and current['close'] > previous['high']:
+            return "Bullish"
+
+        # Bearish Order Block: last bullish candle followed by a strong bearish move
+    elif previous['close'] > previous['open'] and current['close'] < current['open'] and current['close'] < previous['low']:
+            return "Bearish"
+
+    return "Neutral"
+
+
+# Main strategy function using Candlestick
+def priceaction_strategies(data):
+   
+    candlestick_signal = candlestick_pattern_strategy(data)
+    
+    hh_hl = hh_ll_price_action_strategy(data)
+
+    triangle_breakout = three_bar_triangle_breakout(data)
+
+    fvg = fvg_strategy(data)
+
+    bos = bos_strategy(data)
+
+    choch = choch_strategy(data)
+
+    order_block = order_block_strategy(data)
+
+    signals = {
+        "Candlestick Pattern": candlestick_signal,       
+        "HH_HL_LL_LH" : hh_hl,
+        "Triangle Breakout": triangle_breakout,
+        "Fair Value Gap": fvg,
+        "BOS": bos,
+        "CHoCH": choch,
+        "Order_Block": order_block
+
+    }
+
+    weights = {
+        "Candlestick Pattern": 15,       
+        "HH_HL_LL_LH": 15,
+        "Triangle Breakout": 15,
+        "Fair Value Gap": 10,
+        "BOS": 20,
+        "CHoCH": 15,
+        "Order_Block": 10
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal
+
+# API-style function for Candlestick Strategy
+def get_priceaction_trade_signal(data):
+    priceaction_signals, overallscore, final_signal = priceaction_strategies(data)
+    return {
+        "priceaction_signals": priceaction_signals,
+        "priceaction_score": overallscore,
+        "priceaction_final_signal": final_signal
+    }
+

pytrade.py

@@ -0,0 +1,71 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from flask import Response
+from analysestock import analysestock
+from list import build_companies_payload
+import yfinance as yf
+import json
+import os
+
+app = Flask(__name__)
+# CORS(app)  # allow all origins for simplicity
+
+# Allow your Angular Space + local dev
+FRONTEND_ORIGIN = os.environ.get(
+    "FRONTEND_ORIGIN",
+    "https://pykara-pytrade.static.hf.space,https://localhost:4200"
+)
+allowed = [o.strip() for o in FRONTEND_ORIGIN.split(",") if o.strip()]
+CORS(app, resources={r"/*": {"origins": allowed}}, supports_credentials=True)
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}, 200
+
+# ---------- API ----------
+
+@app.get("/getfilters")
+def get_filters():
+    return jsonify({"asOf": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "markets": MARKETS})
+
+@app.get("/getcompanies")
+def get_companies():
+    code = (request.args.get("code") or request.args.get("index") or "").upper()
+    if not code:
+        return jsonify({"error": "Missing ?code=<INDEXCODE>"}), 400
+    try:
+        payload = build_companies_payload(code)
+        return jsonify(payload)
+    except requests.HTTPError as e:
+        return jsonify({"error": f"Upstream error: {e}"}), 502
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/analysestock', methods=['POST'])
+def analyze_all():
+    try:
+        data = request.get_json()
+        tickersSymbol = data['ticker']
+        results = []
+        
+        for ticker in tickersSymbol:
+            try:
+                results.append(analysestock(ticker))
+            except Exception as e:
+                results.append({"ticker": ticker, "error": str(e)})
+
+        # Use Response with json.dumps to preserve OrderedDict order
+        return Response(json.dumps(results, indent=2), mimetype='application/json')
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# if __name__ == "__main__":
+#     app.run(host="127.0.0.1", port=5000, debug=True)
+
+if __name__ == "__main__":
+    # Default to 5000 locally; on Hugging Face Spaces the platform injects PORT.
+    port = int(os.environ.get("PORT", "5000"))
+    # Bind only to localhost in dev; bind to 0.0.0.0 when running on a platform port.
+    host = "127.0.0.1" if port == 5000 else "0.0.0.0"
+    app.run(host=host, port=port, debug=(host == "127.0.0.1"))  

requirements.txt

@@ -0,0 +1,17 @@
+flask
+flask-cors
+yfinance==0.2.65
+pandas==2.3.2
+numpy==2.3.2
+TA-Lib            # we build the C lib in Dockerfile
+scikit-learn
+scipy
+joblib
+threadpoolctl
+openpyxl
+gnews
+newspaper3k
+lxml_html_clean
+nltk
+rapidfuzz
+gunicorn

rsistrategies.py

@@ -0,0 +1,243 @@
+from flask import Flask, request, jsonify
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import talib
+from collections import OrderedDict
+import datetime
+
+# --- Strategy Functions ---
+
+def get_overbought_oversold_signal(recent):
+    if (recent['RSI_14'] < 30).any():
+        return "Bullish"
+    elif (recent['RSI_14'] > 70).any():
+        return "Bearish"
+    else:
+        return "Neutral"
+
+def get_rsi_crossover_signal(rsi5, rsi14):    
+    
+    for i in range(len(rsi5) - 1):
+        older_rsi5 = rsi5[i]
+        newer_rsi5 = rsi5[i + 1]
+        older_rsi14 = rsi14[i]
+        newer_rsi14 = rsi14[i + 1]
+        
+        # Bullish crossover (MACD crosses above Signal)
+        if older_rsi5 <= older_rsi14 and newer_rsi5 > newer_rsi14:
+            return "Bullish"
+        # Bearish crossover (MACD crosses below Signal)
+        elif older_rsi5 >= older_rsi14 and newer_rsi5 < newer_rsi14:
+            return "Bearish"
+    
+    return "Neutral"
+
+
+
+def get_mean_reversion_signal(df):
+    rsi = df['RSI_5']
+    if len(rsi) < 6:
+        return "Neutral"
+
+    # Check for crossover below 20 in last 5 entries
+    buy_signal = ((rsi < 20) & (rsi.shift(1) >= 20)).tail(5).any()
+    sell_signal = ((rsi > 80) & (rsi.shift(1) <= 80)).tail(5).any()
+
+    if buy_signal:
+        return "Bullish"
+    elif sell_signal:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+def get_bollinger_rsi_signal(recent):
+    buy = ((recent['close'].to_numpy().flatten() < recent['Lower_BB']) & (recent['RSI_14'] < 30)).any()
+    sell = ((recent['close'].to_numpy().flatten() > recent['Upper_BB']) & (recent['RSI_14'] > 70)).any()
+    if buy:
+        return "Bullish"
+    elif sell:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+def get_rsi_with_ma_signal(recent):
+    buy = ((recent['close'].to_numpy().flatten() > recent['MA_20']) & (recent['RSI_14'] > 50)).any()
+    sell = ((recent['close'].to_numpy().flatten() < recent['MA_20']) & (recent['RSI_14'] < 50)).any()
+    if buy:
+        return "Bullish"
+    elif sell:
+        return "Bearish"
+    else:
+        return "Neutral"
+
+def get_rsi_50_trend_signal(recent):
+    if (recent['RSI_14'] > 50).all():
+        return "Bullish"
+    elif (recent['RSI_14'] < 50).all():
+        return "Bearish"
+    else:
+        return "Neutral"
+
+
+def get_swing_rejection_signal(rsi14):
+    
+    r1, r2, r3, r4, r5, r6 = rsi14
+
+    if (
+        r1 < 30 and
+        r2 > r1 and
+        r3 < r2 and r3 > r1 and
+        r4 > r3 and
+        (r5 > r2 or r6 > r2) and
+        r6 > 30
+    ):
+        return "Bullish"
+
+    elif (
+        r1 > 70 and
+        r2 < r1 and
+        r3 > r2 and r3 < r1 and
+        r4 < r3 and
+        (r5 < r2 or r6 < r2) and
+        r6 < 70
+    ):
+        return "Bearish"
+
+    return "Neutral"
+
+
+def is_pivot_low(prices, idx, left=5, right=5):
+    """Check if current point is a pivot low"""
+    if idx < left or idx + right >= len(prices):
+        return False
+    return all(prices[idx] < prices[idx - i] and prices[idx] < prices[idx + i] for i in range(1, left + 1))
+
+def is_pivot_high(prices, idx, left=5, right=5):
+    """Check if current point is a pivot high"""
+    if idx < left or idx + right >= len(prices):
+        return False
+    return all(prices[idx] > prices[idx - i] and prices[idx] > prices[idx + i] for i in range(1, left + 1))
+
+def get_rsi_divergence_signal(df):
+    df = df.dropna().reset_index(drop=True)
+    prices = df['close'].values
+    rsi = df['RSI_14'].values
+
+    left = 5
+    right = 5
+    max_range = 20
+
+    recent_idx = len(prices) - 1  # latest candle
+    start_idx = max(recent_idx - max_range, left)
+
+    for i in range(recent_idx - 1, start_idx - 1, -1):
+        if is_pivot_low(prices, i, left, right) and is_pivot_low(rsi, i, left, right):
+            # Regular Bullish Divergence
+            if prices[recent_idx] < prices[i] and rsi[recent_idx] > rsi[i]:
+                return "Bullish"
+
+        if is_pivot_high(prices, i, left, right) and is_pivot_high(rsi, i, left, right):
+            # Regular Bearish Divergence
+            if prices[recent_idx] > prices[i] and rsi[recent_idx] < rsi[i]:
+                return "Bearish"
+
+    return "Neutral"
+
+
+# --- Master RSI Strategy Function ---
+
+def rsi_strategies(df):
+
+    close_prices = df['close']
+   
+    # Calculate all indicators
+    df['RSI_14'] = talib.RSI(close_prices, timeperiod=14)
+    df['RSI_5'] = talib.RSI(close_prices, timeperiod=5)
+    df['MA_20'] = talib.SMA(close_prices, timeperiod=20)
+    df['Upper_BB'], df['Middle_BB'], df['Lower_BB'] = talib.BBANDS(close_prices, timeperiod=20)
+
+    
+    # Ensure all calculations are added to df before slicing
+    recent = df.tail(5)
+    
+
+    signals = OrderedDict([
+    ("RSI 14", round(df[['RSI_14']].iloc[-1][0], 2)),
+    ("Overbought/Oversold", get_overbought_oversold_signal(recent)),
+    ("RSI Swing Rejection", get_swing_rejection_signal(df['RSI_14'].tail(6))),
+    ("RSI Divergence", get_rsi_divergence_signal(df)),
+    ("RSI_Bollinger Band", get_bollinger_rsi_signal(recent)),
+    ("RSI 5/14 Crossover", get_rsi_crossover_signal(df['RSI_5'].tail(5),df['RSI_14'].tail(5))),
+    ("RSI Trend 50 Confirmation", get_rsi_50_trend_signal(recent)),
+    ("RSI_MA", get_rsi_with_ma_signal(recent)),
+    ("Mean Reversion", get_mean_reversion_signal(df[['RSI_5']].tail(6)))
+        ])
+
+
+    # Weightage for each signal
+    rsi_signal_weights = {
+        "Overbought/Oversold": 15,
+        "RSI Swing Rejection": 15,
+        "RSI Divergence": 15,
+        "RSI_Bollinger Band": 15,
+        "RSI 5/14 Crossover": 10,                 
+        "RSI Trend 50 Confirmation": 10,
+        "RSI_MA": 10,
+        "Mean Reversion": 10    
+        
+    }
+    
+    # Calculate weighted score
+    total_score = 0
+    for strategy, weight in rsi_signal_weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+        # Bearish gives 0 score
+
+    overall_percentage = round((total_score / sum(rsi_signal_weights.values())) * 100, 2)
+
+    
+
+    # Final output signal
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+    
+
+    return signals, overall_percentage, final_signal
+
+def extract_series(data, column_name, days=100):
+    series = data[[column_name]].dropna().tail(days)
+    series.index = series.index.strftime('%Y-%m-%d')
+    return series[column_name].round(2).to_dict()
+
+def get_rsi_trade_signal(data):    
+
+    rsi_signals, overallscore, final_signal = rsi_strategies(data)
+
+    return {     
+        
+        "rsi_signals": rsi_signals,
+        "rsi_score": overallscore,
+        "rsi_final_signal": final_signal,
+        "rsi_14_last_2_years": extract_series(data, 'RSI_14'),
+        "rsi_5_last_2_years": extract_series(data, 'RSI_5'),
+        "ma": extract_series(data, 'MA_20'),
+        "close": extract_series(data, 'close'),
+        "open": extract_series(data, 'open'),
+        "high": extract_series(data, 'high'),
+        "low": extract_series(data, 'low'),
+        "lowerbb": extract_series(data, 'Lower_BB'),
+        "upperbb": extract_series(data, 'Upper_BB')
+    }
+
+

srstrategies.py

@@ -0,0 +1,175 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import datetime
+import talib
+
+
+# Calculate Support and Resistance using Pivot Points
+def calculate_support_resistance(data):
+    # Pivot Point Calculation
+    data['Pivot'] = (data['high'] + data['low'] + data['close']) / 3
+    # Support and Resistance Calculations
+    data['Support1'] = (2 * data['Pivot']) - data['high']
+    data['Resistance1'] = (2 * data['Pivot']) - data['low']
+   
+    return data
+
+#Strategy 1: Reversal strategy - find the difference between close and support/resistance and find the tolerance value based on ATR if it is less than tolernace value and check the candlestick pattern - based on the return bullish/bearish/neutral
+def detect_reversal(df, support, resistance):
+    df['Signal'] = 'Neutral'  # Default is neutral
+    
+    close_prices = df['close'].to_numpy().flatten()
+    high_prices = df['high'].to_numpy().flatten()
+    low_prices = df['low'].to_numpy().flatten()
+    open_prices = df['open'].to_numpy().flatten()
+    
+    # Use common reversal patterns
+    hammer = talib.CDLHAMMER(open_prices, high_prices, low_prices, close_prices)
+    engulfing = talib.CDLENGULFING(open_prices, high_prices, low_prices, close_prices)
+    shooting_star = talib.CDLSHOOTINGSTAR(open_prices, high_prices, low_prices, close_prices)
+    doji = talib.CDLDOJI(open_prices, high_prices, low_prices, close_prices)
+    morning_star = talib.CDLMORNINGSTAR(open_prices, high_prices, low_prices, close_prices)
+    evening_star = talib.CDLEVENINGSTAR(open_prices, high_prices, low_prices, close_prices)
+    piercing_line = talib.CDLPIERCING(open_prices, high_prices, low_prices, close_prices)
+    harami = talib.CDLHARAMI(open_prices, high_prices, low_prices, close_prices)
+    df['ATR'] = talib.ATR(high_prices, low_prices, close_prices, timeperiod=14)
+    tolerance = df['ATR'].iloc[-1] * 2  
+    for i in range(1, len(df)):
+        close = close_prices[i]
+        
+        # Detect Bullish Reversal
+        if abs(close - support[i]) <= tolerance:
+            if hammer[i] > 0 or engulfing[i] > 0 or doji[i] > 0 or morning_star[i] > 0 or piercing_line[i] > 0 or harami[i] > 0:
+                df.loc[df.index[i], 'Signal'] = 'Bullish'
+        
+        # Detect Bearish Reversal
+        if abs(close - resistance[i]) <= tolerance:
+            if shooting_star[i] < 0 or engulfing[i] < 0 or doji[i] < 0 or evening_star[i] < 0 or piercing_line[i] < 0 or harami[i] < 0:
+                df.loc[df.index[i], 'Signal'] = 'Bearish'
+
+    return df
+
+
+# Strategy 2: Breakout Trading - the previous day should be above to resistance/support and break the support and resistance and crossed
+def detect_breakouts(df):    
+    support_level = df['Support1'].iloc[-1]
+    resistance_level = df['Resistance1'].iloc[-1]    
+    
+    if df['close'].iloc[-1] > resistance_level and df['close'].iloc[-2] <= resistance_level:
+       return "Bullish"
+
+    elif df['close'].iloc[-1] < resistance_level and df['close'].iloc[-2] >= resistance_level:
+       return "Bearish"
+
+    elif df['close'].iloc[-1] > support_level and df['close'].iloc[-2] <= support_level:
+       return "Bullish"
+
+    elif df['close'].iloc[-1] < support_level and df['close'].iloc[-2] >= support_level:
+       return "Bearish"
+
+    return "Neutral"
+
+# Strategy 3: Flip Zone 
+def detect_flip_zone(df):
+   
+    support_level = df['Support1'].iloc[-1]
+    resistance_level = df['Resistance1'].iloc[-1]
+
+    if df['close'].iloc[-3] < support_level and df['close'].iloc[-2] >= support_level and df['close'].iloc[-1] > support_level:
+      return "Bullish"
+
+    elif df['close'].iloc[-3] > support_level and df['close'].iloc[-2] <= support_level and df['close'].iloc[-1] < support_level:
+      return "Bearish"
+
+    elif df['close'].iloc[-3] < resistance_level and df['close'].iloc[-2] >= resistance_level and df['close'].iloc[-1] > resistance_level:
+      return "Bullish"
+
+    elif df['close'].iloc[-3] > resistance_level and df['close'].iloc[-2] <= resistance_level and df['close'].iloc[-1] < resistance_level:
+      return "Bearish"       
+   
+    
+    return "Neutral"
+
+# Strategy 4: SR RETEST - bounceup and bouncedown
+def detect_sr_retest(df):
+   
+    support_level = df['Support1'].iloc[-1]
+    resistance_level = df['Resistance1'].iloc[-1]
+
+    # Retest Strategy: Bullish Retest - Price breaks above resistance and then tests it as support
+    if df['close'].iloc[-4] < resistance_level and df['close'].iloc[-3] >= resistance_level and df['close'].iloc[-2] < df['close'].iloc[-3] and df['close'].iloc[-2] < df['close'].iloc[-1]:
+        return "Bearish"  
+
+    elif df['close'].iloc[-4] > resistance_level and df['close'].iloc[-3] <= resistance_level and df['close'].iloc[-2] > df['close'].iloc[-3] and df['close'].iloc[-2] > df['close'].iloc[-1]:
+        return "Bullish"
+
+    elif df['close'].iloc[-4] < support_level and df['close'].iloc[-3] >= support_level and df['close'].iloc[-2] < df['close'].iloc[-3] and df['close'].iloc[-2] < df['close'].iloc[-1]:
+        return "Bullish"  
+
+    elif df['close'].iloc[-4] > support_level and df['close'].iloc[-3] <= support_level and df['close'].iloc[-2] > df['close'].iloc[-3] and df['close'].iloc[-2] > df['close'].iloc[-1]:
+        return "Bearish"     
+   
+    
+    return "Neutral"
+
+
+# Final Signal Calculation
+def support_resistance_strategy(data):
+   
+
+    # Calculate Support and Resistance levels using Pivot Points
+    data = calculate_support_resistance(data)
+    # Calculate the market trend based on price and support/resistance
+    breakout = detect_breakouts(data)
+    reversal = detect_reversal(data, data['Support1'].to_numpy(), data['Resistance1'].to_numpy())
+    flip = detect_flip_zone(data)
+    
+    sr_retest = detect_sr_retest(data)
+    
+
+    # Weight the signals for a final decision (example weighting)
+    signals = {
+        "Support1": round(data['Support1'].iloc[-1], 2),
+        "Resistance1": round(data['Resistance1'].iloc[-1], 2),
+        "Breakout": breakout,
+        "Reversal": reversal['Signal'].iloc[-1],  
+        "Flip": flip,        
+        "SR_Retest":sr_retest       
+        
+    }
+
+    weights = {
+        "Breakout": 35,
+        "Reversal": 25,  
+        "Flip": 20,
+        "SR_Retest":20       
+    }
+
+    total_score = 0
+    for strategy, weight in weights.items():
+        signal = signals[strategy]
+        if signal == "Bullish":
+            total_score += weight
+        elif signal == "Neutral":
+            total_score += weight * 0.5
+
+    overall_percentage = round((total_score / sum(weights.values())) * 100, 2)
+
+    if overall_percentage >= 60:
+        final_signal = "Buy"
+    elif overall_percentage <= 40:
+        final_signal = "DBuy"
+    else:
+        final_signal = "Neutral"
+
+    return signals, overall_percentage, final_signal
+
+# API-style function
+def get_support_resistance_signal(data):
+    sr_signals, overallscore, final_signal = support_resistance_strategy(data)
+    return {
+        "support_resistance_signals": sr_signals,
+        "sr_score": overallscore,
+        "sr_final_signal": final_signal
+    }

testing.py

@@ -0,0 +1,28 @@
+from flask import Flask, request, jsonify
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+import torch
+
+app = Flask(__name__)
+
+# Load model and tokenizer
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model_name = "AventIQ-AI/t5-stockmarket-qa-chatbot"
+model = T5ForConditionalGeneration.from_pretrained(model_name).to(device)
+tokenizer = T5Tokenizer.from_pretrained(model_name)
+
+@app.route('/ask', methods=['POST'])
+def ask():
+    # Get question from the frontend
+    question = request.json.get('question', '')
+    input_text = "question: " + question
+    input_ids = tokenizer.encode(input_text, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        outputs = model.generate(input_ids, max_length=50)
+        answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    # Return the answer as a JSON response
+    return jsonify({'answer': answer})
+
+if __name__ == '__main__':
+    app.run(debug=True)