init commit

Dockerfile

@@ -1,6 +1,4 @@
-# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
-
+# HF Space — frontend only, no model weights needed here
 FROM python:3.9
 
 RUN useradd -m -u 1000 user
@@ -13,4 +11,5 @@ COPY --chown=user ./requirements.txt requirements.txt
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
 COPY --chown=user . /app
-CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "120"]
+
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "120"]

app.py

@@ -1,42 +1,31 @@
 """
-GPT-2 Text Generation Server
-=============================
-A minimal Flask API that loads GPT-2 from Hugging Face Transformers and exposes
-a single POST /generate endpoint. The model is loaded once at startup and kept
-in memory, so generation requests are fast after the first cold start (~10-30s).
-
-Endpoints
----------
-POST /generate
-    Body:  { "prompt": str, "max_new_tokens": int, "temperature": float,
-             "top_p": float, "repetition_penalty": float }
-    Returns: { "generated_text": str, "prompt": str }
-
-GET /
-    Serves the frontend HTML page.
-
-Usage
------
-    pip install flask transformers torch
-    python app.py
-    # Open http://localhost:5000
+app.py — HF Space frontend server
+===================================
+Lives in the Hugging Face Space. Does two things only:
+
+  1. Serves index.html (and static assets) to the browser
+  2. Proxies POST /generate to the remote Gradio server running on your machine,
+     translating between the frontend's JSON schema and Gradio's /run/predict API
+
+Set GRADIO_SERVER_URL to the public *.gradio.live URL that server.py prints
+when it starts (or your own domain if you're running behind a reverse proxy).
+
+Architecture
+------------
+Browser  →  POST /generate (HF Space)  →  POST /run/predict (your machine)
+                    app.py                         server.py
 """
 
 from flask import Flask, request, jsonify, send_from_directory
-from transformers import GPT2LMHeadModel, AutoTokenizer
-import torch
+import requests
 import os
 
 app = Flask(__name__, static_folder="static")
 
-print("Loading GPT-2 model and tokenizer...")
-tokenizer = AutoTokenizer.from_pretrained("helloadhavan/llara1.1-100M-base")
-model = GPT2LMHeadModel.from_pretrained("helloadhavan/llara1.1-100M-base")
-model.eval()
-print("Model ready.")
+# Paste the *.gradio.live URL printed by server.py here (no trailing slash)
+GRADIO_SERVER_URL = os.environ.get("GRADIO_SERVER_URL", "https://your-tunnel.gradio.live")
 
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-model.to(DEVICE)
+GRADIO_PREDICT_URL = f"{GRADIO_SERVER_URL}/run/predict"
 
 
 @app.route("/")
@@ -44,6 +33,11 @@ def index():
     return send_from_directory(".", "index.html")
 
 
+@app.route("/static/<path:filename>")
+def static_files(filename):
+    return send_from_directory("static", filename)
+
+
 @app.route("/generate", methods=["POST"])
 def generate():
     body = request.get_json(force=True)
@@ -52,29 +46,31 @@ def generate():
     if not prompt:
         return jsonify({"error": "prompt is required"}), 400
 
-    max_new_tokens = int(body.get("max_new_tokens", 200))
-    temperature = float(body.get("temperature", 0.9))
-    top_p = float(body.get("top_p", 0.95))
-    repetition_penalty = float(body.get("repetition_penalty", 1.2))
-
-    inputs = tokenizer(prompt, return_tensors="pt").to(DEVICE)
-
-    with torch.no_grad():
-        output_ids = model.generate(
-            **inputs,
-            max_new_tokens=max_new_tokens,
-            do_sample=True,
-            temperature=temperature,
-            top_p=top_p,
-            repetition_penalty=repetition_penalty,
-            pad_token_id=tokenizer.eos_token_id,
-        )
-
-    full_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
-    generated_only = full_text[len(prompt):]
-
-    return jsonify({"generated_text": generated_only, "prompt": prompt})
+    # Gradio expects inputs as a positional list matching the server.py fn signature:
+    # [prompt, max_new_tokens, temperature, top_p, repetition_penalty]
+    gradio_payload = {
+        "data": [
+            prompt,
+            int(body.get("max_new_tokens", 200)),
+            float(body.get("temperature", 0.9)),
+            float(body.get("top_p", 0.95)),
+            float(body.get("repetition_penalty", 1.2)),
+        ]
+    }
+
+    try:
+        resp = requests.post(GRADIO_PREDICT_URL, json=gradio_payload, timeout=120)
+        resp.raise_for_status()
+    except requests.exceptions.ConnectionError:
+        return jsonify({"error": "Cannot reach inference server. Is server.py running?"}), 502
+    except requests.exceptions.Timeout:
+        return jsonify({"error": "Inference server timed out."}), 504
+    except requests.exceptions.HTTPError as e:
+        return jsonify({"error": f"Inference server error: {e}"}), 502
+
+    generated_text = resp.json()["data"][0]
+    return jsonify({"generated_text": generated_text, "prompt": prompt})
 
 
 if __name__ == "__main__":
-    app.run(debug=True, host="0.0.0.0", port=7860)
+    app.run(debug=True, port=7860)