Delete app.py

app.py

@@ -1,354 +0,0 @@
-from __future__ import annotations
-
-import os
-import secrets
-from pathlib import Path
-from types import SimpleNamespace
-from typing import Any
-
-# ZeroGPU: import spaces before GPU-sensitive modules.
-try:
-    import spaces
-except ImportError:
-    class _SpacesFallback:
-        @staticmethod
-        def GPU(*args, **kwargs):
-            def deco(fn):
-                return fn
-            return deco
-    spaces = _SpacesFallback()
-
-import gradio as gr
-import uvicorn
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse, FileResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.middleware.sessions import SessionMiddleware
-
-from bh56_core import (
-    BH56_VERSION, STORE, LIVE_LOG, admin_auth, admin_role,
-    build_location, geocode_city, timezone_for_coordinates,
-)
-from bh56_ui import (
-    BASE_CSS,
-    PAGE_JS,
-    build_admin_ui,
-    clean_history,
-    prepare_message,
-    generate_answer,
-)
-from ac_frontend import ac_frontend_html, admin_login_html
-
-os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False")
-os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1")
-os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
-
-SESSION_SECRET = os.getenv("BH56_SESSION_SECRET", "") or secrets.token_urlsafe(48)
-
-app = FastAPI(
-    title=f"Artificial Chachma (AC) {BH56_VERSION}",
-    docs_url=None,
-    redoc_url=None,
-    openapi_url=None,
-)
-app.add_middleware(SessionMiddleware, secret_key=SESSION_SECRET, https_only=True, same_site="lax", max_age=1800)
-
-allowed_origins = [
-    x.strip() for x in os.getenv(
-        "BH56_CORS_ORIGINS",
-        "https://5bcheder.com,https://www.5bcheder.com",
-    ).split(",") if x.strip()
-]
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allowed_origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST"],
-    allow_headers=["Content-Type", "Authorization", "X-Requested-With"],
-)
-
-
-class SecurityHeadersMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        response = await call_next(request)
-        frame_ancestors = os.getenv(
-            "BH56_FRAME_ANCESTORS",
-            "'self' https://huggingface.co https://*.huggingface.co https://5bcheder.com https://www.5bcheder.com https://*.hf.space",
-        )
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
-        response.headers["Permissions-Policy"] = "geolocation=(self), microphone=(self), camera=()"
-        response.headers["Content-Security-Policy"] = f"frame-ancestors {frame_ancestors};"
-        response.headers["Cache-Control"] = "no-store" if request.url.path.startswith("/admin") else "private, max-age=0"
-        return response
-
-
-app.add_middleware(SecurityHeadersMiddleware)
-
-ICON_PATH = Path(__file__).with_name("ac_app_icon.png")
-
-
-@app.get("/ac_app_icon.png", include_in_schema=False)
-def ac_app_icon():
-    return FileResponse(str(ICON_PATH), media_type="image/png", headers={"Cache-Control":"public, max-age=86400"})
-
-
-@app.get("/health")
-def health():
-    return JSONResponse({
-        "ok": True,
-        "name": "Artificial Chachma (AC)",
-        "version": BH56_VERSION,
-        "persistent_storage": STORE.persistent_enabled,
-        "frontend": "custom-fixed-shell",
-    })
-
-
-def _session_id(request: Request) -> str:
-    sid = request.session.get("ac_sid")
-    if not isinstance(sid, str) or len(sid) < 12:
-        sid = secrets.token_urlsafe(16)
-        request.session["ac_sid"] = sid
-    return sid
-
-
-class ChatPayload(BaseModel):
-    message: str = Field(min_length=1, max_length=12000)
-    history: list[dict[str, Any]] = Field(default_factory=list)
-    mode: str = "Binah"
-    answer_length: str = "Normal"
-    study_mode: str = "Explain"
-    location: dict[str, Any] = Field(default_factory=dict)
-    announce_location: bool = False
-    location_attempted: bool = False
-
-
-class LocationSearchPayload(BaseModel):
-    query: str = Field(min_length=1, max_length=150)
-
-
-def _location_dict_from_payload(raw: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
-    """Turn a browser/manual location payload into server-side location state.
-
-    Exact browser coordinates are used only for this request. They are not added
-    to chat history, browser chat archives, LIVE_LOG, or the public response.
-    """
-    if not isinstance(raw, dict):
-        return {}, {}
-    source = str(raw.get("source") or "").strip().lower()
-    try:
-        lat = float(raw.get("latitude"))
-        lon = float(raw.get("longitude"))
-    except Exception:
-        return {}, {}
-    if not (-90 <= lat <= 90 and -180 <= lon <= 180):
-        return {}, {}
-
-    if source == "manual":
-        label = str(raw.get("label") or "").strip()[:220]
-        cc = str(raw.get("country_code") or "").strip().upper()[:3]
-        if not label:
-            return {}, {}
-        tz = timezone_for_coordinates(lat, lon)
-        loc = build_location(lat, lon, tz, "manual city", label, cc)
-        kind = "manual"
-    else:
-        browser_tz = str(raw.get("timezone") or "").strip()[:80]
-        try:
-            accuracy = max(0.0, float(raw.get("accuracy") or 999999))
-        except Exception:
-            accuracy = 999999.0
-        # Reduced-precision browser locations can be several kilometers wide.
-        # Do not describe them as exact.
-        method = "browser geolocation" if accuracy <= 1500 else "approximate browser geolocation"
-        loc = build_location(lat, lon, browser_tz, method)
-        kind = "exact" if loc.exact else "approximate"
-
-    if loc.latitude is None:
-        return {}, {}
-    state = {
-        "latitude": loc.latitude, "longitude": loc.longitude,
-        "timezone_name": loc.timezone_name, "label": loc.label,
-        "method": loc.method, "country_code": loc.country_code, "exact": loc.exact,
-    }
-    public = {"label": loc.label, "kind": kind, "method": loc.method}
-    return state, public
-
-
-@app.get("/", response_class=HTMLResponse, include_in_schema=False)
-def home():
-    return HTMLResponse(ac_frontend_html(is_admin=False))
-
-
-@app.post("/api/location/search", include_in_schema=False)
-def api_location_search(payload: LocationSearchPayload):
-    rows = geocode_city(payload.query)
-    # Manual locations are city/place-center coordinates, not a user's precise
-    # device coordinates, so returning them to the browser is safe and lets the
-    # selected city be reused locally.
-    return {
-        "results": [{
-            "label": str(r.get("label") or "")[:240],
-            "latitude": float(r.get("lat")),
-            "longitude": float(r.get("lon")),
-            "country_code": str(r.get("country_code") or "").upper()[:3],
-        } for r in rows[:6]]
-    }
-
-
-@app.post("/api/chat", include_in_schema=False)
-def api_chat(payload: ChatPayload, request: Request):
-    history = clean_history(payload.history)[-60:]
-    loc_dict, public_loc = _location_dict_from_payload(payload.location)
-    prepared, _, browser_history, _, _ = prepare_message(
-        payload.message,
-        history,
-        history,
-        "Saved",
-        loc_dict,
-    )
-    fake_request = SimpleNamespace(
-        session_hash=_session_id(request),
-        username="",
-    )
-    result = generate_answer(
-        prepared,
-        browser_history,
-        "Saved",
-        loc_dict,
-        payload.mode if payload.mode in {"Chachma", "Binah", "Daas"} else "Binah",
-        payload.answer_length if payload.answer_length in {"Short", "Normal", "Detailed"} else "Normal",
-        payload.study_mode if payload.study_mode in {"Explain", "Hint first", "Quiz me", "Study mode"} else "Explain",
-        fake_request,
-    )
-    new_history, _, _, status, details = result
-    cleaned = clean_history(new_history)
-
-    # The first local answer tells the student what AC is using without ever
-    # exposing coordinates. If it looks wrong, Manual Location is one click away.
-    if payload.announce_location and public_loc and cleaned and cleaned[-1].get("role") == "assistant":
-        label = str(public_loc.get("label") or "Location")
-        kind = str(public_loc.get("kind") or "approximate")
-        if kind == "exact":
-            lead = f"📍 **Exact location: {label}.**"
-        elif kind == "manual":
-            lead = f"📍 **Manual location: {label}.**"
-        else:
-            lead = f"📍 **Approximate location: {label}.**"
-        lead += " If this isn't correct, use **Manual Location** in the sidebar."
-        cleaned[-1]["content"] = lead + "\n\n" + str(cleaned[-1].get("content") or "")
-
-    return {
-        "history": cleaned,
-        "status": str(status or ""),
-        "details": str(details or ""),
-        "location": public_loc,
-        "location_attempted": bool(payload.location_attempted),
-    }
-
-
-class AdminLoginPayload(BaseModel):
-    username: str = Field(min_length=1, max_length=120)
-    password: str = Field(min_length=1, max_length=300)
-
-
-@app.post("/api/admin/login", include_in_schema=False)
-def admin_login(payload: AdminLoginPayload, request: Request):
-    if not admin_auth(payload.username, payload.password):
-        raise HTTPException(status_code=401, detail="Incorrect username or password.")
-    request.session["admin_user"] = payload.username.strip()
-    return {"ok": True}
-
-
-def _admin_from_session(request: Request) -> tuple[str, str]:
-    user = str(request.session.get("admin_user") or "")
-    role = admin_role(user)
-    if role not in {"main", "admin"}:
-        request.session.pop("admin_user", None)
-        raise HTTPException(status_code=401, detail="Admin authentication required.")
-    return user, role
-
-
-@app.get("/admin", response_class=HTMLResponse, include_in_schema=False)
-def admin_home(request: Request):
-    try:
-        user, role = _admin_from_session(request)
-    except HTTPException:
-        return HTMLResponse(admin_login_html())
-    return HTMLResponse(ac_frontend_html(is_admin=True, username=user, role=role))
-
-
-@app.get("/api/admin/dashboard", include_in_schema=False)
-def api_admin_dashboard(request: Request):
-    user, role = _admin_from_session(request)
-    cfg = STORE.config()
-    live = LIVE_LOG.snapshot(100)
-    return {
-        "user": user,
-        "role": "Head Admin" if role == "main" else "Admin",
-        "version": BH56_VERSION,
-        "live_requests": len(live),
-        "emergency_pause": bool(cfg.get("paused")),
-        "persistent_storage": bool(STORE.persistent_enabled),
-    }
-
-
-@app.get("/api/admin/chats", include_in_schema=False)
-def api_admin_chats(request: Request):
-    user, role = _admin_from_session(request)
-    rows = LIVE_LOG.snapshot(200)
-    if role != "main":
-        rows = [r for r in rows if r.get("role", "student") == "student"]
-    rows = list(reversed(rows[-100:]))
-    return {
-        "chats": [{
-            "time": r.get("time", ""),
-            "session": r.get("session", ""),
-            "role": r.get("role", "student"),
-            "mode": r.get("mode", ""),
-            "user": r.get("user", ""),
-            "response": r.get("response", ""),
-        } for r in rows]
-    }
-
-
-@app.post("/api/admin/logout", include_in_schema=False)
-def api_admin_logout(request: Request):
-    request.session.pop("admin_user", None)
-    return {"ok": True}
-
-
-# Keep the existing full Gradio admin console available for advanced controls.
-# It is NOT the visible student/admin shell, so its page sizing cannot make the
-# Hugging Face App tab grow.
-admin_ui = build_admin_ui()
-app = gr.mount_gradio_app(
-    app,
-    admin_ui,
-    path="/admin-console",
-    auth=admin_auth,
-    auth_message="AC Admin — authorized administrators only.",
-    footer_links=[],
-    show_error=False,
-    max_file_size="25mb",
-    enable_monitoring=False,
-    mcp_server=False,
-    ssr_mode=False,
-    pwa=False,
-    theme=gr.themes.Base(),
-    css=BASE_CSS,
-    js=PAGE_JS,
-)
-
-try:
-    import spaces.zero as _spaces_zero
-    if hasattr(_spaces_zero, "startup"):
-        _spaces_zero.startup()
-except Exception as exc:
-    print(f"[AC ZeroGPU] startup report note: {exc}")
-
-if __name__ == "__main__":
-    port = int(os.getenv("GRADIO_SERVER_PORT", os.getenv("PORT", "7860")))
-    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")