PYTHON #3

.env

@@ -1,4 +1,4 @@
 MODEL_NAME=adibrino/LAPOR-AI
 ALLOWED_ORIGINS=https://lalim.vercel.app,http://localhost:8000,http://127.0.0.1:8000
-SERVICE_CODES_MAP='{"DPRKPCK": "Perumahan Rakyat, Kawasan Permukiman dan Cipta Karya", "DPUBM": "Pekerjaan Umum Bina Marga", "DPUSDA": "Pekerjaan Umum Sumber Daya Air", "DLH": "Lingkungan Hidup", "DINSOS": "Sosial", "BPBD": "Penanggulangan Bencana Daerah", "DISHUB": "Perhubungan", "DINKES": "Kesehatan", "SATPOLPP": "Satuan Polisi Pamong Praja", "DISKOMINFO": "Komunikasi dan Informatika", "DISNAKERTRANS": "Tenaga Kerja dan Transmigrasi", "DIPERTAKP": "Pertanian dan Ketahanan Pangan", "DISNAK": "Peternakan", "DKP": "Kelautan dan Perikanan", "DINDIK": "Pendidikan", "DISBUDPAR": "Kebudayaan dan Pariwisata", "DISPERINDAG": "Perindustrian dan Perdagangan", "DPMPTSP": "Penanaman Modal dan Pelayanan Terpadu Satu Pintu", "DISKOPUKM": "Koperasi, Usaha Kecil dan Menengah", "DISPORA": "Kepemudaan dan Olahraga", "DISPERPUSIP": "Perpustakaan dan Kearsipan", "BAPPEDA": "Perencanaan Pembangunan Daerah", "BAPENDA": "Pajak dan Pendapatan Daerah", "DP3AK": "Pemberdayaan Perempuan, Perlindungan Anak dan Kependudukan"}'
+SERVICE_CODES_MAP="{'DPRKPCK': 'Perumahan Rakyat, Kawasan Permukiman dan Cipta Karya', 'DPUBM': 'Pekerjaan Umum Bina Marga', 'DPUSDA': 'Pekerjaan Umum Sumber Daya Air', 'DLH': 'Lingkungan Hidup', 'DINSOS': 'Sosial', 'BPBD': 'Penanggulangan Bencana Daerah', 'DISHUB': 'Perhubungan', 'DINKES': 'Kesehatan', 'SATPOLPP': 'Satuan Polisi Pamong Praja', 'DISKOMINFO': 'Komunikasi dan Informatika', 'DISNAKERTRANS': 'Tenaga Kerja dan Transmigrasi', 'DIPERTAKP': 'Pertanian dan Ketahanan Pangan', 'DISNAK': 'Peternakan', 'DKP': 'Kelautan dan Perikanan', 'DINDIK': 'Pendidikan', 'DISBUDPAR': 'Kebudayaan dan Pariwisata', 'DISPERINDAG': 'Perindustrian dan Perdagangan', 'DPMPTSP': 'Penanaman Modal dan Pelayanan Terpadu Satu Pintu', 'DISKOPUKM': 'Koperasi, Usaha Kecil dan Menengah', 'DISPORA': 'Kepemudaan dan Olahraga', 'DISPERPUSIP': 'Perpustakaan dan Kearsipan', 'BAPPEDA': 'Perencanaan Pembangunan Daerah', 'BAPENDA': 'Pajak dan Pendapatan Daerah', 'DP3AK': 'Pemberdayaan Perempuan, Perlindungan Anak dan Kependudukan'}"
 IS_PRODUCTION=false

Dockerfile

@@ -1,23 +0,0 @@
-FROM python:3.9-slim
-
-RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
-
-RUN curl -fsSL https://ollama.com/install.sh | sh
-
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
-
-WORKDIR $HOME/app
-COPY --chown=user . $HOME/app
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-ENV MODEL_NAME=adibrino/LAPOR-AI
-
-RUN chmod +x start.sh
-
-EXPOSE 7860
-
-CMD ["./start.sh"]

README.md

@@ -1,11 +1,11 @@
 ---
-title: LAPOR AI SERVER
-emoji: 🏃
-colorFrom: purple
-colorTo: yellow
-sdk: docker
+title: LAPOR AI
+emoji: 📞
+colorFrom: lightblue
+colorTo: white
+sdk: gradio
+python_version: 3.9
+app_file: app.py
 pinned: false
 license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---

app.py

@@ -2,51 +2,80 @@ import os
 import io
 import base64
 import json
-import ollama
 import time
-from typing import List, Optional, Union, Any, Dict
-from flask import Flask, request, jsonify, Response
-from flask_cors import CORS
+import subprocess
+import threading
+import shutil
+from typing import List, Any, Dict, Union
+
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
 from PIL import Image
-from werkzeug.datastructures import FileStorage
 from dotenv import load_dotenv
+import ollama
+import spaces
+import gradio as gr
 
 load_dotenv()
 
-ALLOWED_ORIGINS_RAW: Optional[str] = os.getenv("ALLOWED_ORIGINS", None)
-MODEL_NAME: Optional[str] = os.getenv("MODEL_NAME", None)
-IS_PRODUCTION: Optional[str] = os.getenv("IS_PRODUCTION", "false")
+ALLOWED_ORIGINS_RAW: str = os.getenv("ALLOWED_ORIGINS", "*")
+MODEL_NAME: str = os.getenv("MODEL_NAME") or "adibrino/LAPOR-AI"
+IS_PRODUCTION: str = os.getenv("IS_PRODUCTION", "false")
 
+SERVICE_MAP_STR = os.getenv("SERVICE_CODES_MAP", "{}")
 try:
-    SERVICE_MAP_STR = os.getenv("SERVICE_CODES_MAP", "{}")
     SERVICE_MAP = json.loads(SERVICE_MAP_STR)
 except json.JSONDecodeError:
-    raise EnvironmentError("SERVICE_CODES_MAP in .env is not valid JSON.")
-
-if not ALLOWED_ORIGINS_RAW:
-    raise EnvironmentError("The ALLOWED_ORIGINS environment variable is not set.")
-if not MODEL_NAME:
-    raise EnvironmentError("The MODEL_NAME environment variable is not set.")
-if not SERVICE_MAP:
-    raise EnvironmentError("The SERVICE_MAP environment variable is not set or empty.")
+    SERVICE_MAP = {}
 
-ALLOWED_ORIGINS: Union[str, List[str]] = "*" if ALLOWED_ORIGINS_RAW == "*" else [origin.strip() for origin in ALLOWED_ORIGINS_RAW.split(",")]
+if ALLOWED_ORIGINS_RAW == "*":
+    ALLOWED_ORIGINS = ["*"]
+else:
+    ALLOWED_ORIGINS = [origin.strip() for origin in ALLOWED_ORIGINS_RAW.split(",")]
 
-print(f"ALLOWED_ORIGINS (Parsed): {ALLOWED_ORIGINS}")
+print(f"ALLOWED_ORIGINS: {ALLOWED_ORIGINS}")
 print(f"MODEL_NAME: {MODEL_NAME}")
-print(f"IS_PRODUCTION: {IS_PRODUCTION}")
-print(f"SERVICE_MAP Loaded: {len(SERVICE_MAP)} items")
-print(json.dumps(SERVICE_MAP, indent=2, ensure_ascii=True))
 
-app = Flask(__name__)
+def setup_ollama():
+    print("Checking Ollama setup...")
+    if not shutil.which("ollama"):
+        print("Ollama not found. Installing...")
+        subprocess.run("curl -fsSL https://ollama.com/install.sh | sh", shell=True, check=True)
+    
+    def run_server():
+        print("Starting Ollama Serve...")
+        subprocess.Popen(["ollama", "serve"])
+    
+    t = threading.Thread(target=run_server, daemon=True)
+    t.start()
+    
+    print("Waiting for Ollama to spin up...")
+    time.sleep(5)
+    
+    print(f"Pulling Model: {MODEL_NAME}...")
+    try:
+        subprocess.run(["ollama", "pull", MODEL_NAME], check=True)
+        print("Model pulled successfully.")
+    except Exception as e:
+        print(f"Error pulling model: {e}")
 
-app.config['MAX_CONTENT_LENGTH'] = 128 * 1024 * 1024 
+setup_ollama()
 
-CORS(app, resources={r"/api/*": {"origins": ALLOWED_ORIGINS}})
+app = FastAPI()
 
-def process_image_to_base64(image_file: FileStorage) -> Optional[str]:
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def process_image_to_base64(image_bytes: bytes) -> Union[str, None]:
     try:
-        img = Image.open(image_file) # type: ignore
+        img = Image.open(io.BytesIO(image_bytes))
         img = img.convert('RGB')
         buffered = io.BytesIO()
         img.save(buffered, format="JPEG")
@@ -55,110 +84,127 @@ def process_image_to_base64(image_file: FileStorage) -> Optional[str]:
         print(f"Error processing image: {e}")
         return None
 
-@app.route('/', methods=['GET'])
-def health_check() -> Response:
-    return Response("Python Backend is running.")
-
-@app.route('/api/analyze', methods=['POST'])
-def analyze() -> tuple[Response, int]:
-    text_laporan: str = request.form.get('laporan', '')
+@spaces.GPU(duration=60) 
+def run_inference(text_laporan: str, base64_images: List[str]) -> Dict[str, Any]:
+    print("Starting GPU Inference...")
     
-    if not text_laporan or len(text_laporan) < 10:
-        return jsonify({
-            "status": "error", 
-            "message": "Deskripsi laporan wajib diisi minimal 10 karakter."
-        }), 400
-
-    images: List[FileStorage] = request.files.getlist('images')
-    valid_images: List[FileStorage] = [img for img in images if img.filename != '']
-
-    if len(valid_images) < 1:
-        return jsonify({
-            "status": "error",
-            "message": "Wajib melampirkan minimal 1 foto bukti."
-        }), 400
+    try:
+        ollama.show(MODEL_NAME)
+    except Exception:
+        print("Model not found in GPU context, pulling again...")
+        subprocess.run(["ollama", "pull", MODEL_NAME], check=True)
+
+    response: Any = ollama.chat(
+        model=MODEL_NAME,
+        messages=[{
+            'role': 'user',
+            'content': text_laporan,
+            'images': base64_images if base64_images else None # type: ignore
+        }],
+        format='json',
+        options={'temperature': 0.1}
+    )
+    
+    if isinstance(response, dict):
+        return response
+    return dict(response)
+
+@app.get("/")
+def health_check():
+    return {"status": "Python Backend with ZeroGPU is running."}
+
+@app.post("/api/analyze")
+async def analyze(
+    laporan: str = Form(...),
+    images: List[UploadFile] = File(...)
+):
+    if not laporan or len(laporan) < 10:
+        return JSONResponse(
+            status_code=400, 
+            content={"status": "error", "message": "Deskripsi laporan wajib diisi minimal 10 karakter."}
+        )
+
+    if not images:
+        return JSONResponse(
+            status_code=400,
+            content={"status": "error", "message": "Wajib melampirkan minimal 1 foto bukti."}
+        )
 
     base64_images: List[str] = []
-    for img_file in valid_images:
-        b64 = process_image_to_base64(img_file)
-        if b64:
-            base64_images.append(b64)
+    for img_file in images:
+        content = await img_file.read()
+        if len(content) > 0:
+            b64 = process_image_to_base64(content)
+            if b64:
+                base64_images.append(b64)
     
+    if not base64_images:
+         return JSONResponse(
+            status_code=400,
+            content={"status": "error", "message": "File gambar tidak valid/corrupt."}
+        )
+
     max_retries = 3
     last_exception = None
-    
+
     for attempt in range(max_retries):
         try:
             print(f"Attempting AI Analysis... ({attempt + 1}/{max_retries})")
             
-            if not MODEL_NAME:
-                 raise ValueError("Model name is missing")
-
-            response: Any = ollama.chat( # type: ignore
-                model=MODEL_NAME,
-                messages=[{
-                    'role': 'user',
-                    'content': text_laporan,
-                    'images': base64_images if base64_images else None
-                }],
-                format='json',
-                options={'temperature': 0.1}
-            )
-
-            if 'message' not in response or 'content' not in response['message']:
+            response_raw = run_inference(laporan, base64_images)
+
+            if 'message' not in response_raw or 'content' not in response_raw['message']:
                 raise ValueError("Empty response structure from AI")
 
-            content_str = response['message']['content']
-            ai_content: Dict[str, Any] = json.loads(content_str)
+            content_str = response_raw['message']['content']
+            
+            ai_content = json.loads(content_str)
 
             required_keys = ["title", "category", "priority", "service_code"]
             missing_keys = [key for key in required_keys if key not in ai_content]
-
             if missing_keys:
                 raise ValueError(f"Missing keys in JSON: {missing_keys}")
-            
-            if not str(ai_content["title"]).strip():
-                raise ValueError("AI returned empty title")
 
             service_code = ai_content["service_code"]
             if service_code not in SERVICE_MAP:
-                raise ValueError(f"Invalid service_code: {service_code}. Not found in SERVICE_MAP.")
-
-            expected_category = SERVICE_MAP[service_code]
-            if ai_content["category"] != expected_category:
-                raise ValueError(f"Category mismatch. Got '{ai_content['category']}', expected '{expected_category}' for code {service_code}")
-
+                print(f"Warning: Service code {service_code} unknown.")
+            
             priority = str(ai_content["priority"]).lower()
             if priority not in ['high', 'medium', 'low']:
-                raise ValueError(f"Invalid priority: {priority}")
-            
+                priority = 'medium'
             ai_content["priority"] = priority
 
-            data: dict[str, Any] = {
+            data = {
                 "status": "success",
                 "data": ai_content,
                 "meta": {
                     "model": MODEL_NAME,
-                    'processing_time_sec': (response.get("total_duration", 0)) / 1e9,
+                    'processing_time_sec': (response_raw.get("total_duration", 0)) / 1e9,
                     "images_analyzed": len(base64_images),
                     "attempts": attempt + 1
                 }
             }
-
-            print("AI Success:", json.dumps(data, indent=2, ensure_ascii=True))
-
-            return jsonify(data), 200
+            
+            print("AI Success")
+            return data
 
         except Exception as e:
             print(f"Attempt {attempt + 1} failed: {str(e)}")
             last_exception = e
             time.sleep(1)
             continue
-    
-    return jsonify({
-        "status": "error", 
-        "message": f"AI Failed after {max_retries} attempts. Last Error: {str(last_exception)}"
-    }), 500
+
+    return JSONResponse(
+        status_code=500,
+        content={"status": "error", "message": f"AI Failed: {str(last_exception)}"}
+    )
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860, debug=(IS_PRODUCTION == "false"))
+    with gr.Blocks() as demo:
+        gr.Markdown("# LAPOR AI API Backend")
+        gr.Markdown("This space hosts the API at `/api/analyze`.")
+        gr.Markdown(f"**Model:** {MODEL_NAME}")
+    
+    app = gr.mount_gradio_app(app, demo, path="/")
+    
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,6 +1,9 @@
-flask
-flask-cors
+fastapi
+uvicorn
+python-multipart
+pydantic
 ollama
-Pillow
-gunicorn
-python-dotenv
+gradio
+spaces
+python-dotenv
+Pillow

start.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-echo "Starting Ollama Serve..."
-ollama serve &
-
-echo "Waiting for Ollama socket..."
-sleep 5
-
-echo "PRE-LOADING MODEL: $MODEL_NAME"
-ollama pull $MODEL_NAME
-
-echo "Model loaded. Starting Flask Server..."
-python app.py