Updated

DockerFile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+WORKDIR /app
+
+RUN useradd -m -u 1000 user
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY api ./api
+
+RUN chown -R user:user /app
+
+USER user
+
+EXPOSE 7860
+
+CMD ["uvicorn", "api.app:app", "--host", "0.0.0.0", "--port", "7860"]

api/__init__.py

@@ -2,9 +2,4 @@ from .content_moderator import ContentModerator
 from .schemas import Item
 from .config import get_classifier
 
-# This whitelist tells the linter: "I am exporting these on purpose."
-__all__ = [
-    "ContentModerator",
-    "Item",
-    "get_classifier",
-]
+__all__ = ["ContentModerator", "Item", "get_classifier"]

api/app.py

@@ -1,5 +1,5 @@
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, Depends, HTTPException
+from fastapi import FastAPI, Depends
 from . import Item, ContentModerator, get_classifier
 
 
@@ -13,8 +13,7 @@ app = FastAPI(title="Content Moderator API", lifespan=lifespan)
 
 
 def get_moderator():
-    classifier = get_classifier()
-    return ContentModerator(classifier)
+    return ContentModerator(get_classifier())
 
 
 @app.get("/health")
@@ -24,8 +23,4 @@ def health():
 
 @app.post("/predict")
 def predict(item: Item, moderator: ContentModerator = Depends(get_moderator)):
-    try:
-        return moderator.predict_text(item.text)
-    except Exception as e:
-        print(f"Error: {e}")
-        raise HTTPException(status_code=500, detail="Internal Model Error")
+    return moderator.predict_text(item.text)

api/config.py

@@ -4,8 +4,4 @@ from transformers import pipeline
 
 @lru_cache(maxsize=1)
 def get_classifier():
-    """
-    Lazy-loads the Hugging Face text-classification pipeline.
-    Ensures a single instance is used across the service.
-    """
     return pipeline("text-classification", "mothy-08/drbftcm")

api/content_moderator.py

@@ -1,42 +1,20 @@
-from typing import Dict
 import unicodedata
 
 
 class ContentModerator:
-    """
-    Handles text moderation by validating, preprocessing, and classifying
-    """
-
     def __init__(self, classifier):
         self.classifier = classifier
 
-    def predict_text(self, text: str) -> Dict:
-        """
-        Main method to classify text.
-        Returns a dictionary with label and confidence score.
-        """
-
+    def predict_text(self, text: str) -> dict:
         text = self._preprocess_text(text)
         result = self.classifier(text)[0]
 
-        if (
-            not isinstance(result, dict)
-            or "label" not in result
-            or "score" not in result
-        ):
-            raise ValueError("Malformed model output")
-
-        label, score = result["label"].lower(), result["score"]
-
         return {
-            "label": label,
-            "score": score,
+            "label": result["label"],
+            "score": result["score"],
         }
 
     def _preprocess_text(self, text: str) -> str:
-        """Sanitizes text to be model-ready."""
-
         text = unicodedata.normalize("NFKC", text)
         text = "".join(ch for ch in text if unicodedata.category(ch)[0] != "C")
-
-        return "".join(text.split())
+        return " ".join(text.split())

api/schemas.py

@@ -3,11 +3,6 @@ from pydantic import BaseModel, StringConstraints
 
 
 class Item(BaseModel):
-    """
-    Schema for incoming text to be moderated.
-    Ensures text is not empty and within max token length of 512 (approximately 2500 characters)
-    """
-
     text: Annotated[
         str,
         StringConstraints(

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn[standard]
+transformers
+torch --index-url https://download.pytorch.org/whl/cpu

tests/test_moderator.py

@@ -14,53 +14,34 @@ def get_mock_moderator():
 
 
 app.dependency_overrides[get_moderator] = get_mock_moderator
-
 client = TestClient(app)
 
 
 def test_health():
-    """Ensure the app is alive"""
     response = client.get("/health")
     assert response.status_code == 200
     assert response.json() == {"status": "ok"}
 
 
 def test_predict_valid_text():
-    """Test the happy path with the mock."""
     response = client.post("/predict", json={"text": "Hello"})
     assert response.status_code == 200
     data = response.json()
     assert data["label"] == "safe"
     assert data["score"] == 0.99
-    assert data["confidence_text"] == "high"
 
 
 def test_predict_normalization():
-    """
-    CRITICAL TEST: Verify that full-width characters are normalized.
-    We send 'Ｈｅｌｌｏ' (Full width).
-    If your normalization logic works, the classifier sees 'Hello' and returns 'clean'.
-    If it fails, the classifier sees 'Ｈｅｌｌｏ' (unknown) and returns 'toxic' (default fallback in our mock).
-    """
     response = client.post("/predict", json={"text": "Ｈｅｌｌｏ"})
     assert response.status_code == 200
     assert response.json()["label"] == "safe"
 
 
-def test_predit_empty_text():
-    """
-    Test the Pydantic Bouncer
-    Should fail with 422 Unprocessable Entity, NOT 500 Server Error
-    """
-
+def test_predict_empty_text():
     response = client.post("/predict", json={"text": ""})
     assert response.status_code == 422
 
 
 def test_predict_whitespace_only():
-    """
-    Test Pydantic stripping whitespace.
-    '   ' becomes '' -> min_length=1 fails.
-    """
     response = client.post("/predict", json={"text": "   "})
     assert response.status_code == 422