Update app.py

app.py

@@ -1,118 +1,53 @@
-from fastapi import FastAPI,Query
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
-import os
-from pydantic import BaseModel
-from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, Request, Form
 from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
-
-
-# ✅ Force Hugging Face cache to /tmp (writable in Spaces)
-os.environ["HF_HOME"] = "/tmp"
-os.environ["TRANSFORMERS_CACHE"] = "/tmp"
-
-
-# ✅ Base + Adapter
-from peft import PeftModel
-
-base_model_id = "microsoft/DialoGPT-small"
-adapter_id = "rabiyulfahim/Python_coding_model"
-
-tokenizer = AutoTokenizer.from_pretrained(base_model_id, cache_dir="/tmp")
-base_model = AutoModelForCausalLM.from_pretrained(base_model_id, cache_dir="/tmp")
-model = PeftModel.from_pretrained(base_model, adapter_id, cache_dir="/tmp")
-
-
-
-
-app = FastAPI(title="QA GPT2 API UI", description="Serving HuggingFace model with FastAPI")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-# Request schema
-class QueryRequest(BaseModel):
-    question: str
-    max_new_tokens: int = 50
-    temperature: float = 0.7
-    top_p: float = 0.9
-
-
-@app.get("/")
-def home():
-    return {"message": "Welcome to QA GPT2 API 🚀"}
-
-@app.get("/ask")
-def ask(question: str, max_new_tokens: int = 50):
-    inputs = tokenizer(question, return_tensors="pt")
-    outputs = model.generate(**inputs, max_new_tokens=max_new_tokens)
-    answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return {"question": question, "answer": answer}
-
-
-# Mount static folder
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-@app.get("/ui", response_class=HTMLResponse)
-def serve_ui():
-    html_path = os.path.join("static", "index.html")
-    with open(html_path, "r", encoding="utf-8") as f:
-        return HTMLResponse(f.read())
-
-
-# Health check endpoint
-@app.get("/health")
-def health():
-    return {"status": "ok"}
-
-# Inference endpoint
-@app.post("/predict")
-def predict(request: QueryRequest):
-    inputs = tokenizer(request.question, return_tensors="pt")
-    outputs = model.generate(
-        **inputs,
-        max_new_tokens=request.max_new_tokens,
-        do_sample=True,
-        temperature=0.7,
-        top_p=0.9,
-        pad_token_id=tokenizer.eos_token_id,
-        return_dict_in_generate=True
-    )
-
-    answer = tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)
-    return {
-        "question": request.question,
-        "answer": answer
-    }
-
-
-
-
-@app.get("/answers")
-def predict(question: str = Query(..., description="The question to ask"), max_new_tokens: int = Query(50, description="Max new tokens to generate")):
-    # Tokenize the input question
-    inputs = tokenizer(question, return_tensors="pt")
-
-    # Generate output from model
-    outputs = model.generate(
-        **inputs,
-        max_new_tokens=max_new_tokens,
-        do_sample=True,
-        temperature=0.7,
-        top_p=0.9,
-        pad_token_id=tokenizer.eos_token_id,
-        return_dict_in_generate=True
+from fastapi.templating import Jinja2Templates
+import sys
+import io
+
+app = FastAPI()
+templates = Jinja2Templates(directory="templates")
+
+# --- Core tracer logic ---
+def run_code_with_trace(code: str):
+    trace_data = []
+    stdout_capture = io.StringIO()
+
+    def tracer(frame, event, arg):
+        if event == "line":
+            trace_data.append({
+                "line": frame.f_lineno,
+                "locals": frame.f_locals.copy()
+            })
+        return tracer
+
+    sys.settrace(tracer)
+    try:
+        exec(code, {}, {})
+    except Exception as e:
+        trace_data.append({"error": str(e)})
+    finally:
+        sys.settrace(None)
+
+    output = stdout_capture.getvalue()
+    stdout_capture.close()
+
+    return trace_data, output
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.post("/run", response_class=HTMLResponse)
+async def run_code(request: Request, code: str = Form(...)):
+    trace, output = run_code_with_trace(code)
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "trace": trace,
+            "output": output,
+            "code": code
+        }
     )
-
-    # Decode output
-    answer = tokenizer.decode(outputs.sequences[0], skip_special_tokens=True)
-
-    return {
-        "question": question,
-        "answer": answer
-    }