feat: add emotion, framing, fake-score, opinion-fact endpoints

app/analyzers/emotion.py

@@ -0,0 +1,46 @@
+"""
+Emotion detection granular.
+Deteksi emosi: anger, fear, joy, sadness, surprise, disgust, trust, anticipation.
+"""
+from typing import List, Dict
+import re
+
+# Lexicon emosi Bahasa Indonesia (extensible)
+EMOTION_LEXICON: Dict[str, List[str]] = {
+    "anger": ["marah", "murka", "geram", "berang", "emosi", "kesal", "jengkel", "protes", "demo", "kecam", "tolak", "rusuh", "amuk"],
+    "fear": ["takut", "khawatir", "cemas", "panik", "ancaman", "bahaya", "waspada", "darurat", "teror", "ngeri", "was-was", "resah"],
+    "joy": ["senang", "gembira", "bahagia", "sukses", "juara", "menang", "prestasi", "bangga", "puas", "optimis", "harapan", "selebrasi"],
+    "sadness": ["sedih", "duka", "meninggal", "tewas", "korban", "tragis", "pilu", "menderita", "kehilangan", "bela sungkawa", "nestapa"],
+    "surprise": ["kejutan", "mendadak", "tiba-tiba", "mengejutkan", "tak terduga", "heboh", "viral", "gempar", "terungkap", "ternyata"],
+    "disgust": ["jijik", "muak", "korupsi", "skandal", "busuk", "curang", "manipulasi", "penipuan", "menjijikkan", "tercela"],
+    "trust": ["percaya", "yakin", "aman", "terpercaya", "jaminan", "komitmen", "konsisten", "transparan", "akuntabel", "integritas"],
+    "anticipation": ["harap", "rencana", "siap", "target", "proyeksi", "prediksi", "antisipasi", "agenda", "akan", "berencana"],
+}
+
+
+def detect_emotions(text: str) -> Dict[str, float]:
+    text_lower = text.lower()
+    tokens = re.findall(r'\b\w+\b', text_lower)
+    token_set = set(tokens)
+    total_tokens = max(len(tokens), 1)
+
+    scores = {}
+    for emotion, keywords in EMOTION_LEXICON.items():
+        hits = sum(1 for kw in keywords if kw in text_lower or kw in token_set)
+        scores[emotion] = round(hits / total_tokens * 10, 3)  # normalized
+
+    return scores
+
+
+def analyze_batch(items: List) -> List[Dict]:
+    results = []
+    for item in items:
+        scores = detect_emotions(item.text)
+        dominant = max(scores, key=scores.get) if any(v > 0 for v in scores.values()) else "neutral"
+        results.append({
+            "id": item.id,
+            "emotions": scores,
+            "dominant_emotion": dominant,
+            "dominant_score": scores.get(dominant, 0),
+        })
+    return results

app/analyzers/fakescore.py

@@ -0,0 +1,83 @@
+"""
+Fake news score (heuristik).
+Skor 0-100 indikasi potensi hoax/misinformasi berdasarkan pola teks.
+"""
+from typing import List, Dict
+import re
+
+# Indikator clickbait/hoax
+HOAX_INDICATORS = [
+    "terungkap", "ternyata", "rahasia", "viral", "heboh", "bikin",
+    "terbongkar", "fakta mencengangkan", "anda harus tahu",
+    "jangan sampai", "ini dia", "wow", "gempar",
+]
+
+CREDIBILITY_MARKERS = [
+    "menurut", "berdasarkan", "data", "riset", "penelitian",
+    "sumber", "narasumber", "konfirmasi", "verifikasi", "resmi",
+]
+
+
+def calculate_fake_score(text: str, title: str = "") -> Dict:
+    text_lower = (title + " " + text).lower()
+    score = 0
+    reasons = []
+
+    # 1. Kata-kata pemicu hoax di judul
+    title_lower = title.lower()
+    hoax_hits = sum(1 for w in HOAX_INDICATORS if w in title_lower)
+    if hoax_hits > 0:
+        score += min(30, hoax_hits * 15)
+        reasons.append(f"{hoax_hits} kata pemicu hoax")
+
+    # 2. Tanda seru/tanya berlebihan
+    excl = title.count("!") + title.count("?")
+    if excl > 1:
+        score += min(15, excl * 7)
+        reasons.append(f"{excl} tanda seru/tanya")
+
+    # 3. ALL CAPS
+    caps = len(re.findall(r'\b[A-Z]{3,}\b', title))
+    if caps > 1:
+        score += min(15, caps * 7)
+        reasons.append(f"{caps} kata KAPITAL")
+
+    # 4. Tidak ada sumber/narasumber
+    cred_hits = sum(1 for w in CREDIBILITY_MARKERS if w in text_lower)
+    if cred_hits == 0:
+        score += 20
+        reasons.append("tidak ada sumber terverifikasi")
+    elif cred_hits >= 3:
+        score -= 10
+        reasons.append(f"{cred_hits} marker kredibilitas")
+
+    # 5. Teks sangat pendek (kurang substansi)
+    word_count = len(text.split())
+    if word_count < 50:
+        score += 15
+        reasons.append("konten sangat pendek")
+
+    # 6. Banyak klaim tanpa bukti (kalimat deklaratif tanpa attributor)
+    sentences = re.split(r'[.!?]', text)
+    declarative = sum(1 for s in sentences if len(s.strip()) > 20 and not any(m in s.lower() for m in CREDIBILITY_MARKERS))
+    ratio = declarative / max(len(sentences), 1)
+    if ratio > 0.8:
+        score += 10
+        reasons.append("mayoritas klaim tanpa atribusi")
+
+    score = max(0, min(100, score))
+    level = "tinggi" if score >= 60 else "sedang" if score >= 30 else "rendah"
+
+    return {"score": score, "level": level, "reasons": reasons}
+
+
+def analyze_batch(items: List) -> List[Dict]:
+    results = []
+    for item in items:
+        # Pisah title dari text (asumsi: kalimat pertama = title)
+        parts = item.text.split(". ", 1)
+        title = parts[0] if len(parts) > 1 else ""
+        content = parts[1] if len(parts) > 1 else item.text
+        result = calculate_fake_score(content, title)
+        results.append({"id": item.id, **result})
+    return results

app/analyzers/framing.py

@@ -0,0 +1,47 @@
+"""
+Narrative framing detection.
+Identifikasi angle/frame yang digunakan media dalam meliput suatu berita.
+"""
+from typing import List, Dict
+import re
+
+# Frame categories berdasarkan teori framing media
+FRAME_PATTERNS: Dict[str, List[str]] = {
+    "conflict": ["konflik", "versus", "lawan", "sengketa", "pertentangan", "tuduh", "serang", "bantah", "polemik", "debat", "perang"],
+    "human_interest": ["korban", "keluarga", "anak", "ibu", "kisah", "cerita", "perjuangan", "nasib", "derita", "harapan hidup"],
+    "economic": ["rupiah", "inflasi", "harga", "ekonomi", "bisnis", "investasi", "saham", "anggaran", "pajak", "untung", "rugi", "pasar"],
+    "morality": ["etika", "moral", "haram", "halal", "dosa", "adil", "korupsi", "integritas", "tanggung jawab", "amanah"],
+    "attribution": ["pemerintah", "presiden", "menteri", "DPR", "partai", "kebijakan", "regulasi", "aturan", "instruksi", "perintah"],
+    "solution": ["solusi", "program", "langkah", "upaya", "strategi", "inovasi", "rencana", "pembangunan", "perbaikan", "reformasi"],
+    "sensational": ["viral", "heboh", "gempar", "terungkap", "rahasia", "skandal", "mencengangkan", "bikin", "wow", "ternyata"],
+}
+
+
+def detect_framing(text: str) -> Dict:
+    text_lower = text.lower()
+    scores = {}
+
+    for frame, keywords in FRAME_PATTERNS.items():
+        hits = sum(1 for kw in keywords if kw in text_lower)
+        scores[frame] = hits
+
+    total = sum(scores.values())
+    if total == 0:
+        return {"frames": {k: 0.0 for k in FRAME_PATTERNS}, "dominant_frame": "neutral", "score": 0.0}
+
+    normalized = {k: round(v / total, 3) for k, v in scores.items()}
+    dominant = max(scores, key=scores.get)
+
+    return {
+        "frames": normalized,
+        "dominant_frame": dominant,
+        "score": round(scores[dominant] / total, 3),
+    }
+
+
+def analyze_batch(items: List) -> List[Dict]:
+    results = []
+    for item in items:
+        framing = detect_framing(item.text)
+        results.append({"id": item.id, **framing})
+    return results

app/analyzers/opinionfact.py

@@ -0,0 +1,68 @@
+"""
+Opinion vs Fact classifier.
+Klasifikasi apakah artikel bersifat opini/editorial atau berita faktual.
+"""
+from typing import List, Dict
+import re
+
+OPINION_MARKERS = [
+    "menurut saya", "saya rasa", "seharusnya", "sebaiknya", "idealnya",
+    "opini", "editorial", "kolom", "perspektif", "pandangan",
+    "hemat saya", "saya pikir", "kita harus", "perlu diakui",
+    "jelas bahwa", "tidak bisa dipungkiri", "menariknya",
+]
+
+FACT_MARKERS = [
+    "berdasarkan data", "menurut", "kata", "ujar", "ungkap",
+    "dilaporkan", "tercatat", "statistik", "survei", "rilis",
+    "laporan", "konferensi pers", "siaran pers", "resmi",
+    "diumumkan", "ditetapkan", "diresmikan",
+]
+
+SUBJECTIVE_WORDS = [
+    "terbaik", "terburuk", "luar biasa", "mengecewakan", "menyedihkan",
+    "mengesankan", "fantastis", "mengerikan", "sempurna", "parah",
+    "indah", "jelek", "hebat", "bodoh", "cerdas",
+]
+
+
+def classify(text: str) -> Dict:
+    text_lower = text.lower()
+
+    opinion_hits = sum(1 for m in OPINION_MARKERS if m in text_lower)
+    fact_hits = sum(1 for m in FACT_MARKERS if m in text_lower)
+    subjective_hits = sum(1 for w in SUBJECTIVE_WORDS if w in text_lower)
+
+    opinion_score = opinion_hits * 3 + subjective_hits * 2
+    fact_score = fact_hits * 3
+
+    total = opinion_score + fact_score
+    if total == 0:
+        return {"classification": "unknown", "opinion_pct": 50, "fact_pct": 50, "confidence": 0}
+
+    opinion_pct = round((opinion_score / total) * 100)
+    fact_pct = 100 - opinion_pct
+
+    if opinion_pct > 60:
+        classification = "opinion"
+    elif fact_pct > 60:
+        classification = "fact"
+    else:
+        classification = "mixed"
+
+    confidence = round(abs(opinion_pct - 50) / 50, 2)
+
+    return {
+        "classification": classification,
+        "opinion_pct": opinion_pct,
+        "fact_pct": fact_pct,
+        "confidence": confidence,
+    }
+
+
+def analyze_batch(items: List) -> List[Dict]:
+    results = []
+    for item in items:
+        result = classify(item.text)
+        results.append({"id": item.id, **result})
+    return results

app/main.py

@@ -1,13 +1,10 @@
 """
 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.
+FastAPI microservice untuk analisis NLP lanjutan.
 
 Jalankan:
-    uvicorn app.main:app --host 0.0.0.0 --port 8001
+    uvicorn app.main:app --host 0.0.0.0 --port 7860
 """
 from fastapi import FastAPI, Header, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
@@ -18,10 +15,12 @@ from app.schemas import (
     SummarizeRequest, SummarizeResponse,
     TopicRequest, TopicResponse,
     SimilarityRequest, SimilarityResponse,
+    TextItemsRequest, EmotionResponse,
+    FramingResponse, FakeScoreResponse, OpinionFactResponse,
 )
-from app.analyzers import sentiment, topics, summary, similarity
+from app.analyzers import sentiment, topics, summary, similarity, emotion, framing, fakescore, opinionfact
 
-app = FastAPI(title="BrainWatches Analysis Service", version="1.0.0")
+app = FastAPI(title="BrainWatches Analysis Service", version="1.1.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -39,7 +38,7 @@ def verify_token(x_service_token: str = Header(default="")):
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "model_mode": settings.MODEL_MODE}
+    return {"status": "ok", "model_mode": settings.MODEL_MODE, "version": "1.1.0"}
 
 
 @app.post("/sentiment", response_model=SentimentResponse, dependencies=[Depends(verify_token)])
@@ -65,6 +64,30 @@ def similarity_endpoint(req: SimilarityRequest):
     return {"pairs": pairs}
 
 
+@app.post("/emotion", response_model=EmotionResponse, dependencies=[Depends(verify_token)])
+def emotion_endpoint(req: TextItemsRequest):
+    results = emotion.analyze_batch(req.items)
+    return {"results": results}
+
+
+@app.post("/framing", response_model=FramingResponse, dependencies=[Depends(verify_token)])
+def framing_endpoint(req: TextItemsRequest):
+    results = framing.analyze_batch(req.items)
+    return {"results": results}
+
+
+@app.post("/fake-score", response_model=FakeScoreResponse, dependencies=[Depends(verify_token)])
+def fake_score_endpoint(req: TextItemsRequest):
+    results = fakescore.analyze_batch(req.items)
+    return {"results": results}
+
+
+@app.post("/opinion-fact", response_model=OpinionFactResponse, dependencies=[Depends(verify_token)])
+def opinion_fact_endpoint(req: TextItemsRequest):
+    results = opinionfact.analyze_batch(req.items)
+    return {"results": results}
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run("app.main:app", host=settings.HOST, port=settings.PORT, reload=True)

app/schemas.py

@@ -1,5 +1,5 @@
 """Pydantic schemas untuk request/response."""
-from typing import List, Optional
+from typing import List, Dict, Optional
 from pydantic import BaseModel
 
 
@@ -8,14 +8,22 @@ class TextItem(BaseModel):
     text: str
 
 
+# === Shared request ===
+
+class TextItemsRequest(BaseModel):
+    items: List[TextItem]
+
+
+# === Sentiment ===
+
 class SentimentRequest(BaseModel):
     items: List[TextItem]
 
 
 class SentimentResult(BaseModel):
     id: int
-    sentiment: str  # positive | negative | neutral
-    score: float    # -1.0 .. 1.0
+    sentiment: str
+    score: float
     confidence: float
 
 
@@ -24,6 +32,8 @@ class SentimentResponse(BaseModel):
     model_mode: str
 
 
+# === Summarize ===
+
 class SummarizeRequest(BaseModel):
     text: str
     sentences: int = 3
@@ -34,6 +44,8 @@ class SummarizeResponse(BaseModel):
     sentences: List[str]
 
 
+# === Topics ===
+
 class TopicRequest(BaseModel):
     items: List[TextItem]
     num_topics: int = 8
@@ -52,6 +64,8 @@ class TopicResponse(BaseModel):
     model_mode: str
 
 
+# === Similarity ===
+
 class SimilarityRequest(BaseModel):
     items: List[TextItem]
     threshold: float = 0.3
@@ -65,3 +79,56 @@ class SimilarityPair(BaseModel):
 
 class SimilarityResponse(BaseModel):
     pairs: List[SimilarityPair]
+
+
+# === Emotion ===
+
+class EmotionResult(BaseModel):
+    id: int
+    emotions: Dict[str, float]
+    dominant_emotion: str
+    dominant_score: float
+
+
+class EmotionResponse(BaseModel):
+    results: List[EmotionResult]
+
+
+# === Framing ===
+
+class FramingResult(BaseModel):
+    id: int
+    frames: Dict[str, float]
+    dominant_frame: str
+    score: float
+
+
+class FramingResponse(BaseModel):
+    results: List[FramingResult]
+
+
+# === Fake Score ===
+
+class FakeScoreResult(BaseModel):
+    id: int
+    score: int
+    level: str
+    reasons: List[str]
+
+
+class FakeScoreResponse(BaseModel):
+    results: List[FakeScoreResult]
+
+
+# === Opinion vs Fact ===
+
+class OpinionFactResult(BaseModel):
+    id: int
+    classification: str
+    opinion_pct: int
+    fact_pct: int
+    confidence: float
+
+
+class OpinionFactResponse(BaseModel):
+    results: List[OpinionFactResult]