Upload 4 files

main.py

@@ -1,25 +1,16 @@
 # main.py
-import os, json, base64, requests, traceback
+import json, traceback
 import pandas as pd
 import numpy as np
 import io, tempfile, textwrap
 import statsmodels.api as sm
 
-from fastapi import FastAPI, HTTPException, Body, Header, Depends, UploadFile, File, Form, Response, status, Request
+from fastapi import FastAPI, HTTPException, Body, UploadFile, File, Form, Response, status, Request
 from fastapi.responses import FileResponse, PlainTextResponse, ORJSONResponse
 from fastapi.concurrency import run_in_threadpool
 from datetime import datetime
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
-from starlette.middleware.base import BaseHTTPMiddleware
-import time
-
-# ---------- Server-side config ----------
-GITHUB_OWNER = "datfid-valeriidashuk"
-GITHUB_REPO  = "datfid-hf"
-USAGE_PATH   = "hf_usage.json"  # <— add this
-BRANCH       = "main"
-GITHUB_PAT   = os.environ.get("Github_key")  # must have Contents: Read & Write
 
 # Predefined globals
 stored_model = None
@@ -244,164 +235,6 @@ class DATFIDModel:
         out["forecast"] = out[f"{self.y}_forecast"]
         return out
 
-def _gh_get(path: str):
-    url = f"https://api.github.com/repos/{GITHUB_OWNER}/{GITHUB_REPO}/contents/{path}?ref={BRANCH}"
-    headers = {
-        "Authorization": f"Bearer {GITHUB_PAT}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-    r = requests.get(url, headers=headers, timeout=15)
-    if r.status_code == 404:
-        return None, None  # file not found
-    if r.status_code != 200:
-        raise HTTPException(status_code=502, detail=f"GitHub GET {path} failed")
-    data = r.json()
-    content = base64.b64decode(data["content"]).decode("utf-8")
-    sha = data["sha"]
-    return content, sha
-
-def _gh_put(path: str, text: str, *, sha: Optional[str], message: str):
-    url = f"https://api.github.com/repos/{GITHUB_OWNER}/{GITHUB_REPO}/contents/{path}"
-    headers = {
-        "Authorization": f"Bearer {GITHUB_PAT}",
-        "Accept": "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-    payload = {
-        "message": message,
-        "content": base64.b64encode(text.encode("utf-8")).decode("utf-8"),
-        "branch": BRANCH,
-    }
-    if sha:
-        payload["sha"] = sha
-    r = requests.put(url, headers=headers, json=payload, timeout=20)
-    if r.status_code in (200, 201):
-        return r.json()["content"]["sha"]
-    # surface conflict so we can retry
-    if r.status_code in (409, 422):
-        raise RuntimeError("GITHUB_CONFLICT")
-    raise HTTPException(status_code=502, detail=f"GitHub PUT {path} failed")
-
-def _today() -> str:
-    """Return current date as YYYY-MM-DD."""
-    return datetime.utcnow().strftime("%Y-%m-%d")
-
-def _bucket(nbytes: Optional[int]) -> str:
-    """Categorize byte size into buckets."""
-    if not isinstance(nbytes, int):
-        return "<1MB"
-    if nbytes < 1_000_000:
-        return "<1MB"
-    if nbytes < 10_000_000:
-        return "1-10MB"
-    return ">10MB"
-
-def _new_day_bucket():
-    """Create a new day bucket with all metrics initialized."""
-    return {
-        "calls": 0,
-        "ok_2xx": 0,
-        "client_4xx": 0,
-        "server_5xx": 0,
-        "total_duration_ms": 0,
-        "req_size_bucket": {"<1MB": 0, "1-10MB": 0, ">10MB": 0},
-        "resp_size_bucket": {"<1MB": 0, "1-10MB": 0, ">10MB": 0},
-    }
-
-def bump_usage(user_id: str, endpoint: str, max_retries: int = 5, 
-                status_code: Optional[int] = None, duration_ms: Optional[int] = None,
-                req_bytes: Optional[int] = None, resp_bytes: Optional[int] = None):
-    """
-    Increment usage counters in hf_usage.json with optimistic concurrency.
-    Now supports extended metrics: status codes, duration, request/response sizes.
-    """
-    yyyymm = datetime.utcnow().strftime("%Y-%m")
-    yyyymmdd = _today()
-
-    attempt = 0
-    while True:
-        attempt += 1
-        # read current usage (or create)
-        txt, sha = _gh_get(USAGE_PATH)
-        if txt is None:
-            usage = {}
-            sha = None
-        else:
-            try:
-                usage = json.loads(txt) if txt.strip() else {}
-            except Exception:
-                # corrupt file -> start fresh but do not lose the old SHA reference
-                usage = {}
-
-        # Get or create user record
-        rec = usage.get(user_id) or {
-            "total": 0,
-            "by_month": {},
-            "by_endpoint": {},
-            "by_endpoint_month": {},
-            "updated_at": None,
-        }
-
-        # Initialize endpoints structure if not present
-        if "endpoints" not in rec:
-            rec["endpoints"] = {}
-
-        # Get or create endpoint record
-        ep_rec = rec["endpoints"].get(endpoint) or {
-            "total": 0,
-        }
-
-        # Get or create day bucket for this endpoint
-        if yyyymmdd not in ep_rec:
-            ep_rec[yyyymmdd] = _new_day_bucket()
-
-        day_bucket = ep_rec[yyyymmdd]
-
-        # Increment basic counters
-        rec["total"] = int(rec.get("total", 0)) + 1
-        rec["by_month"][yyyymm] = int(rec["by_month"].get(yyyymm, 0)) + 1
-        rec["by_endpoint"][endpoint] = int(rec["by_endpoint"].get(endpoint, 0)) + 1
-        key_ep_month = f"{yyyymm}:{endpoint}"
-        rec["by_endpoint_month"][key_ep_month] = int(rec["by_endpoint_month"].get(key_ep_month, 0)) + 1
-        rec["updated_at"] = datetime.utcnow().isoformat() + "Z"
-
-        # Increment endpoint-level counters
-        ep_rec["total"] = int(ep_rec.get("total", 0)) + 1
-
-        # Increment extended metrics if provided
-        day_bucket["calls"] += 1
-        if status_code is not None:
-            if 200 <= status_code < 300:
-                day_bucket["ok_2xx"] += 1
-            elif 400 <= status_code < 500:
-                day_bucket["client_4xx"] += 1
-            elif 500 <= status_code < 600:
-                day_bucket["server_5xx"] += 1
-        if duration_ms is not None:
-            day_bucket["total_duration_ms"] += duration_ms
-        if req_bytes is not None:
-            day_bucket["req_size_bucket"][_bucket(req_bytes)] += 1
-        if resp_bytes is not None:
-            day_bucket["resp_size_bucket"][_bucket(resp_bytes)] += 1
-
-        # Update nested structures
-        ep_rec[yyyymmdd] = day_bucket
-        rec["endpoints"][endpoint] = ep_rec
-        usage[user_id] = rec
-
-        new_txt = json.dumps(usage, ensure_ascii = False, indent = 2, sort_keys = True) + "\n"
-        try:
-            _gh_put(USAGE_PATH, new_txt, sha=sha, message=f"usage: +1 {user_id} {endpoint} {yyyymmdd}")
-            return
-        except RuntimeError as e:
-            # conflict -> backoff & retry
-            if str(e) == "GITHUB_CONFLICT" and attempt < max_retries:
-                import time as _t
-                _t.sleep(0.25 * attempt)
-                continue
-            raise
-
 def _maybe_json_list(s: Optional[str]):
     if s is None or s == "":
         return []
@@ -572,79 +405,12 @@ def _result_to_text(result_obj: Any) -> str:
 # ---------- FastAPI app ----------
 app = FastAPI(
     title="DATFID API",
-    description="Public demo API (no token auth)",
+    description="Public demo API",
     docs_url="/docs",
     redoc_url=None,
     default_response_class=ORJSONResponse,
 )
 
-# ---------- Metrics Middleware ----------
-class UsageMetricsMiddleware(BaseHTTPMiddleware):
-    """Middleware to capture extended usage metrics and call bump_usage with full context."""
-    
-    async def dispatch(self, request: Request, call_next):
-        # Capture start time
-        t0 = time.time()
-        
-        # Get request size
-        req_bytes = None
-        try:
-            cl = request.headers.get("content-length")
-            if cl:
-                req_bytes = int(cl)
-        except Exception:
-            pass
-        
-        # Process request (this will execute dependencies and handlers)
-        response = await call_next(request)
-        
-        # After handler execution, check if this request was metered
-        # (dependencies set request.state during handler execution)
-        has_metered = hasattr(request.state, "metered_user_id") and hasattr(request.state, "metered_endpoint")
-        
-        if not has_metered:
-            # Not a metered endpoint, just return response
-            return response
-        
-        # Calculate duration
-        duration_ms = int((time.time() - t0) * 1000)
-        
-        # Get response size
-        resp_bytes = None
-        try:
-            rcl = response.headers.get("content-length")
-            if rcl:
-                resp_bytes = int(rcl)
-        except Exception:
-            pass
-        
-        # Get status code
-        status_code = getattr(response, "status_code", None)
-        
-        # Call bump_usage with extended metrics (non-blocking)
-        # In fully public mode without Github_key, skip persistence silently.
-        if not GITHUB_PAT:
-            return response
-        try:
-            user_id = request.state.metered_user_id
-            endpoint = request.state.metered_endpoint
-            bump_usage(
-                user_id=user_id,
-                endpoint=endpoint,
-                status_code=status_code,
-                duration_ms=duration_ms,
-                req_bytes=req_bytes,
-                resp_bytes=resp_bytes,
-            )
-        except Exception:
-            # Never break the request due to metrics failure
-            traceback.print_exc()
-        
-        return response
-
-# Register middleware
-app.add_middleware(UsageMetricsMiddleware)
-
 # In-memory model state
 @dataclass
 class ModelSlot:
@@ -665,24 +431,9 @@ def root():
 def secure_ping():
     return {"ok": True}
 
-# Reusable dependency for protected routes
-def require_valid_token(x_api_key: Optional[str] = Header(None)) -> str:
-    return x_api_key or ""
-
-def metered(endpoint_name: str):
-    """Public dependency: no auth, keeps endpoint metrics labels."""
-    async def _dep(request: Request, x_api_key: Optional[str] = Header(None)) -> str:
-        user_id = "public"
-        # Store in request state for middleware to use
-        request.state.metered_user_id = user_id
-        request.state.metered_endpoint = endpoint_name
-        return x_api_key or ""
-    return _dep
-
 # ---------- Model endpoints (guarded) ----------
 @app.post("/modelfit/")
 async def modelfit(
-    _: str = Depends(metered("modelfit")),
     df: List[Dict] = Body(...),
     id_col: str = Body(...),
     time_col: str = Body(...),
@@ -738,7 +489,6 @@ async def modelfit(
 
 @app.post("/modelforecast/")
 async def modelforecast(
-    _: str = Depends(metered("modelforecast")),
     df_forecast: List[Dict] = Body(...),
 ):
     global stored_model, stored_result_join
@@ -754,7 +504,6 @@ async def modelforecast(
 
 @app.post("/modelfit-file/")
 async def modelfit_file(
-    _: str = Depends(metered("modelfit-file")),
     file: UploadFile = File(...),
     id_col: str = Form(...),
     time_col: str = Form(...),
@@ -823,7 +572,6 @@ async def modelfit_file(
     
 @app.post("/modelforecast-file/")
 async def modelforecast_file(
-    _: str = Depends(metered("modelforecast-file")),
     df_forecast: UploadFile = File(...),
 ):
     global stored_model, stored_result_join
@@ -870,7 +618,6 @@ async def modelforecast_file(
     
 @app.post("/modelfit_ind/")
 async def modelfit_ind(
-    _: str = Depends(metered("modelfit_ind")),
     df: List[Dict] = Body(...),
     id_col: str = Body(...),
     time_col: str = Body(...),
@@ -936,7 +683,6 @@ async def modelfit_ind(
 
 @app.post("/modelforecast_ind/")
 async def modelforecast_ind(
-    _: str = Depends(metered("modelforecast_ind")),
     df_forecast: List[Dict] = Body(...),
 ):
     # Use per-ID models created by /modelfit_ind/
@@ -986,7 +732,6 @@ async def modelforecast_ind(
 
 @app.post("/modelfit-file_ind/")
 async def modelfit_file_ind(
-    _: str = Depends(metered("modelfit-file_ind")),
     file: UploadFile = File(...),
     id_col: str = Form(...),
     time_col: str = Form(...),
@@ -1066,7 +811,6 @@ async def modelfit_file_ind(
 
 @app.post("/modelforecast-file_ind/")
 async def modelforecast_file_ind(
-    _: str = Depends(metered("modelforecast-file_ind")),
     df_forecast: UploadFile = File(...),
 ):
     global model_store