Update app.py

app.py

@@ -1,90 +1,110 @@
+# app.py
+#
+# Hugging Face Space – Live U.S. Debt Clock
+# · Pulls the last 10 Treasury “Debt to the Penny” points
+# · Derives a $/sec rate from the two most-recent *different* days
+# · Computes the *current* debt by projecting from the timestamp
+#   of the latest record → now
+# · Refreshes every 5 min so the rate/value stay current
+#
+# Endpoints
+#   /            – simple text “running” check
+#   /api/debt    – JSON { startingDebt, ratePerSecond, asOf }
+#   /api/ping    – lightweight uptime probe
+
+import os, time, threading, requests
 from flask import Flask, jsonify
-import requests
-import threading
-import time
-import os
 
 app = Flask(__name__)
 
-# ─────── LIVE STATE ─────────────────────────
+# ─────────────────── runtime state ────────────────────
 DEBT_STATE = {
-    "starting_debt": 0,
-    "rate_per_sec": 0,
-    "last_updated": time.time()
+    "debt_at_record": 0.0,       # value at latest record date
+    "record_time":    0.0,       # epoch seconds for that record date (00:00 UTC)
+    "rate_per_sec":   0.0,       # $/s derived from last-two-points
+    "last_refresh":   0.0        # when we last hit the API
 }
 
-# ─────── API FETCH ─────────────────────────
-def get_debt_data():
-    url = "https://api.fiscaldata.treasury.gov/services/api/fiscal_service/v2/accounting/od/debt_to_penny"
-    url += "?fields=record_date,tot_pub_debt_out_amt"
-    url += "&sort=-record_date&page[size]=10"
-
-    resp = requests.get(url, timeout=10)
-    records = resp.json()["data"]
-
+# ─────────────────── helpers ──────────────────────────
+API = (
+    "https://api.fiscaldata.treasury.gov/services/api/fiscal_service/v2/"
+    "accounting/od/debt_to_penny"
+    "?fields=record_date,tot_pub_debt_out_amt"
+    "&sort=-record_date&page[size]=10"
+)
+
+def load_debt_records():
+    r = requests.get(API, timeout=15)
+    r.raise_for_status()
     return [
-        (r["record_date"], float(r["tot_pub_debt_out_amt"]))
-        for r in records
+        (item["record_date"], float(item["tot_pub_debt_out_amt"]))
+        for item in r.json()["data"]
     ]
 
-# ─────── BACKGROUND REFRESH ────────────────
-def refresh_debt_periodically():
+def epoch(date_str):
+    # record_date is YYYY-MM-DD (assume 00:00 UTC)
+    return time.mktime(time.strptime(date_str, "%Y-%m-%d"))
+
+# ─────────────────── background refresher ────────────
+def refresher():
     while True:
         try:
-            records = get_debt_data()
-            today, today_amt = records[0]
-            prev_day, prev_amt = None, None
+            recs = load_debt_records()             # newest first
+            (d0_date, d0_val) = recs[0]
 
-            for r in records[1:]:
-                if r[1] != today_amt:
-                    prev_day, prev_amt = r
-                    break
+            # find previous day with a *different* value
+            prev = next((d for d in recs[1:] if d[1] != d0_val), None)
+            if prev is None:
+                raise ValueError("Could not find two distinct points")
 
-            if prev_day:
-                t1 = time.mktime(time.strptime(today, "%Y-%m-%d"))
-                t2 = time.mktime(time.strptime(prev_day, "%Y-%m-%d"))
-                rate = (today_amt - prev_amt) / (t1 - t2)
+            (d1_date, d1_val) = prev
 
-                # optional: freeze rate if negative
-                if rate < 0:
-                    rate = 0
+            t0, t1 = epoch(d0_date), epoch(d1_date)
+            rate = (d0_val - d1_val) / (t0 - t1)   # $/sec
 
-                DEBT_STATE["starting_debt"] = today_amt
-                DEBT_STATE["rate_per_sec"] = rate
-                DEBT_STATE["last_updated"] = time.time()
+            if rate < 0:                           # optional: freeze if negative
+                rate = 0
 
-                print(f"✅ Refreshed: {today_amt=:.2f}, {rate=:.2f}/sec")
+            DEBT_STATE.update(
+                debt_at_record = d0_val,
+                record_time    = t0,
+                rate_per_sec   = rate,
+                last_refresh   = time.time()
+            )
+
+            print(
+                f"[refresh] {d0_date=}  "
+                f"debt={d0_val:,.2f}  rate={rate:,.2f}$/s"
+            )
 
         except Exception as e:
-            print("❌ Error refreshing debt:", e)
+            print("Debt refresh error:", e)
 
-        time.sleep(300)  # 5 minutes
+        time.sleep(300)      # five-minute cycle
 
+threading.Thread(target=refresher, daemon=True).start()
 
-# ─────── ROUTES ────────────────────────────
+# ────────────��────── routes ──────────────────────────
 @app.route("/")
-def home():
-    return "✅ Debt clock is running", 200
+def root():
+    return "✅ Debt clock running", 200
 
 @app.route("/api/debt")
-def get_debt_api():
+def api_debt():
     now = time.time()
-    elapsed = now - DEBT_STATE["last_updated"]
-    est = DEBT_STATE["starting_debt"] + DEBT_STATE["rate_per_sec"] * elapsed
-    return jsonify({
-        "startingDebt": est,
-        "ratePerSecond": DEBT_STATE["rate_per_sec"]
-    })
+    elapsed = now - DEBT_STATE["record_time"]
+    current = DEBT_STATE["debt_at_record"] + DEBT_STATE["rate_per_sec"] * elapsed
+    return jsonify(
+        startingDebt   = current,
+        ratePerSecond  = DEBT_STATE["rate_per_sec"],
+        asOf           = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(now))
+    )
 
 @app.route("/api/ping")
-def ping():
-    return {"status": "ok", "time": time.strftime("%Y-%m-%d %H:%M:%S")}, 200
-
+def api_ping():
+    return {"status": "ok"}, 200
 
-# ─────── APP START ─────────────────────────
+# ─────────────────── main ────────────────────────────
 if __name__ == "__main__":
-    print("✅ Starting debt refresh thread...")
-    threading.Thread(target=refresh_debt_periodically, daemon=True).start()
-
     port = int(os.environ.get("PORT", 7860))
     app.run(host="0.0.0.0", port=port)