Upload 3 files

app.py.py

@@ -0,0 +1,118 @@
+from fastapi import FastAPI, Depends, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.orm import Session
+from typing import List
+import database, schemas, moderator
+
+# Init DB
+database.init_db()
+
+app = FastAPI(title="SafeStream API")
+
+# Allow all origins for dev
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+def get_db():
+    db = database.SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@app.on_event("startup")
+def startup_event():
+    # Seed data if empty
+    db = database.SessionLocal()
+    if db.query(database.Video).count() == 0:
+        # Using real YouTube IDs for the iframe
+        seed_videos = [
+            database.Video(title="Daily Vlog #102", url="dQw4w9WgXcQ", description="Just another day in the life. Comment below!"),
+            database.Video(title="Gaming Highlights", url="jNQXAC9IVRw", description="Insane plays from last night."),
+            database.Video(title="Relaxing Rain Sounds", url="q76bMs-NwRk", description="Sleep aid.")
+        ]
+        db.add_all(seed_videos)
+        db.commit()
+    db.close()
+
+@app.get("/videos", response_model=List[schemas.Video])
+def get_videos(db: Session = Depends(get_db)):
+    return db.query(database.Video).all()
+
+@app.get("/videos/{video_id}", response_model=schemas.Video)
+def get_video(video_id: int, db: Session = Depends(get_db)):
+    video = db.query(database.Video).filter(database.Video.id == video_id).first()
+    if not video:
+        raise HTTPException(status_code=404, detail="Video not found")
+    return video
+
+
+@app.get("/videos/{video_id}/comments", response_model=List[schemas.Comment])
+def get_comments(video_id: int, db: Session = Depends(get_db)):
+    return db.query(database.Comment).filter(database.Comment.video_id == video_id).all()
+
+@app.post("/comments", response_model=schemas.Comment)
+def create_comment(comment: schemas.CommentCreate, db: Session = Depends(get_db)):
+    # 1. Analyze for toxicity
+    analysis = moderator.moderator.analyze(comment.text)
+    
+    # 2. Save to DB
+    db_comment = database.Comment(
+        video_id=comment.video_id,
+        user=comment.user,
+        text=comment.text,
+        timestamp=comment.timestamp,
+        is_toxic=analysis["is_toxic"],
+        toxicity_score=analysis["score"],
+        flagged_reason=analysis["reason"]
+    )
+    db.add(db_comment)
+    db.commit()
+    db.refresh(db_comment)
+    return db_comment
+
+@app.delete("/comments")
+def clear_comments(db: Session = Depends(get_db)):
+    db.query(database.Comment).delete()
+    db.commit()
+    return {"message": "All comments cleared"}
+
+@app.get("/stats")
+def get_stats(db: Session = Depends(get_db)):
+    comments = db.query(database.Comment).all()
+    total = len(comments)
+    toxic_comments = [c for c in comments if c.is_toxic]
+    toxic_count = len(toxic_comments)
+    
+    # Custom Classification Logic for Demo
+    types = {
+        "Insult": 0, 
+        "Identity Hate": 0, 
+        "Threat": 0, 
+        "Online Harassment": 0
+    }
+    
+    for c in toxic_comments:
+        text = c.text.lower()
+        if any(w in text for w in ["kill", "die", "hurt", "attack", "gun", "shoot", "murder"]):
+            types["Threat"] += 1
+        elif any(w in text for w in ["hate", "racist", "gay", "lesbian", "black", "white", "jew", "muslim", "women", "men", "trans"]):
+            types["Identity Hate"] += 1
+        elif any(w in text for w in ["stupid", "idiot", "dumb", "ugly", "fat", "loser", "moron", "coward"]):
+            types["Insult"] += 1
+        else:
+            # Catch-all for other toxic comments
+            types["Online Harassment"] += 1
+            
+    return {
+        "total_comments": total, 
+        "toxic_comments": toxic_count, 
+        "toxic_ratio": (toxic_count/total) if total > 0 else 0,
+        "types_breakdown": [{"name": k, "value": v} for k, v in types.items()]
+    }
+

moderator.py

@@ -0,0 +1,37 @@
+from transformers import pipeline
+import torch
+
+class ToxicityModel:
+    def __init__(self):
+        print("Loading Toxicity Model...")
+        # Using a model that is good for toxic comment detection
+        # 'distilbert-base-uncased-finetuned-sst-2-english' is Sentiment (Pos/Neg)
+        # Neg is a decent proxy for toxic for a demo.
+        # Alternatively: 'unitary/toxic-bert' is better but heavier.
+        try:
+             self.classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            self.classifier = None
+
+    def analyze(self, text: str):
+        if not self.classifier:
+            return {"is_toxic": False, "score": 0.0, "reason": "Model inactive"}
+        
+        results = self.classifier(text)
+        # Format: [{'label': 'NEGATIVE', 'score': 0.99}]
+        result = results[0]
+        
+        label = result['label']
+        score = result['score']
+        
+        # Heuristic: If Negative and high confidence, flag it.
+        is_toxic = (label == 'NEGATIVE' and score > 0.6)
+        
+        return {
+            "is_toxic": is_toxic,
+            "score": score,
+            "reason": f"Classified as {label} with confidence {score:.2f}"
+        }
+
+moderator = ToxicityModel()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pydantic
+transformers
+torch
+scikit-learn
+python-multipart
+sqlalchemy