nas08-scripts/Stocks/stockproxy_app.py

import os
import time
import sqlite3
import threading
from datetime import datetime, timedelta

import requests
from flask import Flask, request, jsonify

app = Flask(__name__)

# ---- Config ----
SHARED_SECRET = os.environ.get("PROXY_SECRET", "")
DB_PATH = os.environ.get("DB_PATH", "/data/cache.db")
CURRENT_TTL_SECONDS = 15 * 60  # re-check "today" every 15 min in case NAV just posted

_db_lock = threading.Lock()

def get_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS historical_cache (
            ticker TEXT NOT NULL,
            requested_date TEXT NOT NULL,
            resolved_date TEXT NOT NULL,
            price REAL NOT NULL,
            PRIMARY KEY (ticker, requested_date)
        )
    """)
    return conn

_current_cache = {}   # ticker -> (price, resolved_date, fetched_at)
_current_cache_lock = threading.Lock()


@app.after_request
def add_cors_headers(response):
    response.headers["Access-Control-Allow-Origin"] = "*"
    response.headers["Access-Control-Allow-Methods"] = "GET, OPTIONS"
    response.headers["Access-Control-Allow-Headers"] = "Content-Type"
    return response


def check_auth():
    key = request.args.get("key", "")
    return bool(SHARED_SECRET) and key == SHARED_SECRET


def fetch_yahoo_price(ticker, target_date):
    """Ask Yahoo for the last trading-day close on or before target_date."""
    period2 = int((target_date + timedelta(days=1)).timestamp())
    period1 = int((target_date - timedelta(days=10)).timestamp())

    url = f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}"
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
    r = requests.get(url, params={"period1": period1, "period2": period2, "interval": "1d"}, headers=headers, timeout=10)

    if r.status_code != 200:
        return None, f"yahoo http {r.status_code}"

    data = r.json()
    try:
        result = data["chart"]["result"][0]
        timestamps = result["timestamp"]
        closes = result["indicators"]["quote"][0]["close"]
    except (KeyError, IndexError, TypeError):
        return None, "no historical data"

    best = None
    for ts, close in zip(timestamps, closes):
        if close is None:
            continue
        day = datetime.utcfromtimestamp(ts)
        if day.date() <= target_date.date():
            if best is None or day > best[0]:
                best = (day, close)

    if best is None:
        return None, "no trading day found in window"

    return {"resolved_date": best[0].strftime("%Y-%m-%d"), "price": round(best[1], 4)}, None


@app.route("/current")
def current_price():
    if not check_auth():
        return jsonify({"error": "unauthorized"}), 401

    ticker = request.args.get("ticker", "").upper().strip()
    if not ticker:
        return jsonify({"error": "missing ticker"}), 400

    now = time.time()
    with _current_cache_lock:
        cached = _current_cache.get(ticker)
        if cached and (now - cached[2]) < CURRENT_TTL_SECONDS:
            return jsonify({"ticker": ticker, "price": cached[0], "resolved_date": cached[1], "cached": True})

    result, err = fetch_yahoo_price(ticker, datetime.utcnow())
    if err:
        return jsonify({"ticker": ticker, "error": err}), 502

    with _current_cache_lock:
        _current_cache[ticker] = (result["price"], result["resolved_date"], now)

    return jsonify({"ticker": ticker, "price": result["price"], "resolved_date": result["resolved_date"], "cached": False})


@app.route("/historical")
def historical_price():
    if not check_auth():
        return jsonify({"error": "unauthorized"}), 401

    ticker = request.args.get("ticker", "").upper().strip()
    date_str = request.args.get("date", "").strip()
    if not ticker or not date_str:
        return jsonify({"error": "missing ticker or date"}), 400

    try:
        target_date = datetime.strptime(date_str, "%Y-%m-%d")
    except ValueError:
        return jsonify({"error": "date must be YYYY-MM-DD"}), 400

    # If someone asks "historical" for today/future, treat it like /current instead
    if target_date.date() >= datetime.utcnow().date():
        return current_price()

    with _db_lock:
        conn = get_db()
        row = conn.execute(
            "SELECT resolved_date, price FROM historical_cache WHERE ticker=? AND requested_date=?",
            (ticker, date_str),
        ).fetchone()
        conn.close()

    if row:
        return jsonify({"ticker": ticker, "requested_date": date_str, "resolved_date": row[0], "price": row[1], "cached": True})

    result, err = fetch_yahoo_price(ticker, target_date)
    if err:
        return jsonify({"ticker": ticker, "error": err}), 502

    with _db_lock:
        conn = get_db()
        conn.execute(
            "INSERT OR REPLACE INTO historical_cache (ticker, requested_date, resolved_date, price) VALUES (?, ?, ?, ?)",
            (ticker, date_str, result["resolved_date"], result["price"]),
        )
        conn.commit()
        conn.close()

    return jsonify({"ticker": ticker, "requested_date": date_str, "resolved_date": result["resolved_date"], "price": result["price"], "cached": False})


@app.route("/health")
def health():
    return jsonify({"status": "ok"})


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5005)