Deploy my chat filter app

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY . /app
+
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

image_moderator.py

@@ -0,0 +1,94 @@
+# image_moderator.py
+
+from transformers import CLIPProcessor, CLIPModel, ViTForImageClassification, ViTFeatureExtractor
+from PIL import Image, ImageFilter
+import torch
+import cv2
+
+class ImageContentModerator:
+    def __init__(self, nsfw_threshold=0.85, blur_radius=99):
+        # NSFW Setup
+        self.nsfw_threshold = nsfw_threshold
+        self.nsfw_classes = [
+            "porn", "nudity", "sexual activity", "explicit", 
+            "safe", "neutral", "hentai", "suggestive", "drawing"
+        ]
+        self.nsfw_model = CLIPModel.from_pretrained("openai/clip-vit-base-patch16")
+        self.nsfw_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch16")
+
+        # Violence Setup
+        self.violence_model = ViTForImageClassification.from_pretrained('jaranohaal/vit-base-violence-detection')
+        self.violence_extractor = ViTFeatureExtractor.from_pretrained('jaranohaal/vit-base-violence-detection')
+        self.custom_labels = {1: "Non-Violent", 0: "Violent"}
+
+        self.blur_radius = blur_radius
+
+        print("[Moderator] Both models loaded successfully.")
+
+    def is_nsfw(self, image):
+        inputs = self.nsfw_processor(text=self.nsfw_classes, images=image, return_tensors="pt", padding=True)
+        with torch.no_grad():
+            outputs = self.nsfw_model(**inputs)
+            probs = outputs.logits_per_image.softmax(dim=1)[0]
+        top_class = self.nsfw_classes[probs.argmax()]
+        confidence = probs.max().item()
+        print(f"[NSFW] Predicted: {top_class} ({confidence:.2f})")
+        return top_class not in ['safe', 'neutral', 'drawing'] and confidence > self.nsfw_threshold
+
+    def is_violent(self, image):
+        inputs = self.violence_extractor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.violence_model(**inputs)
+            class_idx = outputs.logits.argmax(-1).item()
+            label = self.custom_labels[class_idx]
+        print(f"[Violence] Predicted: {label}")
+        return label == "Violent"
+
+    def blur_image(self, image_path, output_path):
+        image = Image.open(image_path)
+        blurred = image.filter(ImageFilter.GaussianBlur(radius=self.blur_radius))
+        blurred.save(output_path)
+        return output_path
+
+    def process_image(self, image_path, output_path="moderated_image.jpg"):
+        image = Image.open(image_path).convert("RGB")
+
+        if self.is_nsfw(image):
+            print("⚠️ NSFW Content Detected — Blurring Image")
+            return self.blur_image(image_path, output_path)
+
+        if self.is_violent(image):
+            print("⚠️ Violent Content Detected — Blurring Image")
+            return self.blur_image(image_path, output_path)
+
+        print("✅ Image is clean — No action taken")
+        image.save(output_path)
+        return output_path
+from transformers import pipeline
+from better_profanity import profanity
+
+# Load profanity model
+toxic_classifier = pipeline("text-classification", model="unitary/toxic-bert")
+profanity.load_censor_words()
+custom_words = [
+    "idiot", "moron", "dumb", "stupid", "loser", "bastard", "retard", "scumbag",
+    "asshole", "jerk", "shit", "fuck", "damn", "hell", "crap", "bitch"
+]
+profanity.add_censor_words(custom_words)
+
+def mask_bad_words(text):
+    return profanity.censor(text)
+
+def smart_censor(text, toxic_threshold=0.85):
+    result = toxic_classifier(text)[0]
+    label = result['label'].lower()
+    score = result['score']
+
+    if label == "toxic" and score > toxic_threshold:
+        masked_text = mask_bad_words(text)
+        if masked_text != text:
+            return masked_text
+        else:
+            return "⚠️ Vulgar Content Detected"
+    
+    return text

main.py

@@ -0,0 +1,114 @@
+# # from fastapi import FastAPI, UploadFile, File
+# # from pydantic import BaseModel
+# # from image_moderator import ImageContentModerator, smart_censor
+# # from PIL import Image
+# # import shutil
+# # import os
+
+# # app = FastAPI()
+
+# # # Load models once when server starts
+# # moderator = ImageContentModerator()
+
+# # # Input schema for text
+# # class TextRequest(BaseModel):
+# #     text: str
+
+# # @app.get("/")
+# # def root():
+# #     return {"message": "Chat Moderation API is running"}
+
+# # @app.post("/moderate-text")
+# # async def moderate_text(req: TextRequest):
+# #     result = smart_censor(req.text)
+# #     return {"moderated_text": result}
+
+# # @app.post("/moderate-image")
+# # async def moderate_image(file: UploadFile = File(...)):
+# #     temp_path = f"temp_{file.filename}"
+
+# #     # Save uploaded image to disk
+# #     with open(temp_path, "wb") as buffer:
+# #         shutil.copyfileobj(file.file, buffer)
+
+# #     output_path = f"blurred_{file.filename}"
+# #     moderated_path = moderator.process_image(temp_path, output_path)
+
+# #     # Read the moderated image and return as base64
+# #     with open(moderated_path, "rb") as img_file:
+# #         image_bytes = img_file.read()
+# #         import base64
+# #         encoded_image = base64.b64encode(image_bytes).decode()
+
+# #     # Clean up temp files
+# #     os.remove(temp_path)
+# #     os.remove(moderated_path)
+
+# #     return {
+# #         "blurred_image_base64": encoded_image
+# #     }
+
+
+
+
+
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+from image_moderator import ImageContentModerator, smart_censor
+from PIL import Image
+import base64
+import os
+
+app = FastAPI()
+
+# Load models once when server starts
+moderator = ImageContentModerator()
+
+# Schemas
+class TextRequest(BaseModel):
+    text: str
+
+class ImageRequest(BaseModel):
+    image: str  # base64 string
+
+@app.get("/")
+def root():
+    return {"message": "Chat Moderation API is running"}
+# ✅ IMAGE MODERATION ENDPOINT
+@app.post("/moderate-image")
+async def moderate_image(req: ImageRequest):
+    try:
+        # Decode base64 image
+        image_data = base64.b64decode(req.image.split(",")[-1])
+        temp_path = "temp_input.png"
+        output_path = "temp_blurred.png"
+
+        # Save temp image
+        with open(temp_path, "wb") as f:
+            f.write(image_data)
+
+        # Process image
+        moderated_path = moderator.process_image(temp_path, output_path)
+
+        # Encode result
+        with open(moderated_path, "rb") as f:
+            encoded = base64.b64encode(f.read()).decode()
+
+        # Cleanup
+        os.remove(temp_path)
+        os.remove(output_path)
+
+        return {"blurred_image_base64": encoded}
+    except Exception as e:
+        return {"error": str(e)}
+# ✅ TEXT MODERATION ENDPOINT
+@app.post("/moderate-text")
+async def moderate_text(req: TextRequest):
+    try:
+        result = smart_censor(req.text)
+        return {"moderated_text": result}
+    except Exception as e:
+        return {"error": str(e)}
+
+