Upload 6 files

.env.example

@@ -1,3 +1,6 @@
-NVIDIA_API_KEY=nvapi-isi_api_key_kamu
-NVIDIA_MODEL=meta/llama-3.1-8b-instruct
+# Jangan upload file .env asli ke Hugging Face publik.
+# Di Hugging Face, masukkan NVIDIA_API_KEY sebagai Secret.
+
+NVIDIA_API_KEY=isi_api_key_nvidia_kamu
+NVIDIA_MODEL=qwen/qwen2.5-coder-32b-instruct
 NVIDIA_BASE_URL=https://integrate.api.nvidia.com/v1

.gitignore

@@ -1,5 +1,9 @@
 .env
 __pycache__/
 *.pyc
+*.pyo
+*.pyd
+.ipynb_checkpoints/
+.DS_Store
 *.docx
-*.ipynb_checkpoints/
+*.zip

README.md

@@ -7,52 +7,186 @@ sdk: gradio
 sdk_version: 4.44.1
 app_file: app.py
 pinned: false
+python_version: 3.10
 ---
 
 # AI Assistant Mahasiswa NVIDIA
 
-Aplikasi Hugging Face Spaces berbasis Gradio untuk:
+Aplikasi Hugging Face Spaces berbasis Gradio untuk membantu mahasiswa dalam:
 
-1. Chat umum mahasiswa.
-2. Membuat laporan Deep Learning otomatis dari file `.ipynb`.
-3. Output laporan langsung berupa file Word `.docx`.
+1. Chat umum dan tanya jawab materi kuliah.
+2. Membantu tugas, coding, error Python, dan laporan akademik.
+3. Membuat laporan Deep Learning otomatis dari file `.ipynb`.
+4. Menghasilkan output laporan langsung dalam format Microsoft Word `.docx`.
+
+## Fitur Utama
+
+### 1. Chat Umum Mahasiswa
+
+Mahasiswa dapat bertanya tentang:
+
+- materi kuliah
+- tugas
+- coding dasar
+- error Python
+- Deep Learning
+- Machine Learning
+- laporan akademik
+- pertanyaan umum lainnya
+
+### 2. Generator Laporan Deep Learning dari IPYNB
+
+Fitur ini memungkinkan mahasiswa untuk upload file notebook `.ipynb`, lalu sistem akan membaca isi kode dan output notebook untuk dibuatkan laporan otomatis.
+
+Output laporan berupa file:
+
+```txt
+.docx
+```
+
+Jadi hasilnya bisa langsung dibuka dan diedit di Microsoft Word.
+
+### 3. Format Laporan
+
+Laporan dibuat dengan gaya laporan praktikum mahasiswa, yaitu:
+
+- cover laporan
+- judul laporan
+- nama
+- NIM
+- dosen
+- kelas
+- nama anggota/partner opsional
+- program studi
+- kampus
+- tahun
+- bagian-bagian pembahasan
+- kode notebook
+- output notebook jika tersedia
+- gambar/grafik output notebook jika tersimpan
+- penjelasan setiap kode dengan format `Penjelasannya:`
+
+### 4. Cek API
+
+Tersedia tab **Cek API** untuk memastikan API key NVIDIA dan nama model sudah benar.
 
 ## Cara Upload ke Hugging Face Spaces
 
 1. Buat Space baru di Hugging Face.
 2. Pilih SDK: **Gradio**.
-3. Upload file berikut ke Space:
-   - `app.py`
-   - `requirements.txt`
-   - `README.md`
-4. Masuk ke **Settings > Variables and secrets**.
-5. Tambahkan secret:
+3. Pilih Hardware: **CPU Basic**.
+4. Upload file berikut ke Space:
+
+```txt
+app.py
+requirements.txt
+README.md
+```
+
+5. Masuk ke menu:
+
+```txt
+Settings > Variables and secrets
+```
+
+6. Tambahkan Secret dan Variable sesuai bagian di bawah.
+
+## Secret yang Wajib Dibuat
+
+Tambahkan sebagai **Secret**, bukan Variable biasa:
 
 ```txt
 NVIDIA_API_KEY=isi_api_key_nvidia_kamu
 ```
 
-Opsional, tambahkan variable:
+## Variable yang Disarankan
+
+Tambahkan sebagai **Variable**:
 
 ```txt
-NVIDIA_MODEL=meta/llama-3.1-8b-instruct
+NVIDIA_MODEL=qwen/qwen2.5-coder-32b-instruct
 NVIDIA_BASE_URL=https://integrate.api.nvidia.com/v1
 ```
 
+Model `qwen/qwen2.5-coder-32b-instruct` disarankan karena aplikasi ini banyak membaca kode Python dan file notebook `.ipynb`.
+
+## Requirements
+
+Pastikan file `requirements.txt` berisi:
+
+```txt
+gradio==4.44.1
+openai>=1.30.0
+nbformat>=5.10.4
+python-docx>=1.1.2
+pillow>=10.0.0
+audioop-lts>=0.2.1
+```
+
 ## Cara Pakai
 
 ### Chat Umum
-Buka tab **Chat Umum**, lalu ketik pertanyaan.
+
+1. Buka tab **Chat Umum**.
+2. Ketik pertanyaan.
+3. AI akan menjawab seperti asisten mahasiswa.
+
+Contoh pertanyaan:
+
+```txt
+Jelaskan apa itu convolutional neural network.
+```
+
+```txt
+Bantu saya buat rumusan masalah untuk laporan Deep Learning.
+```
+
+```txt
+Kenapa kode Python saya error?
+```
 
 ### Buat Laporan DOCX dari IPYNB
-1. Jalankan notebook `.ipynb` terlebih dahulu agar output/grafik tersimpan.
-2. Upload file `.ipynb`.
-3. Isi data cover laporan.
-4. Klik **Buat Laporan DOCX**.
-5. Download file `.docx` yang muncul.
+
+1. Jalankan notebook `.ipynb` terlebih dahulu agar output, grafik, dan hasil training tersimpan.
+2. Buka tab **Buat Laporan DOCX dari IPYNB**.
+3. Upload file `.ipynb`.
+4. Isi data cover laporan:
+   - judul laporan
+   - nama
+   - NIM
+   - dosen
+   - kelas
+   - nama anggota/partner jika ada
+   - program studi
+   - kampus
+   - tahun
+5. Klik tombol **Buat Laporan DOCX**.
+6. Download file `.docx` yang muncul.
+
+### Cek API
+
+1. Buka tab **Cek API**.
+2. Klik **Cek Koneksi NVIDIA API**.
+3. Jika berhasil, akan muncul status bahwa API aktif.
 
 ## Catatan Penting
 
-- API key jangan ditulis langsung di kode.
-- Simpan API key di Hugging Face Secret bernama `NVIDIA_API_KEY`.
+- Jangan menulis API key langsung di `app.py`.
+- Simpan API key di Hugging Face Secret dengan nama `NVIDIA_API_KEY`.
+- File `.ipynb` sebaiknya sudah dijalankan terlebih dahulu sebelum di-upload.
+- Jika notebook belum dijalankan, output seperti akurasi, loss, grafik, dan hasil evaluasi mungkin tidak terbaca.
 - AI diarahkan agar tidak mengarang angka, akurasi, dataset, atau hasil evaluasi yang tidak ada di notebook.
+- Jika Hugging Face error karena Python 3.13, pastikan bagian atas README memiliki:
+
+```yaml
+python_version: 3.10
+```
+
+## Setelah Upload
+
+Jika sudah upload semua file dan set Secret/Variable:
+
+1. Klik **Restart Space**.
+2. Jika masih error, klik **Factory Rebuild**.
+3. Tunggu proses build selesai.
+4. Aplikasi siap digunakan.

app.py

@@ -1,82 +1,106 @@
 import base64
+import io
 import json
 import os
 import re
 import tempfile
-import textwrap
-import uuid
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
 import gradio as gr
 import nbformat
-from openai import OpenAI
 from docx import Document
 from docx.enum.text import WD_ALIGN_PARAGRAPH
-from docx.oxml import OxmlElement, parse_xml
-from docx.oxml.ns import nsdecls, qn
-from docx.shared import Inches, Pt, RGBColor
-
+from docx.shared import Inches, Pt
+from openai import OpenAI
+from PIL import Image
 
-# =========================
+# ==========================================================
 # KONFIGURASI NVIDIA API
-# =========================
-NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "").strip()
-NVIDIA_BASE_URL = os.getenv("NVIDIA_BASE_URL", "https://integrate.api.nvidia.com/v1").strip()
-NVIDIA_MODEL = os.getenv("NVIDIA_MODEL", "meta/llama-3.1-8b-instruct").strip()
+# ==========================================================
+NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "")
+NVIDIA_MODEL = os.getenv("NVIDIA_MODEL", "qwen/qwen2.5-coder-32b-instruct")
+NVIDIA_BASE_URL = os.getenv("NVIDIA_BASE_URL", "https://integrate.api.nvidia.com/v1")
 
 client = OpenAI(
-    api_key=NVIDIA_API_KEY if NVIDIA_API_KEY else "EMPTY",
+    api_key=NVIDIA_API_KEY,
     base_url=NVIDIA_BASE_URL,
 )
 
-
 SYSTEM_PROMPT = """
 Kamu adalah AI Assistant Mahasiswa.
 
-Tugas utamamu adalah membantu mahasiswa membuat laporan, tugas kuliah, memahami materi,
-merangkum teks, memperbaiki bahasa, membantu coding dasar, dan menjawab pertanyaan umum.
-
-Untuk laporan Deep Learning:
-- Gunakan bahasa Indonesia yang formal, jelas, dan mudah dipahami.
-- Jelaskan kode dengan gaya laporan praktikum mahasiswa.
-- Jangan mengarang hasil, angka akurasi, epoch, dataset, metrik evaluasi, atau referensi.
-- Gunakan informasi yang memang ada pada notebook.
-- Jika output tersedia, jelaskan berdasarkan output tersebut.
-- Jika output tidak tersedia, jelaskan tujuan kode dan fungsi tahap tersebut.
-- Jangan menyebut bahwa kamu adalah model bahasa.
-""".strip()
+Tugas utamamu membantu mahasiswa dalam kegiatan akademik, terutama:
+- menjelaskan materi kuliah,
+- membantu coding dasar,
+- membantu memahami error,
+- membantu membuat laporan akademik,
+- membantu membuat laporan Deep Learning dari kode notebook.
+
+Gunakan bahasa Indonesia yang jelas, sopan, dan mudah dipahami.
+Untuk kebutuhan laporan, gunakan bahasa formal seperti laporan mahasiswa.
+
+Aturan penting:
+- Jangan mengarang data, akurasi, loss, jumlah dataset, nama kelas, hasil evaluasi, atau referensi.
+- Jika angka atau hasil tidak ada di notebook, jangan dibuat-buat.
+- Jika memberi contoh, beri label sebagai contoh.
+- Bantu mahasiswa memahami isi, bukan sekadar memberi jawaban untuk disalin mentah-mentah.
+"""
 
 REPORT_STYLE_PROMPT = """
-Buat penjelasan laporan Deep Learning dengan gaya laporan mahasiswa.
+Kamu membuat penjelasan laporan praktikum Deep Learning dari satu bagian kode notebook.
 
-Format jawaban wajib JSON valid:
+Format jawaban WAJIB JSON valid:
 {
-  "judul": "Judul bagian singkat",
-  "penjelasan": "Penjelasannya: paragraf penjelasan"
+  "judul": "Judul Bagian Singkat",
+  "penjelasan": "Penjelasannya: ..."
 }
 
-Aturan gaya:
-- Judul singkat, misalnya: Import Library, Pembacaan Dataset, Split Dataset, Training Model, Evaluasi Model, Confusion Matrix, Deployment Gradio.
-- Penjelasan diawali dengan teks: Penjelasannya:
-- Bahasa Indonesia formal tetapi tetap natural seperti laporan praktikum.
-- Jelaskan fungsi kode, tujuan tahap, dan arti output jika ada.
-- Jangan mengarang angka, metrik, nama dataset, atau hasil yang tidak muncul pada notebook.
-- Jika ada error pada output, jelaskan bahwa kode menghasilkan error dan apa kemungkinan penyebabnya secara hati-hati.
-""".strip()
+Gaya laporan:
+- Bahasa Indonesia formal, seperti laporan mahasiswa.
+- Judul bagian singkat dan relevan, misalnya Import Library, Pembacaan Dataset, Split Dataset, Arsitektur Model, Training Model, Evaluasi Model, Confusion Matrix, Deployment Gradio.
+- Penjelasan diawali persis dengan: Penjelasannya:
+- Jelaskan fungsi kode, tujuan tahap, dan arti output jika output tersedia.
+- Jangan mengarang angka, akurasi, loss, dataset, nama kelas, atau hasil evaluasi yang tidak ada pada kode/output.
+- Jika output kosong, cukup jelaskan fungsi kode dan tujuan tahap tersebut.
+- Jangan membuat markdown, jangan membuat bullet panjang, dan jangan menambahkan teks di luar JSON.
+"""
 
+# ==========================================================
+# HELPER UMUM
+# ==========================================================
+def get_uploaded_path(file_obj: Any) -> str:
+    """Mengambil path file dari komponen gr.File."""
+    if file_obj is None:
+        raise gr.Error("File belum di-upload.")
+    if isinstance(file_obj, str):
+        return file_obj
+    if hasattr(file_obj, "name"):
+        return file_obj.name
+    if isinstance(file_obj, dict) and "path" in file_obj:
+        return file_obj["path"]
+    raise gr.Error("Format file upload tidak dikenali.")
+
+
+def safe_filename(text: str) -> str:
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9A-Z_-]+", "_", text)
+    text = re.sub(r"_+", "_", text).strip("_")
+    return text or "laporan_deep_learning"
+
+
+def truncate_text(text: str, limit: int) -> str:
+    if not text:
+        return ""
+    if len(text) <= limit:
+        return text
+    return text[:limit] + "\n... [dipotong karena terlalu panjang]"
 
-# =========================
-# UTILITAS UMUM
-# =========================
-def ensure_api_key():
-    if not NVIDIA_API_KEY:
-        raise gr.Error(
-            "NVIDIA_API_KEY belum diset. Buka Hugging Face Space > Settings > Variables and secrets > tambahkan secret NVIDIA_API_KEY."
-        )
 
+def ask_nvidia(messages: List[Dict[str, str]], temperature: float = 0.4, max_tokens: int = 1200) -> str:
+    if not NVIDIA_API_KEY:
+        raise gr.Error("NVIDIA_API_KEY belum diset di Hugging Face Secrets.")
 
-def ask_nvidia(messages, temperature=0.35, max_tokens=900):
-    ensure_api_key()
     response = client.chat.completions.create(
         model=NVIDIA_MODEL,
         messages=messages,
@@ -86,218 +110,210 @@ def ask_nvidia(messages, temperature=0.35, max_tokens=900):
     return response.choices[0].message.content or ""
 
 
-def clean_text(text):
-    if text is None:
-        return ""
-    if isinstance(text, list):
-        text = "\n".join(str(x) for x in text)
-    text = str(text)
-    # hapus ANSI color code dari output notebook
-    text = re.sub(r"\x1b\[[0-9;]*m", "", text)
-    text = text.replace("\r\n", "\n").replace("\r", "\n")
-    return text.strip()
-
-
-def limit_text(text, max_chars):
-    text = clean_text(text)
-    if len(text) <= max_chars:
-        return text
-    return text[:max_chars] + "\n... [dipotong agar tidak terlalu panjang]"
-
-
-def sanitize_filename(name):
-    name = clean_text(name) or "laporan_deep_learning"
-    name = re.sub(r"[^a-zA-Z0-9_\- ]+", "", name)
-    name = re.sub(r"\s+", "_", name).strip("_")
-    return name[:80] or "laporan_deep_learning"
-
-
-def parse_json_from_model(text):
-    text = clean_text(text)
+def parse_json_from_model(text: str) -> Optional[Dict[str, Any]]:
+    """Mencoba mengambil JSON dari jawaban model."""
     try:
         return json.loads(text)
     except Exception:
         pass
 
     match = re.search(r"\{.*\}", text, flags=re.DOTALL)
-    if match:
-        try:
-            return json.loads(match.group(0))
-        except Exception:
-            pass
-
-    return {
-        "judul": "Bagian Notebook",
-        "penjelasan": text if text.lower().startswith("penjelasannya") else f"Penjelasannya: {text}",
-    }
-
-
-def guess_title_from_code(code, markdown_context=""):
-    joined = f"{markdown_context}\n{code}".lower()
-    if "import " in joined and ("tensorflow" in joined or "keras" in joined or "pandas" in joined):
-        return "Import Library"
-    if "read_csv" in joined or "os.listdir" in joined or "dataframe" in joined or "dataset" in joined:
-        return "Pembacaan Dataset"
-    if "train_test_split" in joined:
-        return "Split Dataset"
-    if "class_weight" in joined or "compute_class_weight" in joined:
-        return "Cek Distribusi & Class Weights"
-    if "imagedatagenerator" in joined or "augmentation" in joined:
-        return "Generator Inputan Data Augmentation"
-    if "flow_from_dataframe" in joined:
-        return "Flow Generator"
-    if "sequential" in joined or "conv2d" in joined or "mobilenet" in joined or "efficientnet" in joined or "resnet" in joined:
-        return "Arsitektur Model"
-    if "compile" in joined and "optimizer" in joined:
-        return "Kompilasi Model"
-    if "earlystopping" in joined or "reducelronplateau" in joined or "callback" in joined:
-        return "Callback Model"
-    if ".fit" in joined or "fit(" in joined or "training" in joined:
-        return "Training Model"
-    if "classification_report" in joined:
-        return "Classification Report"
-    if "confusion_matrix" in joined or "heatmap" in joined:
-        return "Confusion Matrix"
-    if "evaluate" in joined:
-        return "Evaluasi Model"
-    if "history" in joined and ("accuracy" in joined or "loss" in joined):
-        return "Visualisasi Loss & Accuracy"
-    if ".save" in joined or "save_model" in joined:
-        return "Simpan Model"
-    if "predict" in joined or "prediction" in joined:
-        return "Visualisasi Prediksi"
-    if "gradio" in joined or "interface.launch" in joined or "gr.interface" in joined:
-        return "Deployment Gradio"
-    return "Bagian Notebook"
+    if not match:
+        return None
+    try:
+        return json.loads(match.group(0))
+    except Exception:
+        return None
 
 
-# =========================
+# ==========================================================
 # CHAT UMUM
-# =========================
-def normal_chat(message, history):
-    try:
-        ensure_api_key()
-        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-
-        # Gradio ChatInterface umumnya mengirim history berbentuk list tuple: [(user, bot), ...]
-        for item in history or []:
-            if isinstance(item, (list, tuple)) and len(item) >= 2:
-                user_msg, assistant_msg = item[0], item[1]
-                if user_msg:
-                    messages.append({"role": "user", "content": str(user_msg)})
-                if assistant_msg:
-                    messages.append({"role": "assistant", "content": str(assistant_msg)})
-            elif isinstance(item, dict):
-                role = item.get("role")
-                content = item.get("content")
-                if role and content:
-                    messages.append({"role": role, "content": str(content)})
-
-        messages.append({"role": "user", "content": message})
-        return ask_nvidia(messages, temperature=0.5, max_tokens=1200)
-    except Exception as e:
-        return f"Terjadi error: {e}"
-
+# ==========================================================
+def normal_chat(message: str, history: Optional[List[Any]]):
+    if not NVIDIA_API_KEY:
+        return "Error: NVIDIA_API_KEY belum diset di Hugging Face Secrets."
 
-# =========================
-# BACA NOTEBOOK IPYNB
-# =========================
-def extract_outputs(cell, temp_dir):
-    output_texts = []
-    image_paths = []
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
 
-    for output in cell.get("outputs", []):
-        output_type = output.get("output_type", "")
+    # Gradio 4 biasanya memberi history list tuple: [(user, assistant), ...]
+    for item in history or []:
+        if isinstance(item, (list, tuple)) and len(item) >= 2:
+            user_msg, assistant_msg = item[0], item[1]
+            if user_msg:
+                messages.append({"role": "user", "content": str(user_msg)})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": str(assistant_msg)})
 
-        if output_type == "stream":
-            output_texts.append(clean_text(output.get("text", "")))
+    messages.append({"role": "user", "content": message})
 
-        elif output_type in ["execute_result", "display_data"]:
-            data = output.get("data", {}) or {}
+    try:
+        return ask_nvidia(messages, temperature=0.5, max_tokens=1500)
+    except Exception as e:
+        return f"Terjadi error saat menghubungi NVIDIA API: {str(e)}"
 
-            if "text/plain" in data:
-                output_texts.append(clean_text(data.get("text/plain", "")))
 
-            for mime, ext in [("image/png", ".png"), ("image/jpeg", ".jpg")]:
-                if mime in data:
-                    raw = data[mime]
-                    if isinstance(raw, list):
-                        raw = "".join(raw)
-                    raw = str(raw).replace("\n", "")
-                    try:
-                        img_bytes = base64.b64decode(raw)
-                        img_path = Path(temp_dir) / f"output_{uuid.uuid4().hex}{ext}"
-                        img_path.write_bytes(img_bytes)
-                        image_paths.append(str(img_path))
-                    except Exception:
-                        pass
+def test_api_connection():
+    if not NVIDIA_API_KEY:
+        return "❌ NVIDIA_API_KEY belum diset di Hugging Face Secrets."
+    try:
+        result = ask_nvidia(
+            [
+                {"role": "system", "content": "Jawab singkat."},
+                {"role": "user", "content": "Balas hanya dengan kata: OK"},
+            ],
+            temperature=0,
+            max_tokens=20,
+        )
+        return f"✅ API aktif. Model: {NVIDIA_MODEL}. Respons: {result.strip()}"
+    except Exception as e:
+        return f"❌ API error: {str(e)}"
 
-        elif output_type == "error":
-            ename = output.get("ename", "Error")
-            evalue = output.get("evalue", "")
-            traceback = clean_text(output.get("traceback", []))
-            output_texts.append(clean_text(f"{ename}: {evalue}\n{traceback}"))
 
-    return clean_text("\n\n".join(x for x in output_texts if x)), image_paths
+# ==========================================================
+# PEMBACA IPYNB
+# ==========================================================
+def save_notebook_image(data_b64: str, suffix: str = ".png") -> Optional[str]:
+    """Menyimpan image base64 dari output notebook menjadi file sementara."""
+    try:
+        if isinstance(data_b64, list):
+            data_b64 = "".join(data_b64)
+        image_bytes = base64.b64decode(data_b64)
+        image = Image.open(io.BytesIO(image_bytes))
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+        image.save(tmp.name)
+        return tmp.name
+    except Exception:
+        return None
 
 
-def read_ipynb(ipynb_path, temp_dir):
+def read_ipynb(ipynb_path: str) -> List[Dict[str, Any]]:
+    """Membaca cell notebook, output teks, dan gambar output."""
     notebook = nbformat.read(ipynb_path, as_version=4)
-    sections = []
+    sections: List[Dict[str, Any]] = []
     last_markdown = ""
 
     for cell in notebook.cells:
         if cell.cell_type == "markdown":
-            md = clean_text(cell.get("source", ""))
-            if md:
-                last_markdown = md
+            text = (cell.source or "").strip()
+            if text:
+                last_markdown = text
+                sections.append(
+                    {
+                        "type": "markdown",
+                        "source": text,
+                        "context": text,
+                        "output_text": "",
+                        "images": [],
+                    }
+                )
             continue
 
-        if cell.cell_type == "code":
-            code = clean_text(cell.get("source", ""))
-            if not code:
-                continue
-
-            output_text, image_paths = extract_outputs(cell, temp_dir)
-            sections.append(
-                {
-                    "markdown_context": last_markdown,
-                    "code": code,
-                    "output_text": output_text,
-                    "image_paths": image_paths,
-                }
-            )
-            last_markdown = ""
+        if cell.cell_type != "code":
+            continue
+
+        code = (cell.source or "").strip()
+        if not code:
+            continue
+
+        output_texts: List[str] = []
+        image_paths: List[str] = []
+
+        for output in cell.get("outputs", []):
+            output_type = output.get("output_type")
+
+            if output_type == "stream":
+                output_texts.append(str(output.get("text", "")))
+
+            elif output_type in ["execute_result", "display_data"]:
+                data = output.get("data", {})
+
+                if "text/plain" in data:
+                    text_plain = data["text/plain"]
+                    if isinstance(text_plain, list):
+                        text_plain = "".join(text_plain)
+                    output_texts.append(str(text_plain))
+
+                if "image/png" in data:
+                    path = save_notebook_image(data["image/png"], ".png")
+                    if path:
+                        image_paths.append(path)
+
+                if "image/jpeg" in data:
+                    path = save_notebook_image(data["image/jpeg"], ".jpg")
+                    if path:
+                        image_paths.append(path)
+
+            elif output_type == "error":
+                ename = output.get("ename", "Error")
+                evalue = output.get("evalue", "")
+                traceback = output.get("traceback", [])
+                output_texts.append(f"{ename}: {evalue}\n" + "\n".join(traceback))
+
+        sections.append(
+            {
+                "type": "code",
+                "source": code,
+                "context": last_markdown,
+                "output_text": "\n".join(output_texts).strip(),
+                "images": image_paths,
+            }
+        )
 
     return sections
 
 
-# =========================
-# GENERATE PENJELASAN AI
-# =========================
-def summarize_code_section(code, output_text, markdown_context=""):
-    fallback_title = guess_title_from_code(code, markdown_context)
+def fallback_title_from_code(code: str, context: str = "") -> str:
+    text = f"{context}\n{code}".lower()
+
+    rules = [
+        ("import ", "Import Library"),
+        ("mount", "Mount Google Drive"),
+        ("zipfile", "Ekstrak Dataset"),
+        ("os.listdir", "Pembacaan Dataset"),
+        ("dataframe", "Memuat Data ke DataFrame"),
+        ("df.info", "Cek Informasi Data"),
+        ("train_test_split", "Split Dataset"),
+        ("compute_class_weight", "Cek Distribusi & Class Weights"),
+        ("imagedatagenerator", "Generator Inputan Data Augmentation"),
+        ("flow_from_dataframe", "Flow Generator"),
+        ("mobilenet", "Arsitektur Model MobileNet"),
+        ("sequential", "Arsitektur Model CNN"),
+        ("model.compile", "Kompilasi Model"),
+        ("earlystopping", "Kompilasi & Callback Model"),
+        ("model.fit", "Training Model"),
+        ("classification_report", "Classification Report"),
+        ("confusion_matrix", "Confusion Matrix"),
+        ("model.evaluate", "Evaluasi Model"),
+        ("plt.plot", "Visualisasi Loss & Accuracy"),
+        ("model.save", "Simpan Model"),
+        ("gradio", "Deployment dengan Gradio"),
+    ]
+
+    for keyword, title in rules:
+        if keyword in text:
+            return title
+    return "Bagian Notebook"
+
 
+def summarize_code_section(code: str, output_text: str, context: str = "") -> Tuple[str, str]:
     prompt = f"""
 {REPORT_STYLE_PROMPT}
 
-Konteks markdown sebelum kode, jika ada:
-```text
-{limit_text(markdown_context, 1000)}
+Konteks markdown sebelumnya:
+```txt
+{truncate_text(context, 1500)}
 ```
 
 Kode notebook:
 ```python
-{limit_text(code, 5000)}
+{truncate_text(code, 6000)}
 ```
 
 Output notebook:
-```text
-{limit_text(output_text, 2500)}
+```txt
+{truncate_text(output_text, 3500)}
 ```
-
-Jika judul bagian bisa ditebak, gunakan judul yang paling sesuai. Kandidat judul awal: {fallback_title}
-""".strip()
+"""
 
     try:
         result = ask_nvidia(
@@ -306,339 +322,250 @@ Jika judul bagian bisa ditebak, gunakan judul yang paling sesuai. Kandidat judul
                 {"role": "user", "content": prompt},
             ],
             temperature=0.25,
-            max_tokens=800,
+            max_tokens=900,
         )
         data = parse_json_from_model(result)
-        judul = clean_text(data.get("judul", fallback_title)) or fallback_title
-        penjelasan = clean_text(data.get("penjelasan", ""))
-        if not penjelasan:
-            penjelasan = "Penjelasannya: Pada tahap ini, kode digunakan untuk menjalankan salah satu proses dalam notebook Deep Learning."
-        if not penjelasan.lower().startswith("penjelasannya"):
-            penjelasan = f"Penjelasannya: {penjelasan}"
-        return judul, penjelasan
+        if data:
+            judul = str(data.get("judul") or fallback_title_from_code(code, context)).strip()
+            penjelasan = str(data.get("penjelasan") or "").strip()
+            if not penjelasan.lower().startswith("penjelasannya"):
+                penjelasan = "Penjelasannya: " + penjelasan
+            return judul, penjelasan
+        return fallback_title_from_code(code, context), result.strip()
     except Exception:
-        return fallback_title, "Penjelasannya: Pada tahap ini, kode digunakan untuk menjalankan salah satu proses dalam notebook Deep Learning. Penjelasan dibuat berdasarkan struktur kode yang tersedia."
-
-
-# =========================
-# FORMAT DOCX
-# =========================
-def set_run_font(run, size=12, bold=False, italic=False, name="Times New Roman"):
-    run.font.name = name
-    run._element.rPr.rFonts.set(qn("w:eastAsia"), name)
-    run.font.size = Pt(size)
-    run.bold = bold
-    run.italic = italic
-
-
-def set_cell_shading(cell, fill="F2F2F2"):
-    tc_pr = cell._tc.get_or_add_tcPr()
-    tc_pr.append(parse_xml(r'<w:shd {} w:fill="{}"/>'.format(nsdecls("w"), fill)))
+        judul = fallback_title_from_code(code, context)
+        penjelasan = (
+            "Penjelasannya: Bagian kode ini digunakan dalam proses pembuatan model Deep Learning. "
+            "Kode perlu dibaca bersama output notebook untuk mengetahui hasil yang diperoleh secara lebih detail."
+        )
+        return judul, penjelasan
 
 
-def set_cell_border(cell):
-    tc = cell._tc
-    tc_pr = tc.get_or_add_tcPr()
-    borders = OxmlElement("w:tcBorders")
-    for edge in ("top", "left", "bottom", "right"):
-        tag = OxmlElement(f"w:{edge}")
-        tag.set(qn("w:val"), "single")
-        tag.set(qn("w:sz"), "4")
-        tag.set(qn("w:space"), "0")
-        tag.set(qn("w:color"), "D9D9D9")
-        borders.append(tag)
-    tc_pr.append(borders)
+# ==========================================================
+# PEMBUAT DOCX
+# ==========================================================
+def set_document_style(doc: Document):
+    style = doc.styles["Normal"]
+    style.font.name = "Times New Roman"
+    style.font.size = Pt(12)
 
+    for section in doc.sections:
+        section.top_margin = Inches(1)
+        section.bottom_margin = Inches(0.8)
+        section.left_margin = Inches(1.2)
+        section.right_margin = Inches(1)
 
-def add_footer(section, kampus):
-    footer = section.footer
-    p = footer.paragraphs[0]
-    p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
-    r = p.add_run(kampus if kampus else "AI Assistant Mahasiswa")
-    set_run_font(r, size=9, italic=True)
-    r.font.color.rgb = RGBColor(0, 102, 153)
 
+def add_center_paragraph(doc: Document, text: str, bold: bool = True, size: int = 12):
+    p = doc.add_paragraph()
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    run = p.add_run(text)
+    run.bold = bold
+    run.font.name = "Times New Roman"
+    run.font.size = Pt(size)
+    return p
 
-def add_code_block(doc, text, max_chars=5000):
-    text = limit_text(text, max_chars)
-    if not text:
-        return
 
+def add_code_block(doc: Document, code: str):
+    code = truncate_text(code, 4500)
     table = doc.add_table(rows=1, cols=1)
-    table.autofit = True
+    table.style = "Table Grid"
     cell = table.cell(0, 0)
-    set_cell_shading(cell, "F7F7F7")
-    set_cell_border(cell)
-
-    p = cell.paragraphs[0]
-    p.paragraph_format.space_after = Pt(0)
-    p.paragraph_format.space_before = Pt(0)
+    paragraph = cell.paragraphs[0]
+    run = paragraph.add_run(code)
+    run.font.name = "Courier New"
+    run.font.size = Pt(8)
 
-    # bagi supaya Word tidak berat ketika code panjang
-    for i, chunk in enumerate(textwrap.wrap(text, width=110, replace_whitespace=False, drop_whitespace=False)):
-        if i > 0:
-            p.add_run("\n")
-        run = p.add_run(chunk)
-        set_run_font(run, size=8, name="Courier New")
 
-
-def add_normal_paragraph(doc, text, bold_prefix=None):
-    p = doc.add_paragraph()
-    p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
-    p.paragraph_format.space_after = Pt(6)
-    p.paragraph_format.line_spacing = 1.15
-
-    text = clean_text(text)
-    if bold_prefix and text.startswith(bold_prefix):
-        r1 = p.add_run(bold_prefix)
-        set_run_font(r1, bold=True)
-        r2 = p.add_run(text[len(bold_prefix):])
-        set_run_font(r2)
-    else:
-        r = p.add_run(text)
-        set_run_font(r)
-    return p
-
-
-def add_heading_numbered(doc, number, title):
+def add_output_block(doc: Document, output_text: str):
+    if not output_text.strip():
+        return
     p = doc.add_paragraph()
-    p.paragraph_format.space_before = Pt(8)
-    p.paragraph_format.space_after = Pt(4)
-    run = p.add_run(f"{number}. {title}")
-    set_run_font(run, size=13, bold=True)
-    return p
+    r = p.add_run("Output:")
+    r.bold = True
+    add_code_block(doc, output_text)
 
 
-def add_image(doc, image_path):
+def add_image_to_doc(doc: Document, image_path: str):
     try:
         p = doc.add_paragraph()
         p.alignment = WD_ALIGN_PARAGRAPH.CENTER
         run = p.add_run()
-        run.add_picture(image_path, width=Inches(5.7))
+        run.add_picture(image_path, width=Inches(5.6))
     except Exception:
-        # kalau gambar terlalu besar/format bermasalah, abaikan agar dokumen tetap jadi
+        # Jika gambar gagal dimasukkan, lewati agar pembuatan laporan tetap jalan.
         pass
 
 
-def build_docx(
-    sections,
-    judul_laporan,
-    nama,
-    nim,
-    dosen,
-    kelas,
-    prodi,
-    kampus,
-    tahun,
-    include_code=True,
-    include_output=True,
-    progress=None,
+def create_cover(
+    doc: Document,
+    judul_laporan: str,
+    nama: str,
+    nim: str,
+    dosen: str,
+    kelas: str,
+    anggota: str,
+    prodi: str,
+    kampus: str,
+    tahun: str,
 ):
-    doc = Document()
-
-    section = doc.sections[0]
-    section.top_margin = Inches(0.9)
-    section.bottom_margin = Inches(0.8)
-    section.left_margin = Inches(1.1)
-    section.right_margin = Inches(1.0)
-    add_footer(section, kampus)
+    add_center_paragraph(doc, "Laporan Deep Learning", bold=True, size=16)
+    add_center_paragraph(doc, judul_laporan.upper(), bold=True, size=14)
 
-    normal_style = doc.styles["Normal"]
-    normal_style.font.name = "Times New Roman"
-    normal_style._element.rPr.rFonts.set(qn("w:eastAsia"), "Times New Roman")
-    normal_style.font.size = Pt(12)
+    doc.add_paragraph("\n\n\n")
 
-    # COVER
-    p = doc.add_paragraph()
-    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    r = p.add_run("Laporan Deep Learning")
-    set_run_font(r, size=16, bold=True)
+    add_center_paragraph(doc, nama, bold=True)
+    add_center_paragraph(doc, f"NIM. {nim}", bold=True)
 
-    p = doc.add_paragraph()
-    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-    r = p.add_run((judul_laporan or "Laporan Deep Learning").upper())
-    set_run_font(r, size=14, bold=True)
+    doc.add_paragraph("")
+    add_center_paragraph(doc, "Dosen Mata kuliah", bold=True)
+    add_center_paragraph(doc, dosen, bold=True)
+    add_center_paragraph(doc, kelas, bold=True)
 
-    doc.add_paragraph("\n\n\n")
-
-    cover_lines = [
-        nama,
-        f"NIM. {nim}" if nim else "NIM.",
-        "",
-        "Dosen Mata kuliah",
-        dosen,
-        "",
-        kelas,
-    ]
-    for line in cover_lines:
-        p = doc.add_paragraph()
-        p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        r = p.add_run(line or "")
-        set_run_font(r, size=12, bold=True)
+    if anggota.strip():
+        doc.add_paragraph("")
+        add_center_paragraph(doc, anggota.upper(), bold=True)
 
     doc.add_paragraph("\n\n")
 
-    for line in [prodi, kampus, tahun]:
-        p = doc.add_paragraph()
-        p.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        r = p.add_run((line or "").upper())
-        set_run_font(r, size=12, bold=True)
+    add_center_paragraph(doc, prodi.upper(), bold=True)
+    add_center_paragraph(doc, kampus.upper(), bold=True)
+    add_center_paragraph(doc, tahun, bold=True)
 
     doc.add_page_break()
 
-    # ISI LAPORAN
-    total = max(len(sections), 1)
-    for idx, item in enumerate(sections, start=1):
-        if progress:
-            progress((idx - 1) / total, desc=f"Membuat penjelasan bagian {idx}/{total}...")
-
-        title, explanation = summarize_code_section(
-            item["code"],
-            item.get("output_text", ""),
-            item.get("markdown_context", ""),
-        )
-
-        add_heading_numbered(doc, idx, title)
 
-        if include_code:
-            add_code_block(doc, item["code"], max_chars=4500)
+def add_footer(doc: Document, kampus: str):
+    for section in doc.sections:
+        footer = section.footer
+        p = footer.paragraphs[0]
+        p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+        run = p.add_run(kampus)
+        run.italic = True
+        run.font.size = Pt(9)
 
-        for image_path in item.get("image_paths", []):
-            add_image(doc, image_path)
 
-        if include_output and item.get("output_text"):
-            out_title = doc.add_paragraph()
-            r = out_title.add_run("Output:")
-            set_run_font(r, bold=True)
-            add_code_block(doc, item["output_text"], max_chars=2500)
-
-        add_normal_paragraph(doc, explanation, bold_prefix="Penjelasannya:")
-
-    if progress:
-        progress(1.0, desc="Menyimpan dokumen DOCX...")
-
-    filename = sanitize_filename(judul_laporan or "laporan_deep_learning") + ".docx"
-    output_path = str(Path(tempfile.gettempdir()) / filename)
-    doc.save(output_path)
-    return output_path
-
-
-# =========================
-# GRADIO FUNCTION: BUAT DOCX
-# =========================
 def create_report_docx(
-    ipynb_file,
-    judul_laporan,
-    nama,
-    nim,
-    dosen,
-    kelas,
-    prodi,
-    kampus,
-    tahun,
-    include_code,
-    include_output,
-    progress=gr.Progress(track_tqdm=False),
+    ipynb_file: Any,
+    judul_laporan: str,
+    nama: str,
+    nim: str,
+    dosen: str,
+    kelas: str,
+    anggota: str,
+    prodi: str,
+    kampus: str,
+    tahun: str,
 ):
-    ensure_api_key()
-
-    if ipynb_file is None:
-        raise gr.Error("Upload file .ipynb terlebih dahulu.")
+    if not NVIDIA_API_KEY:
+        raise gr.Error("NVIDIA_API_KEY belum diset di Hugging Face Secrets.")
 
-    ipynb_path = getattr(ipynb_file, "name", None) or str(ipynb_file)
+    ipynb_path = get_uploaded_path(ipynb_file)
     if not ipynb_path.endswith(".ipynb"):
         raise gr.Error("File harus berformat .ipynb")
 
-    temp_dir = tempfile.mkdtemp(prefix="ipynb_outputs_")
-    progress(0, desc="Membaca file notebook...")
-    sections = read_ipynb(ipynb_path, temp_dir)
+    sections = read_ipynb(ipynb_path)
+    code_sections = [item for item in sections if item.get("type") == "code"]
+
+    if not code_sections:
+        raise gr.Error("Notebook tidak memiliki cell kode yang bisa dibuat menjadi laporan.")
 
-    if not sections:
-        raise gr.Error("Notebook tidak memiliki code cell yang bisa dibuat menjadi laporan.")
+    doc = Document()
+    set_document_style(doc)
+    add_footer(doc, kampus)
 
-    return build_docx(
-        sections=sections,
+    create_cover(
+        doc=doc,
         judul_laporan=judul_laporan,
         nama=nama,
         nim=nim,
         dosen=dosen,
         kelas=kelas,
+        anggota=anggota,
         prodi=prodi,
         kampus=kampus,
         tahun=tahun,
-        include_code=include_code,
-        include_output=include_output,
-        progress=progress,
     )
 
+    number = 1
+    total = len(code_sections)
 
-# =========================
-# UI HUGGING FACE SPACE
-# =========================
-custom_css = """
-.gradio-container {
-    max-width: 1100px !important;
-}
-"""
+    for item in code_sections:
+        code = item.get("source", "")
+        output_text = item.get("output_text", "")
+        context = item.get("context", "")
+        images = item.get("images", [])
+
+        judul, penjelasan = summarize_code_section(code, output_text, context)
+
+        heading = doc.add_paragraph()
+        heading_run = heading.add_run(f"{number}. {judul}")
+        heading_run.bold = True
+        heading_run.font.name = "Times New Roman"
+        heading_run.font.size = Pt(13)
 
-with gr.Blocks(title="AI Assistant Mahasiswa", css=custom_css) as demo:
+        add_code_block(doc, code)
+        add_output_block(doc, output_text)
+
+        for image_path in images[:4]:
+            add_image_to_doc(doc, image_path)
+
+        p = doc.add_paragraph()
+        p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+        r = p.add_run(penjelasan)
+        r.font.name = "Times New Roman"
+        r.font.size = Pt(12)
+
+        if number < total:
+            doc.add_paragraph("")
+        number += 1
+
+    output_name = safe_filename(judul_laporan)
+    output_path = str(Path(tempfile.gettempdir()) / f"{output_name}.docx")
+    doc.save(output_path)
+    return output_path
+
+
+# ==========================================================
+# UI GRADIO
+# ==========================================================
+with gr.Blocks(title="AI Assistant Mahasiswa NVIDIA") as demo:
+    gr.Markdown("# 🎓 AI Assistant Mahasiswa NVIDIA")
     gr.Markdown(
-        """
-# AI Assistant Mahasiswa
-Chatbot untuk membantu laporan, tugas kuliah, materi belajar, coding dasar, dan pembuatan laporan Deep Learning dari file `.ipynb`.
-        """
+        "Asisten AI untuk chat umum mahasiswa dan pembuatan laporan Deep Learning otomatis dari file `.ipynb` ke `.docx`."
     )
 
-    if not NVIDIA_API_KEY:
-        gr.Warning("NVIDIA_API_KEY belum diset. Tambahkan di Settings > Variables and secrets pada Hugging Face Space.")
-
     with gr.Tab("Chat Umum"):
+        gr.Markdown("Gunakan tab ini untuk bertanya tentang materi, tugas, coding, laporan, atau pertanyaan umum.")
         gr.ChatInterface(
             fn=normal_chat,
-            title="Chat AI",
-            description="Tanya apa saja: laporan, tugas kuliah, materi, coding, bahasa, dan pertanyaan umum.",
-            examples=[
-                "Bantu buatkan kerangka laporan praktikum Deep Learning.",
-                "Jelaskan CNN dengan bahasa sederhana.",
-                "Perbaiki kalimat ini agar lebih formal untuk laporan.",
-            ],
+            title="Chat AI Mahasiswa",
+            description="Tanya apa saja seputar kuliah, coding, laporan, Deep Learning, atau pertanyaan umum.",
         )
 
     with gr.Tab("Buat Laporan DOCX dari IPYNB"):
         gr.Markdown(
-            """
-Upload file `.ipynb`, isi data cover, lalu klik **Buat Laporan DOCX**.  
-Output yang keluar langsung berupa file Word `.docx`.
-            """
+            "Upload file `.ipynb` yang sudah dijalankan, isi data cover, lalu klik tombol untuk membuat laporan Word `.docx`."
         )
 
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column():
                 ipynb_file = gr.File(label="Upload File IPYNB", file_types=[".ipynb"])
-
                 judul_laporan = gr.Textbox(label="Judul Laporan", value="Klasifikasi Penyakit Mata")
                 nama = gr.Textbox(label="Nama", value="Hadid Zarid Nawfal")
                 nim = gr.Textbox(label="NIM", value="2355301079")
                 dosen = gr.Textbox(label="Dosen Mata Kuliah", value="Dr. Juni Nurma Sari, S.Kom., M.MT.")
                 kelas = gr.Textbox(label="Kelas", value="ILB")
+                anggota = gr.Textbox(label="Nama Anggota / Partner Opsional", value="")
                 prodi = gr.Textbox(label="Program Studi", value="Program Studi Teknik Informatika")
                 kampus = gr.Textbox(label="Kampus", value="Politeknik Caltex Riau")
                 tahun = gr.Textbox(label="Tahun", value="2025")
-
-                include_code = gr.Checkbox(label="Masukkan kode notebook ke laporan", value=True)
-                include_output = gr.Checkbox(label="Masukkan output teks/gambar notebook ke laporan", value=True)
-
                 btn = gr.Button("Buat Laporan DOCX", variant="primary")
 
-            with gr.Column(scale=1):
+            with gr.Column():
                 output_file = gr.File(label="Download Laporan DOCX", file_types=[".docx"])
                 gr.Markdown(
-                    """
-### Catatan
-- Jangan lupa jalankan notebook dulu sebelum di-upload agar output/grafik ikut tersimpan di file `.ipynb`.
-- AI tidak akan mengarang angka atau hasil evaluasi yang tidak ada di notebook.
-- Untuk API key, gunakan Secret bernama `NVIDIA_API_KEY`.
-                    """
+                    "**Catatan:** Notebook sebaiknya sudah dijalankan terlebih dahulu agar output, grafik, akurasi, loss, dan hasil evaluasi tersimpan di file `.ipynb`."
                 )
 
         btn.click(
@@ -650,15 +577,21 @@ Output yang keluar langsung berupa file Word `.docx`.
                 nim,
                 dosen,
                 kelas,
+                anggota,
                 prodi,
                 kampus,
                 tahun,
-                include_code,
-                include_output,
             ],
             outputs=output_file,
         )
 
+    with gr.Tab("Cek API"):
+        gr.Markdown("Gunakan tab ini untuk mengecek apakah NVIDIA API key dan model sudah benar.")
+        gr.Markdown(f"**Model saat ini:** `{NVIDIA_MODEL}`")
+        gr.Markdown(f"**Base URL:** `{NVIDIA_BASE_URL}`")
+        check_btn = gr.Button("Cek Koneksi NVIDIA API")
+        check_output = gr.Textbox(label="Status", lines=4)
+        check_btn.click(fn=test_api_connection, inputs=None, outputs=check_output)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue(max_size=20).launch()

packages.txt

@@ -0,0 +1 @@
+# Tidak wajib. Dibiarkan kosong karena aplikasi ini hanya butuh package Python.

requirements.txt

@@ -1,5 +1,6 @@
-gradio>=4.44.0
-openai>=1.40.0
-nbformat>=5.10.0
+gradio==4.44.1
+openai>=1.30.0
+nbformat>=5.10.4
 python-docx>=1.1.2
 pillow>=10.0.0
+audioop-lts>=0.2.1