Refactor: reorganize into core/, api/, web/, templates/

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/{routers → api}/inference.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, HTTPException
-from ..model_loader import get_classifier
-from ..schemas import PredictRequest, PredictResponse, ClassifyBatchRequest, ClassifyBatchResponse
+from ..core.model_loader import get_classifier
+from ..core.schemas import PredictRequest, PredictResponse, ClassifyBatchRequest, ClassifyBatchResponse
 from ..services.classifier import classify_one, classify_many
 from ..utils import normalize
 
@@ -10,14 +10,14 @@ router = APIRouter(tags=["inference"])
 @router.post("/classify", response_model=PredictResponse)
 def classify(request: PredictRequest):
     if get_classifier() is None:
-        raise HTTPException(status_code=503, detail="Modelo no disponible")
+        raise HTTPException(status_code=503, detail="Model not available")
     return classify_one(normalize(request.text), request.text)
 
 
 @router.post("/classify/batch", response_model=ClassifyBatchResponse)
 def classify_batch(request: ClassifyBatchRequest):
     if get_classifier() is None:
-        raise HTTPException(status_code=503, detail="Modelo no disponible")
+        raise HTTPException(status_code=503, detail="Model not available")
     normalized = [normalize(t) for t in request.texts]
     results, from_cache = classify_many(normalized, request.texts)
     return ClassifyBatchResponse(results=results, total=len(results), from_cache=from_cache)

app/{routers → api}/meta.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
-from ..model_loader import get_categories
-from ..category_meta import CATEGORY_META
+from ..core.model_loader import get_categories
+from ..core.category_meta import CATEGORY_META
 from ..services.classifier import get_cache
 
 router = APIRouter(tags=["meta"])

app/{model_loader.py → core/model_loader.py}

@@ -4,13 +4,14 @@ from transformers import pipeline
 from huggingface_hub import hf_hub_download
 
 HF_REPO = "cmeneses99/sms-classifier"
-MODEL_DIR = Path(__file__).parent.parent / "model"
+MODEL_DIR = Path(__file__).parent.parent.parent / "model"
 
 _classifier = None
 _categories: list[str] = []
 
 
 def _ensure_model() -> Path:
+    """Download model files from HF Hub if not present locally."""
     if (MODEL_DIR / "config.json").exists():
         return MODEL_DIR
 
@@ -30,6 +31,7 @@ def _ensure_model() -> Path:
 
 
 def load_model() -> None:
+    """Load the classifier pipeline and category labels into module-level state."""
     global _classifier, _categories
 
     model_path = _ensure_model()

app/{schemas.py → core/schemas.py}

@@ -9,8 +9,8 @@ class PredictRequest(BaseModel):
     def sanitize(cls, v: str) -> str:
         v = v.strip()
         if not v:
-            raise ValueError("El texto no puede estar vacío o contener solo espacios")
-        # Colapsa whitespace excesivo (tabs, múltiples espacios, newlines)
+            raise ValueError("Text cannot be empty or contain only whitespace")
+        # collapse excessive whitespace (tabs, multiple spaces, newlines)
         v = " ".join(v.split())
         return v
 
@@ -37,9 +37,9 @@ class ClassifyBatchRequest(BaseModel):
         for text in v:
             text = " ".join(text.strip().split())
             if not text:
-                raise ValueError("Cada texto debe tener al menos un carácter")
+                raise ValueError("Each text must have at least one character")
             if len(text) > 512:
-                raise ValueError("Cada texto debe tener máximo 512 caracteres")
+                raise ValueError("Each text must have at most 512 characters")
             result.append(text)
         return result
 

app/main.py

@@ -1,7 +1,8 @@
 from contextlib import asynccontextmanager
 from fastapi import FastAPI
-from .model_loader import load_model
-from .routers import pages, inference, meta
+from .core.model_loader import load_model
+from .api import inference, meta
+from .web import pages
 
 
 @asynccontextmanager
@@ -12,7 +13,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="SMS Classifier API",
-    description="Clasifica mensajes SMS en categorías usando DistilBERT fine-tuned.",
+    description="Classifies SMS messages into categories using fine-tuned DistilBERT.",
     version="2.0.0",
     lifespan=lifespan,
 )

app/services/classifier.py

@@ -1,6 +1,6 @@
-from ..cache import LRUCache
-from ..model_loader import get_classifier
-from ..schemas import PredictResponse, IntentPrediction
+from ..core.cache import LRUCache
+from ..core.model_loader import get_classifier
+from ..core.schemas import PredictResponse, IntentPrediction
 
 _cache = LRUCache(max_size=512)
 
@@ -10,6 +10,7 @@ def get_cache() -> LRUCache:
 
 
 def run_inference(texts: list[str]) -> list[PredictResponse]:
+    """Run the model on a list of texts and return structured responses."""
     classifier = get_classifier()
     raw = classifier(texts, batch_size=16)
     responses = []
@@ -24,6 +25,7 @@ def run_inference(texts: list[str]) -> list[PredictResponse]:
 
 
 def classify_one(normalized_text: str, original_text: str) -> PredictResponse:
+    """Classify a single message, using cache when available."""
     cached = _cache.get(normalized_text)
     if cached:
         return cached.model_copy(update={"cached": True})
@@ -34,7 +36,7 @@ def classify_one(normalized_text: str, original_text: str) -> PredictResponse:
 
 
 def classify_many(normalized_texts: list[str], original_texts: list[str]) -> tuple[list[PredictResponse], int]:
-    """Returns (results, from_cache_count)."""
+    """Classify a batch of messages. Returns (results, from_cache_count)."""
     results: list[PredictResponse | None] = [None] * len(normalized_texts)
     from_cache = 0
     pending = []

app/utils.py

@@ -1,14 +1,15 @@
 import unicodedata
 from pathlib import Path
 
-_STATIC = Path(__file__).parent / "static"
+_TEMPLATES = Path(__file__).parent / "templates"
 
 
 def normalize(text: str) -> str:
+    """Lowercase and strip accents for cache-key normalization."""
     text = text.lower()
     text = unicodedata.normalize("NFD", text)
     return "".join(c for c in text if unicodedata.category(c) != "Mn")
 
 
 def read_static(filename: str) -> str:
-    return (_STATIC / filename).read_text(encoding="utf-8")
+    return (_TEMPLATES / filename).read_text(encoding="utf-8")