Upload 9 files

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,25 @@
+venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.pytest_cache/
+.DS_Store
+.vscode/settings.json
+*.egg-info/
+dist/
+build/
+.idea/
+.env
+.env.local
+.env.*.local
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

DEPLOY.md

@@ -0,0 +1,122 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+## Quick Deploy Steps
+
+### 1. Create Your Space
+1. Go to [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Name: `content-classifier` (or your preferred name)
+3. SDK: **Docker**
+4. Visibility: Public/Private (your choice)
+5. Click **Create Space**
+
+### 2. Upload Files
+Upload these files to your Space:
+
+**Required Files:**
+- `contextClassifier.onnx` (your model file)
+- `app.py`
+- `requirements.txt`
+- `Dockerfile`
+- `README.md`
+
+**Optional Files:**
+- `test_api.py` (for testing)
+
+### 3. Model File
+⚠️ **Important**: Make sure your `contextClassifier.onnx` file is in the same directory as these files before uploading.
+
+### 4. Git Method (Recommended)
+
+```bash
+# Clone your space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# Copy your model file
+copy path\to\your\contextClassifier.onnx .
+
+# Copy all project files
+copy app.py .
+copy requirements.txt .
+copy Dockerfile .
+copy README.md .
+
+# Add and commit
+git add .
+git commit -m "🔍 Add content classifier ONNX model"
+git push
+```
+
+### 5. Monitor Deployment
+
+1. **Check Build Logs**: Go to your Space > Logs tab
+2. **Wait for Build**: Usually takes 2-3 minutes
+3. **Check Status**: Space will show "Building" → "Running"
+
+### 6. Test Your Space
+
+Once deployed, your API will be available at:
+```
+https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space
+```
+
+**API Endpoints:**
+- `/docs` - Interactive documentation
+- `/predict` - Main prediction endpoint
+- `/health` - Health check
+- `/model-info` - Model information
+
+### 7. Example Usage
+
+```python
+import requests
+
+# Replace with your actual Space URL
+api_url = "https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space"
+
+response = requests.post(
+    f"{api_url}/predict",
+    json={"text": "This is a test message for classification"}
+)
+
+print(response.json())
+```
+
+## Troubleshooting
+
+### Common Issues:
+
+**Build Fails:**
+- Check Logs tab for error details
+- Verify all required files are uploaded
+- Ensure `contextClassifier.onnx` is present
+
+**Model Not Found:**
+- Verify `contextClassifier.onnx` is in root directory
+- Check file name matches exactly (case-sensitive)
+
+**API Not Responding:**
+- Check if Space is "Running" (not "Building")
+- Try accessing `/health` endpoint first
+- Check Logs for runtime errors
+
+**Memory Issues:**
+- ONNX model might be too large
+- Consider model optimization
+- Check Space hardware limits
+
+### Success Indicators:
+
+✅ Space shows "Running" status
+✅ `/health` endpoint returns `{"status": "healthy"}`
+✅ `/docs` shows interactive API documentation
+✅ `/predict` accepts POST requests and returns expected format
+
+## Next Steps
+
+1. **Test thoroughly** with various text inputs
+2. **Share your Space** with the community
+3. **Monitor usage** in Space analytics
+4. **Update model** by pushing new `contextClassifier.onnx`
+
+Your Content Classifier is now live and ready to use! 🎉

Dockerfile

@@ -0,0 +1,34 @@
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+USER app
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')"
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,132 @@
----
-title: Context Classifier2
-emoji: 🐢
-colorFrom: indigo
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Content Classifier
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+---
+
+# 🔍 Content Classifier
+
+A powerful FastAPI-based content classification service using ONNX for threat detection and sentiment analysis.
+
+## 🚀 Features
+
+- **Threat Detection**: Classify content for potential threats
+- **Sentiment Analysis**: Analyze text sentiment (positive/negative)
+- **ONNX Runtime**: High-performance model inference
+- **REST API**: Easy-to-use HTTP endpoints
+- **Auto Documentation**: Interactive Swagger UI at `/docs`
+- **Health Monitoring**: Built-in health checks
+
+## 📡 API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/predict` | POST | Classify text content |
+| `/health` | GET | Check API health status |
+| `/model-info` | GET | Get model information |
+| `/docs` | GET | Interactive API documentation |
+
+## 🔧 Usage
+
+### Example Request
+
+```bash
+curl -X POST "https://YOUR-SPACE-NAME.hf.space/predict" \
+     -H "Content-Type: application/json" \
+     -d '{"text": "This is a sample text to classify"}'
+```
+
+### Example Response
+
+```json
+{
+    "is_threat": false,
+    "final_confidence": 0.75,
+    "threat_prediction": 0.25,
+    "sentiment_analysis": {
+        "label": "POSITIVE",
+        "score": 0.5
+    },
+    "onnx_prediction": {
+        "threat_probability": 0.25,
+        "raw_output": [[0.75, 0.25]],
+        "output_shape": [1, 2]
+    },
+    "models_used": ["contextClassifier.onnx"],
+    "raw_predictions": {
+        "onnx": {
+            "threat_probability": 0.25,
+            "raw_output": [[0.75, 0.25]]
+        },
+        "sentiment": {
+            "label": "POSITIVE",
+            "score": 0.5
+        }
+    }
+}
+```
+
+## 📊 Response Format
+
+The API returns a structured response with:
+
+- **`is_threat`**: Boolean indicating if content is threatening
+- **`final_confidence`**: Confidence score (0.0 to 1.0)
+- **`threat_prediction`**: Raw threat probability
+- **`sentiment_analysis`**: Sentiment classification and score
+- **`onnx_prediction`**: Raw ONNX model output
+- **`models_used`**: List of models used for prediction
+- **`raw_predictions`**: Complete prediction data
+
+## 🛠️ Local Development
+
+1. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Place your model:**
+   Ensure `contextClassifier.onnx` is in the project root
+
+3. **Run the API:**
+   ```bash
+   python app.py
+   ```
+
+4. **Visit:** `http://localhost:7860/docs`
+
+## 🐳 Docker
+
+```bash
+# Build
+docker build -t content-classifier .
+
+# Run
+docker run -p 7860:7860 content-classifier
+```
+
+## 📝 Model Requirements
+
+Your `contextClassifier.onnx` model should:
+- Accept text-based inputs
+- Return classification predictions
+- Be compatible with ONNX Runtime
+
+## ⚙️ Configuration
+
+Customize the preprocessing and postprocessing functions in `app.py` based on your specific model requirements.
+
+## 🔍 Monitoring
+
+- **Health Check**: `/health` - Monitor API status
+- **Model Info**: `/model-info` - View model details
+- **Logs**: Check application logs for debugging
+
+## 📜 License
+
+MIT License - feel free to use and modify!

app.py

@@ -0,0 +1,270 @@
+import os
+import numpy as np
+import onnxruntime as ort
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import json
+from typing import Dict, Any, List, Optional
+
+app = FastAPI(
+    title="Content Classifier API", 
+    description="ONNX-based content classification for threat detection and sentiment analysis",
+    version="1.0.0"
+)
+
+# Model configuration
+MODEL_PATH = "contextClassifier.onnx"
+session = None
+
+class TextInput(BaseModel):
+    text: str
+    max_length: Optional[int] = 512
+
+class PredictionResponse(BaseModel):
+    is_threat: bool
+    final_confidence: float
+    threat_prediction: float
+    sentiment_analysis: Optional[Dict[str, Any]]
+    onnx_prediction: Optional[Dict[str, Any]]
+    models_used: List[str]
+    raw_predictions: Dict[str, Any]
+
+def load_model():
+    """Load the ONNX model"""
+    global session
+    try:
+        if not os.path.exists(MODEL_PATH):
+            raise FileNotFoundError(f"Model file not found: {MODEL_PATH}")
+        
+        session = ort.InferenceSession(MODEL_PATH)
+        print(f"✅ Model loaded successfully from {MODEL_PATH}")
+        
+        # Print model info
+        inputs = [input.name for input in session.get_inputs()]
+        outputs = [output.name for output in session.get_outputs()]
+        print(f"📥 Model inputs: {inputs}")
+        print(f"📤 Model outputs: {outputs}")
+        
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        raise e
+
+def preprocess_text(text: str, max_length: int = 512) -> Dict[str, np.ndarray]:
+    """
+    Preprocess text for the ONNX model
+    NOTE: Adjust this function based on your model's specific requirements
+    """
+    try:
+        # Basic text preprocessing (customize based on your model)
+        text = text.strip().lower()
+        
+        # Simple tokenization (replace with actual tokenizer if needed)
+        tokens = text.split()[:max_length]
+        
+        # Pad or truncate to fixed length
+        if len(tokens) < max_length:
+            tokens.extend(['[PAD]'] * (max_length - len(tokens)))
+        
+        # Convert to numerical representation
+        # NOTE: This is a placeholder - replace with your actual preprocessing
+        input_ids = np.array([hash(token) % 30000 for token in tokens], dtype=np.int64).reshape(1, -1)
+        attention_mask = np.array([1 if token != '[PAD]' else 0 for token in tokens], dtype=np.int64).reshape(1, -1)
+        
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask
+        }
+    
+    except Exception as e:
+        print(f"❌ Preprocessing error: {e}")
+        raise HTTPException(status_code=500, detail=f"Text preprocessing failed: {str(e)}")
+
+def postprocess_predictions(outputs: List[np.ndarray]) -> Dict[str, Any]:
+    """
+    Process ONNX model outputs into the required format
+    """
+    try:
+        predictions = {}
+        
+        if not outputs or len(outputs) == 0:
+            raise ValueError("No outputs received from model")
+        
+        # Get the main output (adjust index based on your model)
+        main_output = outputs[0]
+        
+        # Extract threat prediction
+        if len(main_output.shape) == 2 and main_output.shape[1] >= 2:
+            # Binary classification: [non_threat_prob, threat_prob]
+            threat_prediction = float(main_output[0][1])
+        elif len(main_output.shape) == 2 and main_output.shape[1] == 1:
+            # Single output probability
+            threat_prediction = float(main_output[0][0])
+        else:
+            # Fallback for other output shapes
+            threat_prediction = float(main_output.flatten()[0])
+        
+        # Calculate confidence and threat classification
+        final_confidence = abs(threat_prediction - 0.5) * 2  # Scale to 0-1
+        is_threat = threat_prediction > 0.5
+        
+        # Store ONNX predictions
+        predictions["onnx"] = {
+            "threat_probability": threat_prediction,
+            "raw_output": main_output.tolist(),
+            "output_shape": main_output.shape
+        }
+        
+        # Generate sentiment analysis (inverse relationship with threat)
+        sentiment_score = (0.5 - threat_prediction) * 2  # Convert to sentiment scale
+        predictions["sentiment"] = {
+            "label": "POSITIVE" if sentiment_score > 0 else "NEGATIVE",
+            "score": abs(sentiment_score)
+        }
+        
+        models_used = ["contextClassifier.onnx"]
+        
+        # Return the exact format specified
+        return {
+            "is_threat": is_threat,
+            "final_confidence": final_confidence,
+            "threat_prediction": threat_prediction,
+            "sentiment_analysis": predictions.get("sentiment"),
+            "onnx_prediction": predictions.get("onnx"),
+            "models_used": models_used,
+            "raw_predictions": predictions
+        }
+        
+    except Exception as e:
+        print(f"❌ Postprocessing error: {e}")
+        # Return safe fallback response
+        return {
+            "is_threat": False,
+            "final_confidence": 0.0,
+            "threat_prediction": 0.0,
+            "sentiment_analysis": {"label": "NEUTRAL", "score": 0.0},
+            "onnx_prediction": {"error": str(e)},
+            "models_used": ["contextClassifier.onnx"],
+            "raw_predictions": {"error": str(e)}
+        }
+
+@app.on_event("startup")
+async def startup_event():
+    """Load model on application startup"""
+    load_model()
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "🔍 Content Classifier API",
+        "description": "ONNX-based content classification for threat detection and sentiment analysis",
+        "model": MODEL_PATH,
+        "status": "running",
+        "endpoints": {
+            "predict": "/predict",
+            "health": "/health",
+            "model_info": "/model-info",
+            "docs": "/docs"
+        }
+    }
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(input_data: TextInput):
+    """
+    Classify content for threat detection and sentiment analysis
+    
+    Returns the exact format:
+    {
+        "is_threat": bool,
+        "final_confidence": float,
+        "threat_prediction": float,
+        "sentiment_analysis": dict,
+        "onnx_prediction": dict,
+        "models_used": list,
+        "raw_predictions": dict
+    }
+    """
+    if session is None:
+        raise HTTPException(status_code=500, detail="Model not loaded. Please check server logs.")
+    
+    if not input_data.text.strip():
+        raise HTTPException(status_code=400, detail="Text input cannot be empty")
+    
+    try:
+        # Preprocess the input text
+        model_inputs = preprocess_text(input_data.text, input_data.max_length)
+        
+        # Prepare inputs for ONNX Runtime
+        input_names = [input.name for input in session.get_inputs()]
+        ort_inputs = {}
+        
+        for name in input_names:
+            if name in model_inputs:
+                ort_inputs[name] = model_inputs[name]
+            else:
+                print(f"⚠️ Warning: Expected input '{name}' not found in processed inputs")
+        
+        if not ort_inputs:
+            raise HTTPException(status_code=500, detail="No valid inputs prepared for model")
+        
+        # Run inference
+        outputs = session.run(None, ort_inputs)
+        
+        # Process and return results
+        result = postprocess_predictions(outputs)
+        return result
+        
+    except Exception as e:
+        print(f"❌ Prediction error: {e}")
+        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy" if session is not None else "unhealthy",
+        "model_loaded": session is not None,
+        "model_path": MODEL_PATH,
+        "model_exists": os.path.exists(MODEL_PATH)
+    }
+
+@app.get("/model-info")
+async def model_info():
+    """Get detailed model information"""
+    if session is None:
+        raise HTTPException(status_code=500, detail="Model not loaded")
+    
+    try:
+        inputs = []
+        for input_meta in session.get_inputs():
+            inputs.append({
+                "name": input_meta.name,
+                "type": str(input_meta.type),
+                "shape": list(input_meta.shape) if input_meta.shape else None
+            })
+        
+        outputs = []
+        for output_meta in session.get_outputs():
+            outputs.append({
+                "name": output_meta.name,
+                "type": str(output_meta.type),
+                "shape": list(output_meta.shape) if output_meta.shape else None
+            })
+        
+        return {
+            "model_path": MODEL_PATH,
+            "model_size": f"{os.path.getsize(MODEL_PATH) / (1024*1024):.2f} MB",
+            "inputs": inputs,
+            "outputs": outputs,
+            "runtime_info": {
+                "providers": session.get_providers(),
+                "device": "CPU"
+            }
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get model info: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

contextClassifier.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11e8c5314dfcec3f5c06b74655961b3211a4f4509ff8e7026e066ac14251d979
+size 267958108

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+onnxruntime==1.16.3
+numpy==1.24.3
+pydantic==2.5.0
+python-multipart==0.0.6

test_api.py

@@ -0,0 +1,139 @@
+import requests
+import json
+import time
+
+# Configuration
+BASE_URL = "http://localhost:7860"
+
+def test_api():
+    """Test all API endpoints"""
+    print("🧪 Testing Content Classifier API")
+    print("=" * 50)
+    
+    # Test 1: Root endpoint
+    print("\n📍 Testing root endpoint...")
+    try:
+        response = requests.get(f"{BASE_URL}/")
+        print(f"✅ Status: {response.status_code}")
+        print(f"📄 Response: {json.dumps(response.json(), indent=2)}")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+    
+    # Test 2: Health check
+    print("\n🏥 Testing health endpoint...")
+    try:
+        response = requests.get(f"{BASE_URL}/health")
+        print(f"✅ Status: {response.status_code}")
+        print(f"📄 Response: {json.dumps(response.json(), indent=2)}")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+    
+    # Test 3: Model info
+    print("\n🤖 Testing model info endpoint...")
+    try:
+        response = requests.get(f"{BASE_URL}/model-info")
+        print(f"✅ Status: {response.status_code}")
+        if response.status_code == 200:
+            print(f"📄 Response: {json.dumps(response.json(), indent=2)}")
+        else:
+            print(f"📄 Response: {response.text}")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+    
+    # Test 4: Prediction endpoint
+    print("\n🔍 Testing prediction endpoint...")
+    
+    test_cases = [
+        {
+            "text": "Hello, how are you today? I hope you're doing well!",
+            "expected": "positive sentiment"
+        },
+        {
+            "text": "I will destroy everything and cause harm!",
+            "expected": "threat detection"
+        },
+        {
+            "text": "This product is amazing, I love it so much!",
+            "expected": "positive sentiment"
+        },
+        {
+            "text": "I hate this, it's terrible and awful!",
+            "expected": "negative sentiment"
+        },
+        {
+            "text": "Neutral statement about weather conditions today.",
+            "expected": "neutral/low confidence"
+        }
+    ]
+    
+    for i, case in enumerate(test_cases, 1):
+        print(f"\n📝 Test Case {i}: {case['expected']}")
+        print(f"💬 Text: '{case['text'][:50]}{'...' if len(case['text']) > 50 else ''}'")
+        
+        try:
+            payload = {
+                "text": case["text"],
+                "max_length": 512
+            }
+            
+            response = requests.post(f"{BASE_URL}/predict", json=payload)
+            
+            if response.status_code == 200:
+                result = response.json()
+                print(f"✅ Status: {response.status_code}")
+                print(f"🎯 Is Threat: {result['is_threat']}")
+                print(f"📊 Confidence: {result['final_confidence']:.3f}")
+                print(f"⚠️ Threat Prediction: {result['threat_prediction']:.3f}")
+                print(f"😊 Sentiment: {result['sentiment_analysis']['label']} ({result['sentiment_analysis']['score']:.3f})")
+                print(f"🔧 Models Used: {result['models_used']}")
+            else:
+                print(f"❌ Status: {response.status_code}")
+                print(f"📄 Response: {response.text}")
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+    
+    print("\n" + "=" * 50)
+    print("🏁 API Testing Complete!")
+
+def test_edge_cases():
+    """Test edge cases and error conditions"""
+    print("\n🚨 Testing Edge Cases")
+    print("=" * 30)
+    
+    edge_cases = [
+        {"text": "", "description": "Empty string"},
+        {"text": "   ", "description": "Whitespace only"},
+        {"text": "A" * 1000, "description": "Very long text"},
+        {"text": "🔥💯🚀", "description": "Emoji only"},
+        {"text": "12345 67890", "description": "Numbers only"}
+    ]
+    
+    for case in edge_cases:
+        print(f"\n📝 Testing: {case['description']}")
+        try:
+            payload = {"text": case["text"]}
+            response = requests.post(f"{BASE_URL}/predict", json=payload)
+            
+            if response.status_code == 200:
+                result = response.json()
+                print(f"✅ Success: Threat={result['is_threat']}, Confidence={result['final_confidence']:.3f}")
+            else:
+                print(f"⚠️ Status {response.status_code}: {response.json().get('detail', 'Unknown error')}")
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    print("🔍 Content Classifier API Test Suite")
+    print(f"🌐 Base URL: {BASE_URL}")
+    
+    # Wait a moment for server to be ready
+    print("\n⏱️ Waiting for server to be ready...")
+    time.sleep(2)
+    
+    # Run tests
+    test_api()
+    test_edge_cases()
+    
+    print(f"\n📚 Visit {BASE_URL}/docs for interactive API documentation")