nes

Dockerfile

@@ -19,4 +19,4 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY --chown=user . .
 
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--client-max-size", "10485760"]

client.py

@@ -1,61 +1,53 @@
-import os
+import requests
 import base64
 import json
-import requests
-from PIL import Image
 import urllib3
 
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-orig_path = r"D:\grcpsample\content\extracted\images_8184456bc26d4e7f9c5237c350fe20ba\page_4.png"
-resized_path = r"D:\grcpsample\content\extracted\images_8184456bc26d4e7f9c5237c350fe20ba\page_4_small.jpg"
-
-# 1. Load and downscale
-img = Image.open(orig_path)
-max_side = 800  # tweak to 600 or 512 if still too large
-scale = max_side / max(img.size)
-if scale < 1.0:
-    new_size = (int(img.width * scale), int(img.height * scale))
-    img = img.resize(new_size, Image.LANCZOS)
-
-# 2. Save as JPEG at 70% quality
-img.save(resized_path, format="JPEG", quality=70)
+# url = "https://llm-fastapi-sreejith8100.hf.space/predict"
 
-# 3. Print new on-disk size
-new_size_kb = os.path.getsize(resized_path) / 1024
-print(f"Resized JPEG size: {new_size_kb:.2f} KB")  # aim for ≤ 500 KB
+url = "https://sreejith8100-llm-fastapi.hf.space/predict"
 
-# 4. Base64-encode and print that size
-with open(resized_path, "rb") as f:
-    img_bytes = f.read()
-    b64 = base64.b64encode(img_bytes).decode("utf-8")
-b64_kb = len(b64.encode("utf-8")) / 1024
-print(f"Base64 size: {b64_kb:.2f} KB")  # expect ~1.33× raw size
+# Read image bytes and encode as base64 string
+with open(r"D:\grcpsample\content\extracted\images_21f3b49d112546a5bbf39d66a2f9c6ac\page_4.png", "rb") as f:
+    image_bytes = f.read()
+    image_base64 = base64.b64encode(image_bytes).decode("utf-8")
 
-# 5. Build payload and measure final JSON
 payload = {
     "inputs": {
-        "image": b64,
+        "image": image_base64,
         "question": "What is in the image?",
         "stream": True
     }
 }
-json_payload = json.dumps(payload)
-final_kb = len(json_payload.encode("utf-8")) / 1024
-print(f"Final JSON payload: {final_kb:.2f} KB")  # want < ~700 KB
 
-# 6. POST to the Space
-url = "https://huggingface.co/spaces/sreejith8100/llm_model/predict"
-headers = {"Content-Type": "application/json"}
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+headers = {
+    "Content-Type": "application/json"
+}
 
 try:
-    with requests.post(url, data=json_payload, headers=headers, stream=True, verify=False) as resp:
-        resp.raise_for_status()
-        for line in resp.iter_lines(decode_unicode=True):
-            if line.startswith("data: "):
-                chunk = json.loads(line.replace("data: ", ""))
-                if chunk.get("output"):
-                    print(chunk["output"], end="", flush=True)
-except requests.HTTPError as e:
-    print(f"HTTP error: {e}, body:\n{resp.text}")
+    with requests.post(url, data=json.dumps(payload), headers=headers, stream=True, verify=False) as response:
+        response.raise_for_status()  # Raise error for HTTP errors
+
+        for line in response.iter_lines():
+            if line:
+                decoded_line = line.decode("utf-8")
+                if decoded_line.startswith("data: "):
+                    content = decoded_line.replace("data: ", "")
+                    try:
+                        parsed = json.loads(content)
+                    except json.JSONDecodeError as e:
+                        raise ValueError(f"Malformed JSON chunk: {content}") from e
+
+                    output = parsed.get("output", "")
+                    if output:
+                        print(output, end="", flush=True)
+
+except requests.HTTPError as http_err:
+    print(f"HTTP error occurred: {http_err}")
+    raise
+
+except Exception as err:
+    print(f"Error occurred: {err}")
     raise

main.py

@@ -1,50 +1,95 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks
 from fastapi.responses import JSONResponse, StreamingResponse
-from pydantic import BaseModel
-import types
-import json
-
-from endpoint_handler import EndpointHandler  # your handler file
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, validator
+import base64, types, json, logging, asyncio
+from endpoint_handler import EndpointHandler
 
+logger = logging.getLogger("uvicorn.error")
 app = FastAPI()
 
+
 handler = None
 
 @app.on_event("startup")
 async def load_handler():
     global handler
-    handler = EndpointHandler()
+    try:
+        handler = EndpointHandler()
+        logger.info("EndpointHandler initialized successfully.")
+    except Exception as e:
+        logger.error(f"Failed to initialize handler: {e}", exc_info=True)
+        handler = None  # so /predict will return 503
+
+@app.on_event("shutdown")
+async def cleanup_handler():
+    if handler:
+        try:
+            handler.close()
+            logger.info("Handler cleaned up on shutdown.")
+        except Exception:
+            logger.error("Error during handler cleanup", exc_info=True)
 
 class PredictInput(BaseModel):
-    image: str       # base64-encoded image string
+    image: str
     question: str
     stream: bool = False
 
+    @validator("question")
+    def question_not_empty(cls, v):
+        if not v.strip():
+            raise ValueError("Question must not be empty")
+        return v
+
+    @validator("image")
+    def valid_base64(cls, v):
+        try:
+            base64.b64decode(v, validate=True)
+        except Exception:
+            raise ValueError("`image` must be valid base64")
+        return v
+
 class PredictRequest(BaseModel):
     inputs: PredictInput
 
-@app.get("/")
-async def root():
-    return {"message": "FastAPI app is running on Hugging Face"}
-
 @app.post("/predict")
 async def predict_endpoint(payload: PredictRequest):
-    print(f"[Request] Received question: {payload.inputs.question}")
-    
-    data = {
+    if handler is None:
+        return JSONResponse({"error": "Service unavailable"}, status_code=503)
+
+    # Log input
+    logger.info(f"Received question: {payload.inputs.question}")
+
+    # Prepare the data dict exactly how EndpointHandler expects
+    request_dict = {
         "inputs": {
             "image": payload.inputs.image,
             "question": payload.inputs.question,
-            "stream": payload.inputs.stream
+            "stream": payload.inputs.stream,
         }
     }
-    
-    result = handler.predict(data)
-    
+
+    try:
+        result = await asyncio.to_thread(handler.predict, request_dict)
+    except ValueError as ve:
+        return JSONResponse({"error": str(ve)}, status_code=400)
+    except Exception as e:
+        logger.error("Unexpected error in handler.predict", exc_info=True)
+        return JSONResponse({"error": "Internal server error"}, status_code=500)
+
+    # If handler.predict returned a generator, wrap in SSE
     if isinstance(result, types.GeneratorType):
-        def event_stream():
-            for chunk in result:
-                yield f"data: {json.dumps(chunk)}\n\n"
+        async def event_stream():
+            try:
+                for chunk in result:
+                    yield f"data: {json.dumps(chunk)}\n\n"
+            except (asyncio.CancelledError, ConnectionResetError):
+                logger.info("Client disconnected from stream.")
+            except Exception:
+                logger.error("Error during streaming", exc_info=True)
+                yield f"data: {json.dumps({'error': 'Stream error'})}\n\n"
+
         return StreamingResponse(event_stream(), media_type="text/event-stream")
-    
-    return JSONResponse(content=result)
+
+    # Otherwise normal JSON
+    return JSONResponse(content=result, status_code=200)