update pytrade.py

pytrade.py

@@ -12,7 +12,6 @@ import jwt  # PyJWT
 from flask import Flask, request, jsonify, Response, make_response
 from flask_cors import CORS
 
-# --- Your modules ---
 # --- Your modules ---
 from analysestock import analysestock
 from list import (
@@ -26,6 +25,7 @@ from signin import get_db_connection, ensure_user_table_exists  # <- NOTE: from
 import bcrypt  # pip install bcrypt
 from typing import Tuple
 from werkzeug.security import generate_password_hash, check_password_hash
+import yfinance as yf
 
 # ------------------------------------------------------------------------------
 # App, ENV, CORS
@@ -47,6 +47,7 @@ FRONTEND_ORIGIN = os.environ.get(
     "FRONTEND_ORIGIN",
     "https://pykara-py-trade.static.hf.space,https://localhost:4200"
 )
+
 allowed = [o.strip() for o in FRONTEND_ORIGIN.split(",") if o.strip()]
 CORS(
     app,
@@ -524,7 +525,7 @@ def create_community_post():
         if not row or row[0] is None:
             return jsonify({"error": "Failed to retrieve new post id"}), 500
 
-        new_id = int(row[0])
+        new_id = int(row[0]);
 
         return jsonify({
             "id": new_id,
@@ -616,6 +617,365 @@ def list_community_posts():
         except:
             pass
         conn.close()
+        
+
+# ------------------------------------------------------------------------------
+# Market overview values (uses yfinance)
+# ------------------------------------------------------------------------------
+@app.get("/getmarketcards")
+def get_market_cards():
+    """
+    Returns a list of market overview items with live prices fetched from yfinance.
+    Each item: { title, price, chg, chgPct }
+    """
+    # map of friendly title -> yfinance symbol
+    tickers = {
+        'Gold': 'GC=F',
+        'Silver': 'SI=F',
+        'Crude Oil (Brent)': 'BZ=F',
+        'Crude Oil (WTI)': 'CL=F',
+        'Natural Gas': 'NG=F',
+        'USD/INR': 'INR=X',
+        'EUR/USD': 'EURUSD=X',
+        'GBP/USD': 'GBPUSD=X',
+        'Bitcoin': 'BTC-USD',
+        'Ethereum': 'ETH-USD',
+        'S&P 500': '^GSPC',
+        'NASDAQ': '^IXIC',
+        'DAX': '^GDAXI',
+        'Nikkei': '^N225',
+        'Copper': 'HG=F'
+    }
+
+    out = []
+    for title, symbol in tickers.items():
+        try:
+            t = yf.Ticker(symbol)
+            # try to get recent close prices
+            hist = None
+            try:
+                hist = t.history(period="2d")
+            except Exception:
+                hist = None
+
+            price = None
+            chg = None
+            chg_pct = None
+
+            if hist is not None and hasattr(hist, 'empty') and not hist.empty:
+                closes = list(hist['Close'].values)
+                if len(closes) >= 2:
+                    last = float(closes[-1])
+                    prev = float(closes[-2])
+                else:
+                    last = float(closes[-1])
+                    prev = last
+                price = last
+                chg = last - prev
+                chg_pct = (chg / prev * 100) if prev != 0 else 0.0
+            else:
+                # fallback: try fast info lookup
+                info = {}
+                try:
+                    info = t.info or {}
+                except Exception:
+                    info = {}
+                # try fields: 'regularMarketPrice', 'previousClose'
+                last = info.get('regularMarketPrice') or info.get('currentPrice') or info.get('previousClose')
+                prev = info.get('previousClose')
+                try:
+                    if last is not None:
+                        price = float(last)
+                    if prev is not None:
+                        chg = float(last) - float(prev) if last is not None else None
+                        chg_pct = (chg / float(prev) * 100) if prev and chg is not None else None
+                except Exception:
+                    price = price or None
+
+            out.append({
+                'title': title,
+                'symbol': symbol,
+                'price': price,
+                'chg': chg,
+                'chgPct': chg_pct
+            })
+        except Exception as e:
+            app.logger.exception('getmarketcards: failed for %s', symbol)
+            out.append({'title': title, 'symbol': symbol, 'price': None, 'chg': None, 'chgPct': None})
+
+    return jsonify(out), 200
+
+
+# ------------------------------------------------------------------------------
+# Global indices (uses yfinance)
+# ------------------------------------------------------------------------------
+@app.get("/getglobalindices")
+def get_global_indices():
+    """
+    Returns a flat list of global indices for a set of countries. Each item:
+    { id, name, country, region, price, change, changePct, sparkline }
+    """
+    # Define representative indices per country with yfinance symbols
+    indices_map = {
+        'India': [
+            ('Nifty 50', '^NSEI'),
+            ('SENSEX', '^BSESN'),
+            ('Nifty Bank', '^NSEBANK'),
+            ('Nifty Midcap 100', None),
+            ('Nifty Smallcap 100', None),
+        ],
+        'United States': [
+            ('S&P 500', '^GSPC'),
+            ('Dow Jones', '^DJI'),
+            ('Nasdaq Composite', '^IXIC'),
+            ('S&P MidCap 400', None),
+            ('S&P SmallCap 600', None),
+        ],
+        'United Kingdom': [
+            ('FTSE 100', '^FTSE'),
+            ('FTSE 250', None),
+        ],
+        'Germany': [
+            ('DAX', '^GDAXI'),
+            ('MDAX', None),
+        ],
+        'Sweden': [
+            ('OMX Stockholm 30', '^OMXSPI'),
+        ],
+        'Russia': [
+            ('MOEX Russia', 'IMOEX.ME'),
+            ('RTS Index', None),
+        ]
+    }
+
+    def build_spark_from_hist(close_vals, pts=26):
+        # normalize to length pts by sampling or padding
+        arr = []
+        if not close_vals:
+            # synthetic series
+            base = 100
+            from random import random
+            arr = [max(1, base + (random() - 0.5) * base * 0.02) for _ in range(pts)]
+            return arr
+        vals = list(close_vals)
+        # if too short, pad with last
+        while len(vals) < pts:
+            vals.insert(0, vals[0])
+        if len(vals) > pts:
+            # sample evenly
+            step = len(vals) / pts
+            sampled = [vals[int(i * step)] for i in range(pts)]
+            return [float(v) for v in sampled]
+        return [float(v) for v in vals]
+
+    out = []
+    for country, items in indices_map.items():
+        for name, symbol in items:
+            price = None
+            change = None
+            change_pct = None
+            spark = []
+            try:
+                if symbol:
+                    t = yf.Ticker(symbol)
+                    hist = None
+                    try:
+                        hist = t.history(period='30d')
+                    except Exception:
+                        hist = None
+                    if hist is not None and hasattr(hist, 'empty') and not hist.empty:
+                        closes = list(hist['Close'].values)
+                        # create spark from most recent values
+                        spark = build_spark_from_hist(closes[-26:], pts=26)
+                        last = float(closes[-1])
+                        prev = float(closes[-2]) if len(closes) >= 2 else last
+                        price = last
+                        change = last - prev
+                        change_pct = (change / prev * 100) if prev != 0 else 0.0
+                    else:
+                        # try single-value info
+                        info = {}
+                        try:
+                            info = t.info or {}
+                        except Exception:
+                            info = {}
+                        last = info.get('regularMarketPrice') or info.get('currentPrice') or info.get('previousClose')
+                        prev = info.get('previousClose')
+                        if last is not None:
+                            price = float(last)
+                        if price is not None and prev is not None:
+                            change = float(price) - float(prev)
+                            change_pct = (change / float(prev) * 100) if prev != 0 else 0.0
+                else:
+                    # no symbol: produce demo values (randomized around a base)
+                    import random
+                    base = 10000 if 'Nifty' in name or 'Sensex' in name or 'Nifty' in name else 1000
+                    price = round(base + (random.random() - 0.5) * base * 0.05, 2)
+                    change = round((random.random() - 0.5) * price * 0.01, 2)
+                    change_pct = (change / (price - change) * 100) if price - change != 0 else 0.0
+                    spark = build_spark_from_hist([price for _ in range(26)], pts=26)
+            except Exception as e:
+                app.logger.exception('get_global_indices: failed for %s', symbol or name)
+
+            gid = (name or '').replace('\n', ' ').replace(' ', '_') + '_' + (country.replace(' ', '_') if country else 'unknown')
+            out.append({
+                'id': gid,
+                'name': name,
+                'country': country,
+                'region': country,
+                'price': price,
+                'change': change,
+                'changePct': change_pct,
+                'sparkline': spark
+            })
+
+    return jsonify(out), 200
+
+@app.get("/getquotes")
+def get_quotes():
+    """
+    Returns live quotes for a list of tickers provided via ?tickers=CSV
+    Each returned item: { symbol, price, chg, chgPct, high, low }
+    """
+    tickers_csv = (request.args.get("tickers") or "").strip()
+    if not tickers_csv:
+        return jsonify({"error": "Missing ?tickers=..."}), 400
+
+    tickers = [t.strip() for t in tickers_csv.split(",") if t.strip()]
+    out = []
+    for symbol in tickers:
+        price = None
+        chg = None
+        chg_pct = None
+        high = None
+        low = None
+        try:
+            t = yf.Ticker(symbol)
+            hist = None
+            try:
+                hist = t.history(period="2d")
+            except Exception:
+                hist = None
+
+            if hist is not None and hasattr(hist, 'empty') and not hist.empty:
+                closes = list(hist['Close'].values)
+                if len(closes) >= 2:
+                    last = float(closes[-1])
+                    prev = float(closes[-2])
+                else:
+                    last = float(closes[-1])
+                    prev = last
+                price = last
+                chg = last - prev
+                chg_pct = (chg / prev * 100) if prev != 0 else 0.0
+
+                # try to extract intraday high/low from history if available
+                try:
+                    highs = list(hist['High'].values)
+                    lows = list(hist['Low'].values)
+                    high = float(highs[-1]) if highs else None
+                    low = float(lows[-1]) if lows else None
+                except Exception:
+                    high = None
+                    low = None
+            else:
+                info = {}
+                try:
+                    info = t.info or {}
+                except Exception:
+                    info = {}
+                last = info.get('regularMarketPrice') or info.get('currentPrice') or info.get('previousClose')
+                prev = info.get('previousClose')
+                if last is not None:
+                    price = float(last)
+                if price is not None and prev is not None:
+                    chg = float(price) - float(prev)
+                    chg_pct = (chg / float(prev) * 100) if prev != 0 else 0.0
+                try:
+                    high = info.get('dayHigh') or info.get('regularMarketDayRange')
+                    low = info.get('dayLow')
+                except Exception:
+                    high = None
+                    low = None
+        except Exception as e:
+            app.logger.exception('get_quotes: failed for %s', symbol)
+
+        out.append({
+            'symbol': symbol,
+            'price': price,
+            'chg': chg,
+            'chgPct': chg_pct,
+            'high': high,
+            'low': low
+        })
+
+    return jsonify(out), 200
+
+@app.get("/getintraday")
+def get_intraday():
+    """
+    Returns intraday series for a given symbol using yfinance.
+    Query params: ?symbol=...&period=1d&interval=1m
+    Response: { symbol, timestamps: [iso,...], closes: [num,...] }
+    """
+    symbol = (request.args.get('symbol') or '').strip()
+    period = (request.args.get('period') or '1d').strip()
+    interval = (request.args.get('interval') or '1m').strip()
+    if not symbol:
+        return jsonify({'error': 'Missing ?symbol parameter'}), 400
+
+    try:
+        t = yf.Ticker(symbol)
+        hist = None
+        try:
+            hist = t.history(period=period, interval=interval)
+        except Exception:
+            hist = None
+
+        timestamps = []
+        closes = []
+        if hist is not None and hasattr(hist, 'empty') and not hist.empty:
+            # hist.index may be DatetimeIndex
+            for idx, row in hist.iterrows():
+                try:
+                    ts = idx.isoformat()
+                except Exception:
+                    try:
+                        ts = str(idx)
+                    except Exception:
+                        ts = None
+                if ts is not None:
+                    timestamps.append(ts)
+                try:
+                    closes.append(float(row['Close']))
+                except Exception:
+                    closes.append(None)
+        else:
+            # fallback: attempt to get last close from info
+            info = {}
+            try:
+                info = t.info or {}
+            except Exception:
+                info = {}
+            last = info.get('regularMarketPrice') or info.get('currentPrice') or info.get('previousClose')
+            if last is not None:
+                # return a tiny synthetic series
+                from datetime import datetime, timedelta
+                now = datetime.utcnow()
+                for i in range(60):
+                    ts = (now - timedelta(minutes=(59 - i))).isoformat()
+                    timestamps.append(ts)
+                    closes.append(float(last))
+
+        return jsonify({
+            'symbol': symbol,
+            'timestamps': timestamps,
+            'closes': closes
+        }), 200
+    except Exception as e:
+        app.logger.exception('get_intraday failed for %s', symbol)
+        return jsonify({'symbol': symbol, 'timestamps': [], 'closes': []}), 200
+
 # ------------------------------------------------------------------------------
 # Run
 # ------------------------------------------------------------------------------