chore: add req and res samples for API reqs, remove redundant lines

app.py

@@ -1,10 +1,18 @@
 from typing import Optional, List, Dict, Any
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
+from enum import Enum
 
 from classifier import ArabicClassifier
 from summarizer import ArabicSummarizer
 from preprocessor import ArabicPreprocessor
+from examples import REQUEST_EXAMPLES, RESPONSE_EXAMPLES
+
+
+class TaskType(str, Enum):
+    CLASSIFICATION = "classification"
+    SUMMARIZATION = "summarization"
+
 
 app = FastAPI(
     title="Arabic Text Analysis API",
@@ -19,20 +27,155 @@ preprocessor = ArabicPreprocessor()
 
 class TextInput(BaseModel):
     text: str
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": REQUEST_EXAMPLES["text_input"]
+        }
+    }
 
 
 class TextInputWithSentences(BaseModel):
     text: str
     num_sentences: Optional[int] = 3
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": REQUEST_EXAMPLES["text_input_with_sentences"]
+        }
+    }
 
 
 class BatchTextInput(BaseModel):
     texts: List[str]
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": REQUEST_EXAMPLES["batch_text_input"]
+        }
+    }
 
 
 class PreprocessingInput(BaseModel):
     text: str
-    task_type: Optional[str] = "classification"
+    task_type: TaskType = TaskType.CLASSIFICATION
+    
+    model_config = {
+        "json_schema_extra": {
+            "example": REQUEST_EXAMPLES["preprocessing_input"]
+        }
+    }
+
+
+class ClassificationResponse(BaseModel):
+    prediction: str
+    prediction_index: int
+    confidence: float
+    probability_distribution: Dict[str, float]
+    cleaned_text: str
+    model_used: str
+    prediction_metadata: Dict[str, Any]
+
+    model_config = {
+        "protected_namespaces": (),
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["classification"],
+            "schema_extra": {
+                "properties": {
+                    "prediction_index": {
+                        "description": "Numerical index of the predicted class (0=culture, 1=economy, 2=international, 3=local, 4=religion, 5=sports)"
+                    }
+                }
+            }
+        }
+    }
+
+
+class SummarizationResponse(BaseModel):
+    summary: str
+    original_sentence_count: int
+    summary_sentence_count: int
+    sentences: List[str]
+    selected_indices: List[int]
+    sentence_scores: Optional[List[float]]
+    top_sentence_scores: Optional[List[float]]
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["summarization"]
+        }
+    }
+
+
+class TextAnalysisResponse(BaseModel):
+    text: str
+    analysis: Dict[str, Any]
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["text_analysis"]
+        }
+    }
+
+
+class BatchClassificationResponse(BaseModel):
+    results: List[ClassificationResponse]
+    total_texts: int
+    model_used: str
+
+    model_config = {
+        "protected_namespaces": (),
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["batch_classification"]
+        }
+    }
+
+
+class SentenceAnalysisResponse(BaseModel):
+    sentences: List[Dict[str, Any]]
+    total_sentences: int
+    score_statistics: Dict[str, float]
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["sentence_analysis"]
+        }
+    }
+
+
+class CompleteAnalysisResponse(BaseModel):
+    original_text: str
+    text_analysis: Dict[str, Any]
+    classification: ClassificationResponse
+    summarization: SummarizationResponse
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["complete_analysis"]
+        }
+    }
+
+
+class PreprocessingResponse(BaseModel):
+    task_type: str
+    preprocessing_steps: Dict[str, Any]
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["preprocessing"]
+        }
+    }
+
+
+class ModelInfoResponse(BaseModel):
+    classifier: Dict[str, Any]
+    summarizer: Dict[str, Any]
+
+    model_config = {
+        "json_schema_extra": {
+            "example": RESPONSE_EXAMPLES["model_info"]
+        }
+    }
 
 
 @app.get("/")
@@ -58,8 +201,8 @@ def read_root() -> Dict[str, Any]:
     }
 
 
-@app.post("/classify")
-def classify_text(data: TextInput) -> Dict[str, Any]:
+@app.post("/classify", response_model=ClassificationResponse)
+def classify_text(data: TextInput) -> ClassificationResponse:
     """Classify Arabic text with probability distribution and metadata."""
     try:
         result = classifier.predict(data.text)
@@ -68,8 +211,8 @@ def classify_text(data: TextInput) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Classification failed: {str(e)}")
 
 
-@app.post("/classify/batch")
-def classify_texts(data: BatchTextInput) -> Dict[str, Any]:
+@app.post("/classify/batch", response_model=BatchClassificationResponse)
+def classify_texts(data: BatchTextInput) -> BatchClassificationResponse:
     """Classify multiple Arabic texts in batch."""
     try:
         results = classifier.predict_batch(data.texts)
@@ -82,8 +225,8 @@ def classify_texts(data: BatchTextInput) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Batch classification failed: {str(e)}")
 
 
-@app.post("/summarize")
-def summarize_text(data: TextInputWithSentences) -> Dict[str, Any]:
+@app.post("/summarize", response_model=SummarizationResponse)
+def summarize_text(data: TextInputWithSentences) -> SummarizationResponse:
     """Summarize Arabic text with sentence analysis."""
     try:
         result = summarizer.summarize(data.text, data.num_sentences)
@@ -92,8 +235,8 @@ def summarize_text(data: TextInputWithSentences) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Summarization failed: {str(e)}")
 
 
-@app.post("/sentence-analysis")
-def analyze_sentences(data: TextInput) -> Dict[str, Any]:
+@app.post("/sentence-analysis", response_model=SentenceAnalysisResponse)
+def analyze_sentences(data: TextInput) -> SentenceAnalysisResponse:
     """Analyze all sentences with scores and rankings."""
     try:
         result = summarizer.get_sentence_analysis(data.text)
@@ -102,8 +245,8 @@ def analyze_sentences(data: TextInput) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Sentence analysis failed: {str(e)}")
 
 
-@app.post("/analyze")
-def analyze_text_complete(data: TextInputWithSentences) -> Dict[str, Any]:
+@app.post("/analyze", response_model=CompleteAnalysisResponse)
+def analyze_text_complete(data: TextInputWithSentences) -> CompleteAnalysisResponse:
     """Complete analysis: classification, summarization, and text statistics."""
     try:
         classification_result = classifier.predict(data.text)
@@ -120,21 +263,21 @@ def analyze_text_complete(data: TextInputWithSentences) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Complete analysis failed: {str(e)}")
 
 
-@app.post("/preprocess")
-def preprocess_text(data: PreprocessingInput) -> Dict[str, Any]:
+@app.post("/preprocess", response_model=PreprocessingResponse)
+def preprocess_text(data: PreprocessingInput) -> PreprocessingResponse:
     """Preprocess text with step-by-step breakdown."""
     try:
-        steps = preprocessor.get_preprocessing_steps(data.text, data.task_type)
+        steps = preprocessor.get_preprocessing_steps(data.text, data.task_type.value)
         return {
-            "task_type": data.task_type,
+            "task_type": data.task_type.value,
             "preprocessing_steps": steps
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Preprocessing failed: {str(e)}")
 
 
-@app.post("/text-analysis")
-def analyze_text_characteristics(data: TextInput) -> Dict[str, Any]:
+@app.post("/text-analysis", response_model=TextAnalysisResponse)
+def analyze_text_characteristics(data: TextInput) -> TextAnalysisResponse:
     """Analyze text characteristics and statistics."""
     try:
         analysis = preprocessor.analyze_text(data.text)
@@ -146,8 +289,8 @@ def analyze_text_characteristics(data: TextInput) -> Dict[str, Any]:
         raise HTTPException(status_code=500, detail=f"Text analysis failed: {str(e)}")
 
 
-@app.get("/model-info")
-def get_model_info() -> Dict[str, Any]:
+@app.get("/model-info", response_model=ModelInfoResponse)
+def get_model_info() -> ModelInfoResponse:
     """Get information about loaded models."""
     try:
         classifier_info = classifier.get_model_info()

classifier.py

@@ -6,52 +6,61 @@ from preprocessor import preprocess_for_classification
 
 class ArabicClassifier:
     """Arabic text classifier with probability distributions and metadata."""
-    
-    def __init__(self, 
-                 classifier_path: str = "svm_classifier.joblib",
-                 vectorizer_path: str = "tfidf_vectorizer_classifier.joblib"):
+
+    def __init__(
+        self,
+        classifier_path: str = "svm_classifier.joblib",
+        vectorizer_path: str = "tfidf_vectorizer_classifier.joblib",
+    ):
         self.model = joblib.load(classifier_path)
         self.vectorizer = joblib.load(vectorizer_path)
         self.model_name = classifier_path.split("/")[-1].replace(".joblib", "")
-    
+
     def predict(self, text: str) -> Dict[str, Any]:
         """Predict class with full probability distribution and metadata."""
         cleaned_text = preprocess_for_classification(text)
-        
+
         if self.vectorizer:
             text_vector = self.vectorizer.transform([cleaned_text])
         else:
             text_vector = [cleaned_text]
-        
+
         prediction = self.model.predict(text_vector)[0]
-        
-        classes = getattr(self.model, 'classes_', None)
+
+        classes = getattr(self.model, "classes_", None)
         if classes is not None:
             prediction_index = int(np.where(classes == prediction)[0][0])
         else:
-            prediction_index = int(prediction) if isinstance(prediction, (int, np.integer)) else 0
-        
-        if hasattr(self.model, 'predict_proba'):
+            prediction_index = (
+                int(prediction) if isinstance(prediction, (int, np.integer)) else 0
+            )
+
+        if hasattr(self.model, "predict_proba"):
             probabilities = self.model.predict_proba(text_vector)[0]
             confidence = float(probabilities[prediction_index])
         else:
-            if hasattr(self.model, 'decision_function'):
+            if hasattr(self.model, "decision_function"):
                 decision_scores = self.model.decision_function(text_vector)[0]
                 if len(decision_scores.shape) == 0:
-                    probabilities = np.array([1 / (1 + np.exp(decision_scores)), 1 / (1 + np.exp(-decision_scores))])
+                    probabilities = np.array(
+                        [
+                            1 / (1 + np.exp(decision_scores)),
+                            1 / (1 + np.exp(-decision_scores)),
+                        ]
+                    )
                 else:
                     exp_scores = np.exp(decision_scores - np.max(decision_scores))
                     probabilities = exp_scores / np.sum(exp_scores)
                 confidence = float(probabilities[prediction_index])
             else:
-                classes = getattr(self.model, 'classes_', None)
+                classes = getattr(self.model, "classes_", None)
                 num_classes = len(classes) if classes is not None else 2
                 probabilities = np.zeros(num_classes)
                 probabilities[prediction_index] = 1.0
                 confidence = 1.0
-        
-        classes = getattr(self.model, 'classes_', None)
-        
+
+        classes = getattr(self.model, "classes_", None)
+
         prob_distribution = {}
         if classes is not None:
             for i, class_label in enumerate(classes):
@@ -59,36 +68,36 @@ class ArabicClassifier:
         else:
             for i, prob in enumerate(probabilities):
                 prob_distribution[f"class_{i}"] = float(prob)
-        
+
         return {
             "prediction": str(prediction),
-            "prediction_label": str(prediction),
             "prediction_index": int(prediction_index),
             "confidence": confidence,
             "probability_distribution": prob_distribution,
-            "all_probabilities": probabilities.tolist(),
             "cleaned_text": cleaned_text,
             "model_used": self.model_name,
             "prediction_metadata": {
                 "max_probability": float(np.max(probabilities)),
                 "min_probability": float(np.min(probabilities)),
-                "entropy": float(-np.sum(probabilities * np.log(probabilities + 1e-10))),
-                "num_classes": len(probabilities)
-            }
+                "entropy": float(
+                    -np.sum(probabilities * np.log(probabilities + 1e-10))
+                ),
+                "num_classes": len(probabilities),
+            },
         }
-    
+
     def predict_batch(self, texts: List[str]) -> List[Dict[str, Any]]:
         """Predict classes for multiple texts."""
         cleaned_texts = [preprocess_for_classification(text) for text in texts]
-        
+
         if self.vectorizer:
             text_vectors = self.vectorizer.transform(cleaned_texts)
         else:
             text_vectors = cleaned_texts
-        
+
         predictions = self.model.predict(text_vectors)
-        classes = getattr(self.model, 'classes_', None)
-        
+        classes = getattr(self.model, "classes_", None)
+
         prediction_indices = []
         for pred in predictions:
             if classes is not None:
@@ -96,29 +105,38 @@ class ArabicClassifier:
             else:
                 pred_index = int(pred) if isinstance(pred, (int, np.integer)) else 0
             prediction_indices.append(pred_index)
-        
-        if hasattr(self.model, 'predict_proba'):
+
+        if hasattr(self.model, "predict_proba"):
             probabilities = self.model.predict_proba(text_vectors)
         else:
-            if hasattr(self.model, 'decision_function'):
+            if hasattr(self.model, "decision_function"):
                 decision_scores = self.model.decision_function(text_vectors)
                 if len(decision_scores.shape) == 1:
-                    probabilities = np.column_stack([1 / (1 + np.exp(decision_scores)), 1 / (1 + np.exp(-decision_scores))])
+                    probabilities = np.column_stack(
+                        [
+                            1 / (1 + np.exp(decision_scores)),
+                            1 / (1 + np.exp(-decision_scores)),
+                        ]
+                    )
                 else:
-                    exp_scores = np.exp(decision_scores - np.max(decision_scores, axis=1, keepdims=True))
-                    probabilities = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
+                    exp_scores = np.exp(
+                        decision_scores - np.max(decision_scores, axis=1, keepdims=True)
+                    )
+                    probabilities = exp_scores / np.sum(
+                        exp_scores, axis=1, keepdims=True
+                    )
             else:
-                classes = getattr(self.model, 'classes_', None)
+                classes = getattr(self.model, "classes_", None)
                 num_classes = len(classes) if classes is not None else 2
                 probabilities = np.zeros((len(predictions), num_classes))
                 for i, pred_idx in enumerate(prediction_indices):
                     probabilities[i, pred_idx] = 1.0
-        
+
         results = []
-        
+
         for i, (pred, pred_idx) in enumerate(zip(predictions, prediction_indices)):
             confidence = float(probabilities[i][pred_idx])
-            
+
             prob_distribution = {}
             if classes is not None:
                 for j, class_label in enumerate(classes):
@@ -126,35 +144,39 @@ class ArabicClassifier:
             else:
                 for j, prob in enumerate(probabilities[i]):
                     prob_distribution[f"class_{j}"] = float(prob)
-            
-            results.append({
-                "prediction": str(pred),
-                "prediction_label": str(pred),
-                "prediction_index": int(pred_idx),
-                "confidence": confidence,
-                "probability_distribution": prob_distribution,
-                "all_probabilities": probabilities[i].tolist(),
-                "cleaned_text": cleaned_texts[i],
-                "model_used": self.model_name,
-                "prediction_metadata": {
-                    "max_probability": float(np.max(probabilities[i])),
-                    "min_probability": float(np.min(probabilities[i])),
-                    "entropy": float(-np.sum(probabilities[i] * np.log(probabilities[i] + 1e-10))),
-                    "num_classes": len(probabilities[i])
+
+            results.append(
+                {
+                    "prediction": str(pred),
+                    "prediction_index": int(pred_idx),
+                    "confidence": confidence,
+                    "probability_distribution": prob_distribution,
+                    "cleaned_text": cleaned_texts[i],
+                    "model_used": self.model_name,
+                    "prediction_metadata": {
+                        "max_probability": float(np.max(probabilities[i])),
+                        "min_probability": float(np.min(probabilities[i])),
+                        "entropy": float(
+                            -np.sum(probabilities[i] * np.log(probabilities[i] + 1e-10))
+                        ),
+                        "num_classes": len(probabilities[i]),
+                    },
                 }
-            })
-        
+            )
+
         return results
-    
+
     def get_model_info(self) -> Dict[str, Any]:
         """Get model information and capabilities."""
-        classes = getattr(self.model, 'classes_', None)
+        classes = getattr(self.model, "classes_", None)
         return {
             "model_name": self.model_name,
             "model_type": type(self.model).__name__,
             "num_classes": len(classes) if classes is not None else "unknown",
             "classes": classes.tolist() if classes is not None else None,
-            "has_predict_proba": hasattr(self.model, 'predict_proba'),
+            "has_predict_proba": hasattr(self.model, "predict_proba"),
             "has_vectorizer": self.vectorizer is not None,
-            "vectorizer_type": type(self.vectorizer).__name__ if self.vectorizer else None
+            "vectorizer_type": type(self.vectorizer).__name__
+            if self.vectorizer
+            else None,
         }

examples.py

@@ -0,0 +1,214 @@
+"""API request and response examples for documentation."""
+
+EXAMPLE_TEXT = "يكون سعر الفاكهة والخضراوات في موسم إنباتها أقل من غيره من المواسم. ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات. لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه. في فصل الخريف يتوفر التفاح والتين والبنجر والكمثرى."
+
+REQUEST_EXAMPLES = {
+    "text_input": {"text": EXAMPLE_TEXT},
+    "text_input_with_sentences": {"text": EXAMPLE_TEXT, "num_sentences": 2},
+    "batch_text_input": {
+        "texts": [
+            EXAMPLE_TEXT,
+            "هذا نص تجريبي آخر للتصنيف باللغة العربية.",
+            "المطاعم في المدينة تقدم أطباق شهية ومتنوعة.",
+        ]
+    },
+    "preprocessing_input": {"text": EXAMPLE_TEXT, "task_type": "classification"},
+}
+
+RESPONSE_EXAMPLES = {
+    "classification": {
+        "prediction": "culture",
+        "prediction_index": 0,
+        "confidence": 0.902,
+        "probability_distribution": {
+            "culture": 0.902,
+            "economy": 0.001,
+            "international": 0.0,
+            "local": 0.061,
+            "religion": 0.0,
+            "sports": 0.036,
+        },
+        "cleaned_text": "يكن سعر فاكه خضرو موسم انبات اقل غير موسم",
+        "model_used": "svm_classifier",
+        "prediction_metadata": {
+            "max_probability": 0.902,
+            "min_probability": 0.0,
+            "entropy": 0.393,
+            "num_classes": 6,
+        },
+    },
+    "summarization": {
+        "summary": "ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه",
+        "original_sentence_count": 4,
+        "summary_sentence_count": 2,
+        "sentences": [
+            "يكون سعر الفاكهة والخضراوات في موسم إنباتها أقل من غيره من المواسم",
+            "ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات",
+            "لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه",
+            "في فصل الخريف يتوفر التفاح والتين والبنجر والكمثرى",
+        ],
+        "selected_indices": [1, 2],
+        "sentence_scores": [2.968, 3.224, 3.234, 2.642],
+        "top_sentence_scores": [3.224, 3.234],
+    },
+    "text_analysis": {
+        "text": EXAMPLE_TEXT,
+        "analysis": {
+            "character_count": 282,
+            "word_count": 46,
+            "sentence_count": 4,
+            "arabic_character_count": 252,
+            "arabic_character_ratio": 0.8936,
+            "average_word_length": 5.48,
+            "average_sentence_length": 11.5,
+            "has_diacritics": False,
+            "punctuation_count": 3,
+        },
+    },
+    "batch_classification": {
+        "results": [
+            {
+                "prediction": "culture",
+                "prediction_index": 0,
+                "confidence": 0.902,
+                "probability_distribution": {
+                    "culture": 0.902,
+                    "economy": 0.001,
+                    "international": 0.0,
+                    "local": 0.061,
+                    "religion": 0.0,
+                    "sports": 0.036,
+                },
+                "cleaned_text": "يكن سعر فاكه خضرو موسم انبات اقل غير موسم",
+                "model_used": "svm_classifier",
+                "prediction_metadata": {
+                    "max_probability": 0.902,
+                    "min_probability": 0.0,
+                    "entropy": 0.393,
+                    "num_classes": 6,
+                },
+            }
+        ],
+        "total_texts": 3,
+        "model_used": "svm_classifier",
+    },
+    "sentence_analysis": {
+        "sentences": [
+            {
+                "index": 0,
+                "sentence": "يكون سعر الفاكهة والخضراوات في موسم إنباتها أقل من غيره من المواسم",
+                "score": 2.968,
+                "rank": 3,
+            },
+            {
+                "index": 1,
+                "sentence": "ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات",
+                "score": 3.224,
+                "rank": 2,
+            },
+            {
+                "index": 2,
+                "sentence": "لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه",
+                "score": 3.234,
+                "rank": 1,
+            },
+            {
+                "index": 3,
+                "sentence": "في فصل الخريف يتوفر التفاح والتين والبنجر والكمثرى",
+                "score": 2.642,
+                "rank": 4,
+            },
+        ],
+        "total_sentences": 4,
+        "score_statistics": {"mean": 3.017, "std": 0.254, "min": 2.642, "max": 3.234},
+    },
+    "complete_analysis": {
+        "original_text": EXAMPLE_TEXT,
+        "text_analysis": {
+            "character_count": 282,
+            "word_count": 46,
+            "sentence_count": 4,
+            "arabic_character_count": 252,
+            "arabic_character_ratio": 0.8936,
+            "average_word_length": 5.48,
+            "average_sentence_length": 11.5,
+            "has_diacritics": False,
+            "punctuation_count": 3,
+        },
+        "classification": {
+            "prediction": "culture",
+            "prediction_index": 0,
+            "confidence": 0.902,
+            "probability_distribution": {
+                "culture": 0.902,
+                "economy": 0.001,
+                "international": 0.0,
+                "local": 0.061,
+                "religion": 0.0,
+                "sports": 0.036,
+            },
+            "cleaned_text": "يكن سعر فاكه خضرو موسم انبات اقل غير موسم",
+            "model_used": "svm_classifier",
+            "prediction_metadata": {
+                "max_probability": 0.902,
+                "min_probability": 0.0,
+                "entropy": 0.393,
+                "num_classes": 6,
+            },
+        },
+        "summarization": {
+            "summary": "ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه",
+            "original_sentence_count": 4,
+            "summary_sentence_count": 2,
+            "sentences": [
+                "يكون سعر الفاكهة والخضراوات في موسم إنباتها أقل من غيره من المواسم",
+                "ستلجأ محلات الخضروات إلى عرض الفاكهة بأسعار مناسبة في موسمها بسبب توفر المنتجات",
+                "لا يقتصر الأمر على السعر الأقل، بل سيكون طعامك أشهى وألذ عند تناوله في موسمه",
+                "في فصل الخريف يتوفر التفاح والتين والبنجر والكمثرى",
+            ],
+            "selected_indices": [1, 2],
+            "sentence_scores": [2.968, 3.224, 3.234, 2.642],
+            "top_sentence_scores": [3.224, 3.234],
+        },
+    },
+    "preprocessing": {
+        "task_type": "classification",
+        "preprocessing_steps": {
+            "original_text": EXAMPLE_TEXT,
+            "step_1_remove_diacritics": "يكون سعر الفاكهة والخضراوات في موسم انباتها اقل من غيره من المواسم",
+            "step_2_remove_punctuation": "يكون سعر الفاكهة والخضراوات في موسم انباتها اقل من غيره من المواسم",
+            "step_3_normalize_text": "يكون سعر الفاكهة والخضراوات في موسم انباتها اقل من غيره من المواسم",
+            "step_4_remove_stopwords": "سعر فاكهة خضراوات موسم انباتها اقل غيره مواسم",
+            "step_5_stem_words": "سعر فاكه خضرو موسم انبات اقل غير موسم",
+            "final_result": "سعر فاكه خضرو موسم انبات اقل غير موسم",
+            "preprocessing_summary": {
+                "original_length": 282,
+                "final_length": 47,
+                "reduction_percentage": 83.3,
+                "words_removed": 39,
+                "words_remaining": 7,
+            },
+        },
+    },
+    "model_info": {
+        "classifier": {
+            "model_name": "svm_classifier",
+            "vectorizer_loaded": True,
+            "model_loaded": True,
+            "classes": [
+                "culture",
+                "economy",
+                "international",
+                "local",
+                "religion",
+                "sports",
+            ],
+            "num_classes": 6,
+            "model_type": "SVM with TF-IDF vectorization",
+        },
+        "summarizer": {
+            "vectorizer_loaded": True,
+            "model_type": "TF-IDF based summarization",
+        },
+    },
+}