Update app.py

app.py

@@ -1,24 +1,3 @@
-"""
-Flask + SQLite Telemetry Server  v2.0
-ESP32 (INA219 + Potentiometer) → Flask API → SQLite DB → Dashboard
-
-Install:  pip install flask flask-cors
-Run:      python server.py
-Dashboard: http://localhost:8000
-
-DB file:  telemetry.db  (auto-created on first run)
-
-POST /api/telemetry  ← ESP32 यहाँ data भेजता है
-GET  /api/latest     ← latest 1 record
-GET  /api/history    ← last N records + stats
-GET  /api/track      ← position + speed only (lightweight)
-GET  /api/stats      ← session summary + energy
-GET  /api/devices    ← all registered devices
-GET  /api/export     ← CSV download
-DELETE /api/clear    ← data clear
-GET  /health         ← server health check
-"""
-
 from flask import Flask, request, jsonify, send_file, g, Response
 from flask_cors import CORS
 from datetime import datetime
@@ -28,22 +7,22 @@ import os
 import csv
 import io
 
-# ─── CONFIG ──────────────────────────────────────────────────
-HOST    = "0.0.0.0"
-PORT    = 7860
-DB_PATH = os.path.join(os.path.dirname(__file__), "telemetry.db")
+# ─── CONFIG ───────────────────────────────────────────
+HOST = "0.0.0.0"
+PORT = 7860
+
+BASE_DIR = os.path.dirname(__file__)
+DB_PATH = os.path.join(BASE_DIR, "telemetry.db")
 
 app = Flask(__name__)
 CORS(app)
 
-# ─── DATABASE ─────────────────────────────────────────────────
+# ─── DATABASE ─────────────────────────────────────────
 
 def get_db():
     if "db" not in g:
-        g.db = sqlite3.connect(DB_PATH, detect_types=sqlite3.PARSE_DECLTYPES)
+        g.db = sqlite3.connect(DB_PATH)
         g.db.row_factory = sqlite3.Row
-        g.db.execute("PRAGMA journal_mode=WAL")
-        g.db.execute("PRAGMA synchronous=NORMAL")
     return g.db
 
 
@@ -56,336 +35,171 @@ def close_db(exc=None):
 
 def init_db():
     with sqlite3.connect(DB_PATH) as db:
-        db.execute("PRAGMA journal_mode=WAL")
-        db.execute("""
-            CREATE TABLE IF NOT EXISTS telemetry (
-                id             INTEGER PRIMARY KEY AUTOINCREMENT,
-                device_id      TEXT    NOT NULL,
-                server_time    TEXT    NOT NULL,
-                server_unix    REAL    NOT NULL,
-                uptime_sec     INTEGER DEFAULT 0,
-
-                -- Motion
-                speed_pct      REAL    NOT NULL,
-                speed_ups      REAL    NOT NULL,
-                pos_x          REAL    NOT NULL,
-                pos_y          REAL    NOT NULL DEFAULT 0,
-                pos_z          REAL    NOT NULL DEFAULT 0,
-                total_distance REAL    NOT NULL,
-
-                -- Power (from INA219)
-                voltage_V      REAL    NOT NULL,
-                current_mA     REAL    NOT NULL,
-                current_A      REAL    NOT NULL,
-                power_mW       REAL    NOT NULL,
-                power_W        REAL    NOT NULL,
-                drawn_mW       REAL    NOT NULL DEFAULT 0,
-                generated_mW   REAL    NOT NULL DEFAULT 0,
-                samples        INTEGER NOT NULL DEFAULT 25,
-                interval_sec   INTEGER NOT NULL DEFAULT 5
-            )
-        """)
         db.execute("""
-            CREATE INDEX IF NOT EXISTS idx_device_time
-            ON telemetry (device_id, server_unix DESC)
+        CREATE TABLE IF NOT EXISTS telemetry (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            device_id TEXT,
+            server_time TEXT,
+            server_unix REAL,
+            uptime_sec INTEGER,
+
+            speed_pct REAL,
+            speed_ups REAL,
+
+            pos_x REAL,
+            pos_y REAL,
+            pos_z REAL,
+            total_distance REAL,
+
+            voltage_V REAL,
+            current_mA REAL,
+            current_A REAL,
+            power_mW REAL,
+            power_W REAL,
+            drawn_mW REAL,
+            generated_mW REAL,
+
+            samples INTEGER,
+            interval_sec INTEGER
+        )
         """)
         db.commit()
-    print(f"[DB] SQLite ready → {DB_PATH}")
+
+    print("Database initialized")
 
 
-def row_to_dict(row):
-    return dict(row)
+# 🔴 IMPORTANT FIX (Gunicorn compatible)
+with app.app_context():
+    init_db()
 
 
-# ─── HELPERS ──────────────────────────────────────────────────
+# ─── HELPERS ─────────────────────────────────────────
 
 def query(sql, params=(), one=False):
     cur = get_db().execute(sql, params)
     rows = cur.fetchall()
-    result = [row_to_dict(r) for r in rows]
-    return result[0] if (one and result) else (None if one else result)
+    data = [dict(r) for r in rows]
+    return (data[0] if data else None) if one else data
 
 
-def compute_stats(rows):
-    if not rows:
-        return {}
-    n = len(rows)
-    return {
-        "speed_avg_pct":  round(sum(r["speed_pct"]  for r in rows) / n, 2),
-        "speed_max_pct":  round(max(r["speed_pct"]  for r in rows), 2),
-        "power_avg_mW":   round(sum(r["power_mW"]   for r in rows) / n, 2),
-        "power_max_mW":   round(max(r["power_mW"]   for r in rows), 2),
-        "voltage_avg_V":  round(sum(r["voltage_V"]  for r in rows) / n, 3),
-        "pos_x_latest":   round(rows[-1]["pos_x"], 3),
-        "pos_x_range":    round(
-            max(r["pos_x"] for r in rows) - min(r["pos_x"] for r in rows), 3
-        ),
-    }
-
-
-def safe_float(data, key, default=0.0):
-    """Safely extract float from dict, return default if missing/invalid."""
+def safe_float(data, key, default=0):
     try:
         return float(data.get(key, default))
-    except (TypeError, ValueError):
+    except:
         return default
 
 
-# ─── ROUTES ───────────────────────────────────────────────────
+# ─── ROUTES ─────────────────────────────────────────
 
-@app.post("/api/telemetry")
-def receive_telemetry():
-    """
-    ESP32 POSTs JSON here every interval.
-
-    Required body:
-    {
-      "device_id"     : "esp32-tracker-01",
-      "uptime_sec"    : 120,                     ← optional (default 0)
-      "speed_pct"     : 73.4,                    ← 0–100
-      "speed_ups"     : 7.34,                    ← speed_pct / 10
-      "position"      : { "x": 182.5, "y": 0, "z": 0 },
-      "total_distance": 182.5,
-      "power": {
-        "voltage_V"    : 3.712,
-        "current_mA"   : 245.6,
-        "current_A"    : 0.2456,
-        "power_mW"     : 912.5,
-        "power_W"      : 0.9125,
-        "drawn_mW"     : 912.5,
-        "generated_mW" : 0.0,
-        "samples"      : 25,
-        "interval_sec" : 5
-      }
-    }
-    """
-    data = request.get_json(force=True, silent=True)
-    if not data:
-        return jsonify({"error": "Invalid JSON"}), 400
 
-    # Required fields validation
-    required = ["device_id", "speed_pct", "speed_ups", "position", "total_distance", "power"]
-    missing = [k for k in required if k not in data]
-    if missing:
-        return jsonify({"error": f"Missing fields: {missing}"}), 400
+@app.post("/api/telemetry")
+def receive():
+    data = request.get_json()
 
-    pos = data["position"]
-    pwr = data["power"]
+    if not data:
+        return jsonify({"error": "invalid json"}), 400
 
-    # Required power fields
-    required_pwr = ["voltage_V", "current_mA", "current_A", "power_mW", "power_W"]
-    missing_pwr = [k for k in required_pwr if k not in pwr]
-    if missing_pwr:
-        return jsonify({"error": f"Missing power fields: {missing_pwr}"}), 400
+    pos = data.get("position", {})
+    pwr = data.get("power", {})
 
-    now         = datetime.now()
-    server_time = now.isoformat(timespec="milliseconds")
+    now = datetime.now()
+    server_time = now.isoformat()
     server_unix = time.time()
 
     db = get_db()
+
     db.execute("""
-        INSERT INTO telemetry (
-            device_id, server_time, server_unix, uptime_sec,
-            speed_pct, speed_ups,
-            pos_x, pos_y, pos_z, total_distance,
-            voltage_V, current_mA, current_A,
-            power_mW, power_W, drawn_mW, generated_mW,
-            samples, interval_sec
-        ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+    INSERT INTO telemetry (
+        device_id, server_time, server_unix, uptime_sec,
+        speed_pct, speed_ups,
+        pos_x, pos_y, pos_z, total_distance,
+        voltage_V, current_mA, current_A,
+        power_mW, power_W, drawn_mW, generated_mW,
+        samples, interval_sec
+    )
+    VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
     """, (
-        data["device_id"],
+        data.get("device_id"),
         server_time,
         server_unix,
         data.get("uptime_sec", 0),
-        float(data["speed_pct"]),
-        float(data["speed_ups"]),
+
+        data.get("speed_pct", 0),
+        data.get("speed_ups", 0),
+
         safe_float(pos, "x"),
         safe_float(pos, "y"),
         safe_float(pos, "z"),
-        float(data["total_distance"]),
-        float(pwr["voltage_V"]),
-        float(pwr["current_mA"]),
-        float(pwr["current_A"]),
-        float(pwr["power_mW"]),
-        float(pwr["power_W"]),
-        safe_float(pwr, "drawn_mW"),
-        safe_float(pwr, "generated_mW"),
-        int(pwr.get("samples", 25)),
-        int(pwr.get("interval_sec", 5)),
+        data.get("total_distance", 0),
+
+        pwr.get("voltage_V", 0),
+        pwr.get("current_mA", 0),
+        pwr.get("current_A", 0),
+        pwr.get("power_mW", 0),
+        pwr.get("power_W", 0),
+        pwr.get("drawn_mW", 0),
+        pwr.get("generated_mW", 0),
+
+        pwr.get("samples", 25),
+        pwr.get("interval_sec", 5),
     ))
-    db.commit()
 
-    print(
-        f"[{server_time[:19]}] {data['device_id']} | "
-        f"Spd={float(data['speed_pct']):.1f}% | "
-        f"X={safe_float(pos,'x'):.3f} | "
-        f"V={float(pwr['voltage_V']):.3f}V | "
-        f"P={float(pwr['power_mW']):.2f}mW"
-    )
+    db.commit()
 
-    return jsonify({"status": "ok", "server_time": server_time}), 201
+    return jsonify({"status": "ok"})
 
 
 @app.get("/api/latest")
-def get_latest():
-    device_id = request.args.get("device_id")
-    if device_id:
-        row = query(
-            "SELECT * FROM telemetry WHERE device_id=? ORDER BY server_unix DESC LIMIT 1",
-            (device_id,), one=True
-        )
-    else:
-        row = query(
-            "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT 1",
-            one=True
-        )
+def latest():
+    row = query(
+        "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT 1",
+        one=True
+    )
 
     if not row:
-        return jsonify({"error": "No data yet"}), 404
+        return jsonify({"error": "no data"}), 404
 
-    total = query("SELECT COUNT(*) AS n FROM telemetry", one=True)["n"]
-    return jsonify({"latest": row, "total_stored": total})
+    return jsonify(row)
 
 
 @app.get("/api/history")
-def get_history():
-    limit     = min(int(request.args.get("limit", 200)), 1000)  # max 1000
-    device_id = request.args.get("device_id")
-
-    if device_id:
-        rows = query(
-            "SELECT * FROM telemetry WHERE device_id=? ORDER BY server_unix DESC LIMIT ?",
-            (device_id, limit)
-        )
-    else:
-        rows = query(
-            "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT ?",
-            (limit,)
-        )
-
-    rows = list(reversed(rows))
-    return jsonify({
-        "readings": rows,
-        "count":    len(rows),
-        "stats":    compute_stats(rows),
-    })
-
-
-@app.get("/api/track")
-def get_track():
-    """Position + speed only — lightweight for real-time visualization."""
-    limit     = min(int(request.args.get("limit", 500)), 2000)
-    device_id = request.args.get("device_id")
+def history():
+    limit = int(request.args.get("limit", 100))
 
-    if device_id:
-        rows = query(
-            "SELECT server_unix, pos_x, pos_y, speed_pct FROM telemetry "
-            "WHERE device_id=? ORDER BY server_unix DESC LIMIT ?",
-            (device_id, limit)
-        )
-    else:
-        rows = query(
-            "SELECT server_unix, pos_x, pos_y, speed_pct FROM telemetry "
-            "ORDER BY server_unix DESC LIMIT ?",
-            (limit,)
-        )
-
-    rows = list(reversed(rows))
-    track = [{
-        "t":   r["server_unix"],
-        "x":   r["pos_x"],
-        "y":   r["pos_y"],
-        "spd": r["speed_pct"]
-    } for r in rows]
-    return jsonify({"track": track, "points": len(track)})
-
-
-@app.get("/api/stats")
-def get_stats():
-    """Full session summary with energy calculation."""
-    device_id = request.args.get("device_id")
-
-    if device_id:
-        rows = query(
-            "SELECT * FROM telemetry WHERE device_id=? ORDER BY server_unix ASC",
-            (device_id,)
-        )
-    else:
-        rows = query("SELECT * FROM telemetry ORDER BY server_unix ASC")
-
-    if not rows:
-        return jsonify({"error": "No data"}), 404
-
-    n        = len(rows)
-    interval = rows[-1]["interval_sec"] or 5
-    total_h  = (n * interval) / 3600.0
-    energy_mWh = sum(r["power_mW"] for r in rows) * (interval / 3600.0)
+    rows = query(
+        "SELECT * FROM telemetry ORDER BY server_unix DESC LIMIT ?",
+        (limit,)
+    )
 
     return jsonify({
-        "total_packets":      n,
-        "total_time_minutes": round(total_h * 60, 2),
-        "device_id":          rows[-1]["device_id"],
-        "speed": {
-            "avg_pct": round(sum(r["speed_pct"] for r in rows) / n, 2),
-            "max_pct": round(max(r["speed_pct"] for r in rows), 2),
-            "avg_ups": round(sum(r["speed_ups"] for r in rows) / n, 3),
-        },
-        "position": {
-            "current_x":      round(rows[-1]["pos_x"], 3),
-            "total_distance": round(rows[-1]["total_distance"], 3),
-        },
-        "power": {
-            "voltage_avg_V":    round(sum(r["voltage_V"]  for r in rows) / n, 3),
-            "current_avg_mA":   round(sum(r["current_mA"] for r in rows) / n, 2),
-            "power_avg_mW":     round(sum(r["power_mW"]   for r in rows) / n, 2),
-            "power_max_mW":     round(max(r["power_mW"]   for r in rows), 2),
-            "total_energy_mWh": round(energy_mWh, 4),
-            "drawn_total_mWh":  round(
-                sum(r["drawn_mW"] for r in rows) * (interval / 3600.0), 4
-            ),
-        },
-        "first_packet": rows[0]["server_time"],
-        "last_packet":  rows[-1]["server_time"],
+        "count": len(rows),
+        "data": list(reversed(rows))
     })
 
 
 @app.get("/api/devices")
-def get_devices():
-    """List all devices with last-seen info and packet count."""
+def devices():
     rows = query("""
-        SELECT device_id,
-               COUNT(*)          AS total_packets,
-               MAX(server_time)  AS last_seen,
-               MAX(pos_x)        AS max_x,
-               MAX(speed_pct)    AS max_speed,
-               AVG(voltage_V)    AS avg_voltage,
-               AVG(power_mW)     AS avg_power
-        FROM telemetry
-        GROUP BY device_id
+    SELECT device_id,
+           COUNT(*) as packets,
+           MAX(server_time) as last_seen
+    FROM telemetry
+    GROUP BY device_id
     """)
-    devices = {r["device_id"]: r for r in rows}
-    return jsonify({"devices": devices, "count": len(devices)})
+
+    return jsonify(rows)
 
 
 @app.get("/api/export")
 def export_csv():
-    """Download all data as CSV."""
-    device_id = request.args.get("device_id")
 
-    if device_id:
-        rows = query(
-            "SELECT * FROM telemetry WHERE device_id=? ORDER BY server_unix ASC",
-            (device_id,)
-        )
-        filename = f"telemetry_{device_id}.csv"
-    else:
-        rows = query("SELECT * FROM telemetry ORDER BY server_unix ASC")
-        filename = "telemetry_all.csv"
+    rows = query("SELECT * FROM telemetry")
 
     if not rows:
-        return jsonify({"error": "No data"}), 404
+        return jsonify({"error": "no data"}), 404
 
     out = io.StringIO()
+
     writer = csv.DictWriter(out, fieldnames=rows[0].keys())
     writer.writeheader()
     writer.writerows(rows)
@@ -393,47 +207,40 @@ def export_csv():
     return Response(
         out.getvalue(),
         mimetype="text/csv",
-        headers={"Content-Disposition": f"attachment; filename={filename}"}
+        headers={"Content-Disposition": "attachment; filename=telemetry.csv"}
     )
 
 
 @app.delete("/api/clear")
-def clear_data():
-    """Delete all records (or by device_id)."""
-    device_id = request.args.get("device_id")
+def clear():
+
     db = get_db()
-    if device_id:
-        db.execute("DELETE FROM telemetry WHERE device_id=?", (device_id,))
-        msg = f"Cleared data for '{device_id}'"
-    else:
-        db.execute("DELETE FROM telemetry")
-        msg = "All data cleared"
+    db.execute("DELETE FROM telemetry")
     db.commit()
-    return jsonify({"status": "ok", "message": msg})
+
+    return jsonify({"status": "cleared"})
 
 
 @app.get("/health")
 def health():
-    row = query("SELECT COUNT(*) AS n FROM telemetry", one=True)
+
+    row = query("SELECT COUNT(*) as n FROM telemetry", one=True)
+
     return jsonify({
-        "status":        "ok",
-        "db":            DB_PATH,
-        "total_records": row["n"] if row else 0,
-        "server_time":   datetime.now().isoformat(timespec="milliseconds"),
+        "status": "ok",
+        "records": row["n"] if row else 0,
+        "db": DB_PATH,
+        "time": datetime.now().isoformat()
     })
 
 
 @app.get("/")
 def dashboard():
-    html_path = os.path.join(os.path.dirname(__file__), "dashboard.html")
-    return send_file(html_path)
+    return send_file(os.path.join(BASE_DIR, "dashboard.html"))
 
 
-# ─── MAIN ─────────────────────────────────────────────────────
+# ─── LOCAL RUN ───────────────────────────────────────
+
 if __name__ == "__main__":
-    init_db()
-    print(f"\n[SERVER] Flask running  → http://{HOST}:{PORT}")
-    print(f"[SERVER] Dashboard      → http://localhost:{PORT}")
-    print(f"[SERVER] API telemetry  → POST http://localhost:{PORT}/api/telemetry")
-    print(f"[SERVER] DB path        → {DB_PATH}\n")
-    app.run(host=HOST, port=PORT, debug=True)
+    print("Server running at http://localhost:7860")
+    app.run(host=HOST, port=PORT)