feat: BrainWatches Python Analysis Service - sentiment, topics, summarize, similarity

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# HuggingFace Spaces exposes port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,14 +1,26 @@
 ---
-title: AnalisisNews
-emoji: 🐢
-colorFrom: yellow
+title: BrainWatches Analysis Service
+emoji: 📊
+colorFrom: green
 colorTo: indigo
-sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
-short_description: analisisNews
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# BrainWatches Python Analysis Service
+
+FastAPI microservice untuk analisis NLP berita Indonesia.
+
+## Endpoints
+
+- `GET /health` — Health check
+- `POST /sentiment` — Analisis sentimen (lexicon / IndoBERT)
+- `POST /topics` — Topic modeling otomatis (TF-IDF + KMeans)
+- `POST /summarize` — Ringkasan extractive (TextRank)
+- `POST /similarity` — Kemiripan semantik (cosine similarity)
+
+## Auth
+
+Semua endpoint (kecuali `/health`) butuh header `X-Service-Token`.
+Set via environment variable `PY_SERVICE_TOKEN` di Settings HuggingFace Space.

app/analyzers/sentiment.py

@@ -0,0 +1,91 @@
+"""
+Sentiment analyzer.
+- mode "light": lexicon-based sederhana (cepat, tanpa dependency berat)
+- mode "transformer": IndoBERT/RoBERTa (akurat, butuh torch + transformers)
+"""
+from typing import List, Dict
+from app.config import settings
+
+# Lexicon ringan Bahasa Indonesia (subset). Bisa diperluas.
+POSITIVE_WORDS = {
+    "baik", "bagus", "hebat", "sukses", "untung", "naik", "tumbuh", "positif",
+    "menang", "juara", "prestasi", "maju", "berhasil", "setuju", "dukung",
+    "apresiasi", "optimis", "damai", "sehat", "aman", "puas", "senang",
+    "bangga", "harapan", "solusi", "peluang", "inovasi", "manfaat", "efektif",
+}
+NEGATIVE_WORDS = {
+    "buruk", "jelek", "gagal", "rugi", "turun", "anjlok", "negatif", "kalah",
+    "krisis", "masalah", "korupsi", "tewas", "meninggal", "bencana", "konflik",
+    "protes", "demo", "tolak", "kecam", "marah", "takut", "khawatir", "sakit",
+    "bahaya", "ancaman", "kritik", "lemah", "lambat", "mahal", "sulit", "rusak",
+    "kecewa", "tertekan", "korban", "darurat",
+}
+
+_pipeline = None
+
+
+def _load_transformer():
+    global _pipeline
+    if _pipeline is None:
+        from transformers import pipeline
+        _pipeline = pipeline(
+            "text-classification",
+            model=settings.SENTIMENT_MODEL,
+            truncation=True,
+            max_length=512,
+        )
+    return _pipeline
+
+
+def _normalize_label(label: str) -> str:
+    low = label.lower()
+    if "pos" in low:
+        return "positive"
+    if "neg" in low:
+        return "negative"
+    return "neutral"
+
+
+def analyze_light(text: str) -> Dict:
+    tokens = [t.strip(".,!?;:\"'()[]").lower() for t in text.split()]
+    pos = sum(1 for t in tokens if t in POSITIVE_WORDS)
+    neg = sum(1 for t in tokens if t in NEGATIVE_WORDS)
+    total = pos + neg
+
+    if total == 0:
+        return {"sentiment": "neutral", "score": 0.0, "confidence": 0.5}
+
+    score = round((pos - neg) / total, 3)
+    if score > 0.15:
+        sentiment = "positive"
+    elif score < -0.15:
+        sentiment = "negative"
+    else:
+        sentiment = "neutral"
+
+    confidence = round(min(1.0, total / 10), 3)
+    return {"sentiment": sentiment, "score": score, "confidence": confidence}
+
+
+def analyze_transformer(texts: List[str]) -> List[Dict]:
+    pipe = _load_transformer()
+    outputs = pipe(texts)
+    results = []
+    for out in outputs:
+        label = _normalize_label(out["label"])
+        conf = round(float(out["score"]), 3)
+        score = conf if label == "positive" else (-conf if label == "negative" else 0.0)
+        results.append({"sentiment": label, "score": round(score, 3), "confidence": conf})
+    return results
+
+
+def analyze_batch(items: List) -> List[Dict]:
+    if settings.MODEL_MODE == "transformer":
+        try:
+            texts = [it.text[:2000] for it in items]
+            tf = analyze_transformer(texts)
+            return [{"id": it.id, **r} for it, r in zip(items, tf)]
+        except Exception:
+            # Fallback ke light bila transformer gagal load
+            pass
+    return [{"id": it.id, **analyze_light(it.text)} for it in items]

app/analyzers/similarity.py

@@ -0,0 +1,45 @@
+"""
+Semantic similarity via TF-IDF + cosine (scikit-learn).
+Cari pasangan artikel mirip secara makna.
+"""
+from typing import List, Dict
+import re
+
+INDO_STOPWORDS = {
+    "yang", "di", "ke", "dari", "untuk", "pada", "dengan", "ini", "itu", "dan",
+    "atau", "adalah", "akan", "juga", "tidak", "para", "oleh", "sebagai",
+}
+
+
+def _clean(text: str) -> str:
+    text = re.sub(r"[^a-zA-Z\s]", " ", text.lower())
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def find_similar_pairs(items: List, threshold: float = 0.3) -> List[Dict]:
+    if len(items) < 2:
+        return []
+
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.metrics.pairwise import cosine_similarity
+
+    docs = [_clean(it.text) for it in items]
+    ids = [it.id for it in items]
+
+    vectorizer = TfidfVectorizer(max_features=3000, stop_words=list(INDO_STOPWORDS))
+    try:
+        X = vectorizer.fit_transform(docs)
+    except ValueError:
+        return []
+
+    sim = cosine_similarity(X)
+    pairs = []
+    n = len(ids)
+    for i in range(n):
+        for j in range(i + 1, n):
+            score = float(sim[i, j])
+            if score >= threshold:
+                pairs.append({"id_a": ids[i], "id_b": ids[j], "score": round(score, 3)})
+
+    pairs.sort(key=lambda p: p["score"], reverse=True)
+    return pairs[:500]

app/analyzers/summary.py

@@ -0,0 +1,32 @@
+"""
+Extractive summarization via TextRank (sumy).
+Ringan, tanpa model berat.
+"""
+from typing import List, Dict
+import re
+
+
+def summarize(text: str, num_sentences: int = 3) -> Dict:
+    text = (text or "").strip()
+    if not text:
+        return {"summary": "", "sentences": []}
+
+    try:
+        from sumy.parsers.plaintext import PlaintextParser
+        from sumy.nlp.tokenizers import Tokenizer
+        from sumy.summarizers.text_rank import TextRankSummarizer
+
+        parser = PlaintextParser.from_string(text, Tokenizer("english"))
+        summarizer = TextRankSummarizer()
+        sentences = [str(s) for s in summarizer(parser.document, num_sentences)]
+        if sentences:
+            return {"summary": " ".join(sentences), "sentences": sentences}
+    except Exception:
+        pass
+
+    # Fallback: ambil N kalimat terpanjang (proxy informativeness)
+    raw = re.split(r"(?<=[.!?])\s+", text)
+    raw = [s.strip() for s in raw if len(s.strip()) > 40]
+    raw.sort(key=len, reverse=True)
+    picked = raw[:num_sentences]
+    return {"summary": " ".join(picked), "sentences": picked}

app/analyzers/topics.py

@@ -0,0 +1,71 @@
+"""
+Topic modeling via TF-IDF + KMeans (scikit-learn).
+Auto-discover topik tanpa kategori predefined.
+"""
+from typing import List, Dict
+import re
+
+INDO_STOPWORDS = {
+    "yang", "di", "ke", "dari", "untuk", "pada", "dengan", "ini", "itu", "dan",
+    "atau", "adalah", "akan", "juga", "tidak", "para", "oleh", "sebagai",
+    "dalam", "tersebut", "ada", "dapat", "bisa", "harus", "lebih", "sangat",
+    "telah", "sudah", "masih", "hanya", "saja", "karena", "namun", "tetapi",
+    "tapi", "saat", "ketika", "setelah", "sebelum", "antara", "hingga",
+    "republika", "okezone", "detik", "kompas", "tribunnews", "cnn", "tempo",
+    "antaranews", "antara", "merdeka", "kumparan", "news", "com",
+}
+
+
+def _clean(text: str) -> str:
+    text = re.sub(r"[^a-zA-Z\s]", " ", text.lower())
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def discover_topics(items: List, num_topics: int = 8) -> List[Dict]:
+    if len(items) < num_topics:
+        num_topics = max(2, len(items) // 2)
+    if len(items) < 4:
+        return []
+
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    from sklearn.cluster import KMeans
+    import numpy as np
+
+    docs = [_clean(it.text) for it in items]
+    ids = [it.id for it in items]
+
+    vectorizer = TfidfVectorizer(
+        max_features=2000,
+        stop_words=list(INDO_STOPWORDS),
+        min_df=2,
+        ngram_range=(1, 2),
+    )
+    try:
+        X = vectorizer.fit_transform(docs)
+    except ValueError:
+        return []
+
+    if X.shape[1] == 0:
+        return []
+
+    k = min(num_topics, X.shape[0])
+    km = KMeans(n_clusters=k, random_state=42, n_init=10)
+    labels = km.fit_predict(X)
+
+    terms = vectorizer.get_feature_names_out()
+    order_centroids = km.cluster_centers_.argsort()[:, ::-1]
+
+    topics = []
+    for topic_id in range(k):
+        keywords = [terms[ind] for ind in order_centroids[topic_id, :8]]
+        member_ids = [ids[i] for i in range(len(ids)) if labels[i] == topic_id]
+        topics.append({
+            "topic_id": topic_id,
+            "label": ", ".join(keywords[:3]),
+            "keywords": keywords,
+            "article_ids": member_ids,
+            "size": len(member_ids),
+        })
+
+    topics.sort(key=lambda t: t["size"], reverse=True)
+    return topics

app/config.py

@@ -0,0 +1,21 @@
+"""Konfigurasi service via environment variables."""
+import os
+
+
+class Settings:
+    # Token sederhana untuk otentikasi antara Laravel <-> Python service
+    API_TOKEN: str = os.getenv("PY_SERVICE_TOKEN", "change-this-token")
+
+    # Mode model: "light" (sklearn/lexicon, cepat) atau "transformer" (IndoBERT, akurat)
+    MODEL_MODE: str = os.getenv("PY_MODEL_MODE", "light")
+
+    # Nama model transformer (dipakai bila MODEL_MODE=transformer)
+    SENTIMENT_MODEL: str = os.getenv(
+        "PY_SENTIMENT_MODEL", "w11wo/indonesian-roberta-base-sentiment-classifier"
+    )
+
+    HOST: str = os.getenv("PY_HOST", "0.0.0.0")
+    PORT: int = int(os.getenv("PY_PORT", "7860"))
+
+
+settings = Settings()

app/main.py

@@ -0,0 +1,70 @@
+"""
+BrainWatches Python Analysis Service
+====================================
+FastAPI microservice untuk analisis NLP lanjutan (sentiment transformer,
+topic modeling, summarization, semantic similarity).
+
+Dipanggil oleh Laravel via HTTP. Otentikasi via header X-Service-Token.
+
+Jalankan:
+    uvicorn app.main:app --host 0.0.0.0 --port 8001
+"""
+from fastapi import FastAPI, Header, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import settings
+from app.schemas import (
+    SentimentRequest, SentimentResponse,
+    SummarizeRequest, SummarizeResponse,
+    TopicRequest, TopicResponse,
+    SimilarityRequest, SimilarityResponse,
+)
+from app.analyzers import sentiment, topics, summary, similarity
+
+app = FastAPI(title="BrainWatches Analysis Service", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+def verify_token(x_service_token: str = Header(default="")):
+    if x_service_token != settings.API_TOKEN:
+        raise HTTPException(status_code=401, detail="Invalid service token")
+    return True
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "model_mode": settings.MODEL_MODE}
+
+
+@app.post("/sentiment", response_model=SentimentResponse, dependencies=[Depends(verify_token)])
+def sentiment_endpoint(req: SentimentRequest):
+    results = sentiment.analyze_batch(req.items)
+    return {"results": results, "model_mode": settings.MODEL_MODE}
+
+
+@app.post("/summarize", response_model=SummarizeResponse, dependencies=[Depends(verify_token)])
+def summarize_endpoint(req: SummarizeRequest):
+    return summary.summarize(req.text, req.sentences)
+
+
+@app.post("/topics", response_model=TopicResponse, dependencies=[Depends(verify_token)])
+def topics_endpoint(req: TopicRequest):
+    result = topics.discover_topics(req.items, req.num_topics)
+    return {"topics": result, "model_mode": settings.MODEL_MODE}
+
+
+@app.post("/similarity", response_model=SimilarityResponse, dependencies=[Depends(verify_token)])
+def similarity_endpoint(req: SimilarityRequest):
+    pairs = similarity.find_similar_pairs(req.items, req.threshold)
+    return {"pairs": pairs}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host=settings.HOST, port=settings.PORT, reload=True)

app/schemas.py

@@ -0,0 +1,67 @@
+"""Pydantic schemas untuk request/response."""
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class TextItem(BaseModel):
+    id: int
+    text: str
+
+
+class SentimentRequest(BaseModel):
+    items: List[TextItem]
+
+
+class SentimentResult(BaseModel):
+    id: int
+    sentiment: str  # positive | negative | neutral
+    score: float    # -1.0 .. 1.0
+    confidence: float
+
+
+class SentimentResponse(BaseModel):
+    results: List[SentimentResult]
+    model_mode: str
+
+
+class SummarizeRequest(BaseModel):
+    text: str
+    sentences: int = 3
+
+
+class SummarizeResponse(BaseModel):
+    summary: str
+    sentences: List[str]
+
+
+class TopicRequest(BaseModel):
+    items: List[TextItem]
+    num_topics: int = 8
+
+
+class TopicCluster(BaseModel):
+    topic_id: int
+    label: str
+    keywords: List[str]
+    article_ids: List[int]
+    size: int
+
+
+class TopicResponse(BaseModel):
+    topics: List[TopicCluster]
+    model_mode: str
+
+
+class SimilarityRequest(BaseModel):
+    items: List[TextItem]
+    threshold: float = 0.3
+
+
+class SimilarityPair(BaseModel):
+    id_a: int
+    id_b: int
+    score: float
+
+
+class SimilarityResponse(BaseModel):
+    pairs: List[SimilarityPair]

requirements.txt

@@ -0,0 +1,18 @@
+# BrainWatches Python Analysis Service
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+pydantic==2.10.4
+
+# NLP ringan (default, cepat, tanpa GPU)
+scikit-learn==1.6.1
+numpy==2.2.1
+
+# Opsional — model transformer Indonesia (IndoBERT). Uncomment bila ingin akurasi tinggi.
+# Membutuhkan ~2GB disk + RAM lebih besar.
+# torch==2.5.1
+# transformers==4.48.0
+# sentencepiece==0.2.0
+
+# Summarization & similarity ringan
+sumy==0.11.0
+nltk==3.9.1