Upload 7 files

app.py

@@ -0,0 +1 @@
+from main import app

grammar_service.py

@@ -0,0 +1,182 @@
+# services/grammar_service.py
+import re
+from functools import lru_cache
+
+# Optional: jika ada modul kbbi, gunakan. Jika tidak — lewati cek KBBI.
+try:
+    from kbbi import KBBI
+    _HAS_KBBI = True
+except Exception:
+    _HAS_KBBI = False
+
+
+@lru_cache(maxsize=10000)
+def cek_kbbi(kata: str) -> bool:
+    """
+    Cek KBBI jika tersedia. Untuk kata pendek (<=2) return True agar tidak memblokir.
+    """
+    kata = kata.strip()
+    if not kata or len(kata) <= 2:
+        return True
+    if not _HAS_KBBI:
+        # Jika KBBI tidak tersedia, kembalikan False untuk kata yang tampak digabung 'diX'?
+        return False
+    try:
+        KBBI(kata)
+        return True
+    except Exception:
+        return False
+
+
+# Simplified dictionaries (bisa kamu perluas kembali)
+DI_LOKASI = {
+    "rumah", "kantor", "sekolah", "kampus", "pasar", "kota", "desa", "kabupaten",
+    "provinsi", "negara", "daerah", "jalan", "kamar", "dapur", "teras", "taman",
+    "toilet", "wc", "garasi", "hotel", "restoran", "kafe", "stasiun",
+    "bandara", "terminal", "perpustakaan", "lapangan", "rumah sakit", "bank",
+}
+
+KATA_KERJA_UMUM = {
+    "ambil", "taruh", "angkat", "makan", "minum", "bawa", "buat", "beri", "jual", "beli",
+    "tulis", "hapus", "cetak", "masak", "pakai", "bakar", "dorong", "tarik", "tutup",
+    "buka", "cuci", "tolong", "lari", "jalan", "duduk", "berdiri", "naik", "turun",
+    "klik", "ketik", "upload", "download", "kirim", "simpan", "cari", "parkir",
+}
+
+
+def _find_sentence_starts(text: str):
+    """
+    Menghasilkan match untuk kata pertama tiap kalimat (pos dan kata).
+    Kalimat dianggap dimulai di awal teks atau setelah .!? diikuti spasi.
+    """
+    pattern = re.compile(r'(^|[\.!?]\s+)([^\s])', flags=re.MULTILINE | re.UNICODE)
+    for m in pattern.finditer(text):
+        yield m.start(2), m.group(2)
+
+
+def check_grammar(text: str):
+    """
+    Mengembalikan dict:
+    {
+      "corrected_text": "...",
+      "errors": [
+        {"start": int, "end": int, "original": "...", "suggestion":"...", "message":"..."},
+        ...
+      ]
+    }
+    Deteksi:
+      - Huruf awal kalimat harus kapital
+      - 'di' yang salah pisah/gabung (sederhana)
+      - spasi ganda
+      - spasi sebelum tanda baca
+      - kata + 'nya' yang seharusnya digabung (cek KBBI jika tersedia)
+    """
+    if not text:
+        return {"corrected_text": "", "errors": []}
+
+    errors = []
+
+    # 1) Huruf awal kalimat kecil -> sarankan kapitalisasi kata awal
+    for pos, char in _find_sentence_starts(text):
+        if char.isalpha() and char.islower():
+            # ambil kata lengkap dari posisi pos
+            m_word = re.match(r'[^\s\.,;:!?()"\']+', text[pos:])
+            if m_word:
+                word = m_word.group(0)
+                start = pos
+                end = pos + len(word)
+                suggestion = word[0].upper() + word[1:] if len(word) > 0 else word.upper()
+                errors.append({
+                    "start": start, "end": end,
+                    "original": text[start:end],
+                    "suggestion": suggestion,
+                    "message": "Huruf pertama kalimat harus kapital"
+                })
+
+    # 2) Spasi sebelum tanda baca -> hapus spasi
+    for m in re.finditer(r'\s+([,.:;!?])', text):
+        start, end = m.start(0), m.end(0)
+        # suggestion: punctuation saja (tanpa spasi)
+        suggestion = m.group(1)
+        errors.append({
+            "start": start, "end": end,
+            "original": text[start:end],
+            "suggestion": suggestion,
+            "message": "Hapus spasi sebelum tanda baca"
+        })
+
+    # 3) Spasi ganda -> ganti jadi satu spasi
+    for m in re.finditer(r' {2,}', text):
+        start, end = m.start(), m.end()
+        suggestion = " "
+        errors.append({
+            "start": start, "end": end,
+            "original": text[start:end],
+            "suggestion": suggestion,
+            "message": "Spasi ganda — gunakan satu spasi"
+        })
+
+    # 4) 'di' salah pisah / harus digabung
+    for m in re.finditer(r'\bdi\s+([^\s,\.!?;:()"\']+)', text, flags=re.IGNORECASE):
+        kata = m.group(1)
+        start, end = m.start(0), m.end(0)
+        kata_lower = kata.lower()
+        
+        # jika kata kerja umum -> gabung
+        if kata_lower in KATA_KERJA_UMUM:
+            suggestion = "di" + kata
+            errors.append({
+                "start": start, "end": end,
+                "original": text[start:end],
+                "suggestion": suggestion,
+                "message": f"Gabungkan 'di' dengan kata kerja (bentuk baku: 'di{kata_lower}')"
+            })
+        else:
+            # jika KBBI ada dan 'di'+kata adalah entry baku, sarankan gabung
+            if cek_kbbi("di" + kata_lower):
+                suggestion = "di" + kata
+                errors.append({
+                    "start": start, "end": end,
+                    "original": text[start:end],
+                    "suggestion": suggestion,
+                    "message": "Kemungkinan kata baku 'di'+kata seharusnya digabung"
+                })
+
+    # 5) 'masak nya' -> 'masaknya'
+    for m in re.finditer(r'\b([^\s,\.!?;:()"\']+)\s+nya\b', text, flags=re.IGNORECASE):
+        dasar = m.group(1)
+        gab = (dasar + "nya").lower()
+        if cek_kbbi(gab):
+            start, end = m.start(0), m.end(0)
+            suggestion = dasar + "nya"
+            errors.append({
+                "start": start, "end": end,
+                "original": text[start:end],
+                "suggestion": suggestion,
+                "message": f"Gabungkan kata dan 'nya' menjadi '{suggestion}'"
+            })
+
+    # Deduplicate errors
+    seen = set()
+    unique_errors = []
+    for e in errors:
+        key = (e["start"], e["end"], e["suggestion"])
+        if key not in seen:
+            seen.add(key)
+            unique_errors.append(e)
+
+    # Sort by start position
+    unique_errors.sort(key=lambda x: x["start"])
+
+    # Build corrected_text
+    corrected = text
+    edits = [(e["start"], e["end"], e["suggestion"]) for e in unique_errors]
+    edits.sort(key=lambda t: t[0], reverse=True)
+
+    for s, e, sug in edits:
+        corrected = corrected[:s] + sug + corrected[e:]
+
+    return {
+        "corrected_text": corrected,
+        "errors": unique_errors
+    }

main.py

@@ -0,0 +1,103 @@
+# main.py
+import os
+import asyncio
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from typing import List
+
+# --- Import services ---
+from services.surya_ocr import ocr_surya
+from services.grammar_service import check_grammar
+from services.summarize_service import summarize_text
+from services.pdf_service import export_pdf
+
+app = FastAPI(title="NoteBoard AI Backend")
+
+# ---------------------------------------------------------
+# CORS
+# ---------------------------------------------------------
+ALLOWED_ORIGINS = os.getenv("ALLOWED_ORIGINS", "*")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[origin.strip() for origin in ALLOWED_ORIGINS.split(",")],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ---------------------------------------------------------
+# OCR Endpoint
+# ---------------------------------------------------------
+@app.post("/ocr")
+async def ocr_endpoint(files: List[UploadFile] = File(...)):
+    """
+    Menerima beberapa file dan mengembalikan hasil OCR (list).
+    """
+    results = []
+
+    for file in files:
+        content = await file.read()
+        text = await ocr_surya(content)  # Surya OCR async
+        results.append(text)
+
+    return {"results": results}
+
+
+# ---------------------------------------------------------
+# Grammar Check Endpoint - DIPERBAIKI
+# ---------------------------------------------------------
+@app.post("/grammar")
+async def grammar_endpoint(text: str = Form(...)):
+    """
+    Menerima text dari FormData dan mengembalikan hasil grammar check.
+    """
+    # Jalankan di thread pool karena check_grammar adalah fungsi sinkron
+    result = await asyncio.to_thread(check_grammar, text)
+    return result
+
+
+# ---------------------------------------------------------
+# Summarization Endpoint
+# ---------------------------------------------------------
+@app.post("/summarize")
+async def summarize_endpoint(text: str = Form(...)):
+    """
+    Meringkas teks menggunakan AI.
+    """
+    summary = await summarize_text(text)
+    return {"summary": summary}
+
+
+# ---------------------------------------------------------
+# Export PDF Endpoint
+# ---------------------------------------------------------
+@app.post("/export-pdf")
+async def export_pdf_endpoint(text: str = Form(...)):
+    """
+    Generate PDF lalu mengirim kembali file. Karena sinkron,
+    dijalankan di thread terpisah.
+    """
+    pdf_path = await asyncio.to_thread(export_pdf, text, "output.pdf")
+
+    return FileResponse(
+        pdf_path,
+        media_type="application/pdf",
+        filename="output.pdf"
+    )
+
+
+# ---------------------------------------------------------
+# Health Check
+# ---------------------------------------------------------
+@app.get("/")
+async def root():
+    return {"message": "NoteBoard AI Backend is running!", "status": "ok"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

pdf_service.py

@@ -0,0 +1,41 @@
+# services/pdf_service.py
+from reportlab.lib.pagesizes import A4
+from reportlab.pdfgen import canvas
+
+def export_pdf(text: str, file_path: str = "output.pdf") -> str:
+    """
+    Membuat file PDF dari teks (simple, line by line).
+    Mengembalikan path file.
+    """
+    c = canvas.Canvas(file_path, pagesize=A4)
+    width, height = A4
+    margin_left = 50
+    margin_top = 50
+    y = height - margin_top
+    line_height = 14
+
+    for line in text.split('\n'):
+        # split panjang jadi beberapa baris jika perlu (simple wrap)
+        if not line:
+            y -= line_height
+        else:
+            # simple wrapping per 90 karakter (bukan ideal tapi cukup)
+            max_chars = 90
+            while len(line) > max_chars:
+                chunk = line[:max_chars]
+                c.drawString(margin_left, y, chunk)
+                line = line[max_chars:]
+                y -= line_height
+                if y < margin_top:
+                    c.showPage()
+                    y = height - margin_top
+            # terakhir
+            c.drawString(margin_left, y, line)
+            y -= line_height
+
+        if y < margin_top:
+            c.showPage()
+            y = height - margin_top
+
+    c.save()
+    return file_path

requirements.txt

@@ -0,0 +1,13 @@
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+
+numpy==1.26.4
+pillow==10.4.0
+requests==2.32.3
+regex==2024.11.6
+tqdm==4.67.1
+
+transformers==4.56.1
+surya-ocr==0.17.0
+
+reportlab==4.2.5

summarize_service.py

@@ -0,0 +1,45 @@
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+
+MODEL_ID = "panggi/t5-base-indonesian-summarization-cased"
+
+tokenizer = None
+model = None
+
+def load_model():
+    global tokenizer, model
+    if tokenizer is None or model is None:
+        tokenizer = T5Tokenizer.from_pretrained(MODEL_ID)
+        model = T5ForConditionalGeneration.from_pretrained(MODEL_ID)
+
+
+
+def _summarize_sync(text: str):
+    load_model()
+
+    # Encode dengan batas maksimum 512 token
+    input_ids = tokenizer.encode(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=512
+    )
+
+    # Parameter diganti agar sama seperti kode yang menurutmu lebih bagus
+    summary_ids = model.generate(
+        input_ids,
+        max_length=250,
+        min_length=40,
+        num_beams=2,
+        repetition_penalty=2.5,
+        length_penalty=1.0,
+        early_stopping=True,
+        no_repeat_ngram_size=2,
+        use_cache=True
+    )
+
+    summary_text = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+    return summary_text
+
+
+async def summarize_text(text: str):
+    return await asyncio.to_thread(_summarize_sync, text)

surya_ocr.py

@@ -0,0 +1,36 @@
+import asyncio
+from PIL import Image
+from io import BytesIO
+
+from surya.foundation import FoundationPredictor
+from surya.recognition import RecognitionPredictor
+from surya.detection import DetectionPredictor
+
+foundation = None
+recognizer = None
+detector = None
+
+
+def load_surya():
+    global foundation, recognizer, detector
+    if foundation is None:
+        foundation = FoundationPredictor()
+        recognizer = RecognitionPredictor(foundation)
+        detector = DetectionPredictor()
+
+
+def _run_ocr_sync(img):
+    load_surya()
+    result = recognizer([img], det_predictor=detector)
+    result = result[0] if isinstance(result, list) else result
+    return "\n".join([l.text for l in result.text_lines])
+
+
+async def ocr_surya(image_bytes: bytes) -> str:
+    try:
+        img = Image.open(BytesIO(image_bytes)).convert("RGB")
+        text = await asyncio.to_thread(_run_ocr_sync, img)
+        return " ".join(text.split())
+    except Exception as e:
+        print("OCR Error:", e)
+        return ""