Update app.py

app.py

@@ -1,31 +1,17 @@
 import os
 import sys
 import time
+import json
 import logging
 import traceback
 from contextlib import asynccontextmanager
-from typing import List, Dict, Any
+from typing import Dict, Any
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field
 
-# ==================== Safe optional imports ====================
-
-try:
-    from transformers import pipeline  # type: ignore
-except Exception as e:  # pragma: no cover
-    pipeline = None  # type: ignore
-    logging.error(f"[ImportError] transformers not available: {e}", file=sys.stderr)  # type: ignore
-
-try:
-    from langdetect import detect  # type: ignore
-except Exception as e:  # pragma: no cover
-    detect = None  # type: ignore
-    logging.error(f"[ImportError] langdetect not available: {e}", file=sys.stderr)  # type: ignore
-
-
-# ==================== Logging ====================
+# ===================== ЛОГИРОВАНИЕ =====================
 
 logging.basicConfig(
     level=logging.INFO,
@@ -33,66 +19,65 @@ logging.basicConfig(
     handlers=[logging.StreamHandler(sys.stderr)],
 )
 
-logger = logging.getLogger("eroha")
+logger = logging.getLogger("eroha-app")
+
+# ===================== БЕЗОПАСНЫЕ ИМПОРТЫ =====================
 
+try:
+    from transformers import pipeline
+    from langdetect import detect
+except Exception as e:  # noqa: BLE001
+    # ВАЖНО: без параметра file=...
+    logger.error("[ImportError] transformers/langdetect not available: %s", e, exc_info=True)
+
+    pipeline = None  # type: ignore[assignment]
+    # запасной детектор языка
+    def detect(text: str) -> str:  # type: ignore[no-redef]
+        return "en"
 
-# ==================== Environment / HF cache ====================
+
+# ===================== НАСТРОЙКИ HF =====================
 
 HF_HOME = "/tmp/huggingface"
 os.environ["HF_HOME"] = HF_HOME
 os.makedirs(HF_HOME, exist_ok=True)
 
-
-# ==================== Pydantic models ====================
+# ===================== Pydantic-модели =====================
 
 
 class SummarizeRequest(BaseModel):
     text: str = Field(..., min_length=3, max_length=1_000_000)
 
-    @validator("text")
-    def not_empty(cls, v: str) -> str:
-        if not v.strip():
-            raise ValueError("Text cannot be empty or whitespace only")
-        return v
+    def clean_text(self) -> str:
+        return self.text.strip()
 
 
 class CheckRequest(BaseModel):
-    text: str = Field(..., min_length=1, max_length=500_000)
+    data: str = Field(..., min_length=1, max_length=500_000)
 
-    @validator("text")
-    def not_empty(cls, v: str) -> str:
-        if not v.strip():
-            raise ValueError("Text cannot be empty or whitespace only")
-        return v
+    def clean_text(self) -> str:
+        return self.data.strip()
 
 
-class HealthResponse(BaseModel):
-    status: str
-    version: str
-    endpoints: List[str]
-    cached_models: List[str]
-
-
-# ==================== Model management ====================
+# ===================== КЭШ МОДЕЛЕЙ =====================
 
 _model_cache: Dict[str, Any] = {}
 
 
-def _safe_detect_lang(text: str) -> str:
-    if detect is None:
-        return "en"
+def safe_detect_lang(text: str) -> str:
     try:
-        return detect(text)  # type: ignore[call-arg]
-    except Exception:
+        lang = detect(text)
+        return lang or "en"
+    except Exception:  # noqa: BLE001
         return "en"
 
 
-def _get_model(lang: str):
+def get_model(lang: str):
     if pipeline is None:
-        raise RuntimeError("Transformers pipeline unavailable")
+        raise RuntimeError("Transformers pipeline is not available")
 
     if lang in _model_cache:
-        logger.info("[ModelCache] using cached model for %s", lang)
+        logger.info("[ModelCache] Using cached model for %s", lang)
         return _model_cache[lang]
 
     model_map = {
@@ -105,77 +90,43 @@ def _get_model(lang: str):
     }
     model_name = model_map.get(lang, "facebook/bart-large-cnn")
 
-    logger.info("[ModelLoad] loading model for %s: %s", lang, model_name)
-    try:
-        # CPU-режим (device=-1) — безопасно для HF Spaces
-        model = pipeline("summarization", model=model_name, device=-1)  # type: ignore[arg-type]
-        _model_cache[lang] = model
-        logger.info("[ModelLoad] model for %s ready", lang)
-        return model
-    except Exception as e:  # pragma: no cover
-        logger.error("[ModelLoad] failed to load %s: %s", lang, e)
-        raise
-
-
-def _summarize(text: str, lang: str) -> Dict[str, Any]:
-    summarizer = _get_model(lang)
-
-    max_input_length = 3000  # защита от слишком длинных текстов
-    input_text = text[:max_input_length]
-
-    result = summarizer(
-        input_text,
-        max_length=180,
-        min_length=40,
-        do_sample=False,
-    )
-
-    summary = result[0]["summary_text"].replace("▁", " ").strip()
+    logger.info("[ModelLoad] Loading model for %s: %s", lang, model_name)
+    model = pipeline("summarization", model=model_name, device=-1)
+    _model_cache[lang] = model
+    logger.info("[ModelLoad] Cached model for %s", lang)
+    return model
 
-    json_ld = {
-        "@context": "https://schema.org",
-        "@type": "NewsArticle",
-        "headline": summary[:80],
-        "inLanguage": lang,
-        "publisher": {"@type": "Organization", "name": "Eroha AI Publisher"},
-    }
-
-    return {
-        "summary": summary,
-        "summary_length": len(summary),
-        "original_length": len(text),
-        "truncated": len(text) > max_input_length,
-        "seo_json_ld": json_ld,
-    }
-
-
-# ==================== Lifespan: warmup on startup ====================
 
+# ===================== LIFESPAN (WARMUP) =====================
 
 @asynccontextmanager
-async def lifespan(app: FastAPI):  # type: ignore[override]
-    logger.info("[Startup] application starting, warming models...")
+async def lifespan(app: FastAPI):  # noqa: ARG001
     start = time.time()
-    if pipeline is not None:
-        for lang in ("en", "ru"):
-            try:
-                _get_model(lang)
-            except Exception as e:
-                logger.error("[Startup] warmup for %s failed: %s", lang, e)
-    else:
-        logger.warning("[Startup] transformers pipeline unavailable, skipping warmup")
+    logger.info("[Lifespan] Application startup – warmup models...")
 
-    logger.info("[Startup] warmup finished in %.2fs", time.time() - start)
-    yield
-    logger.info("[Shutdown] application stopping")
+    try:
+        if pipeline is not None:
+            for lang in ("en", "ru"):
+                try:
+                    get_model(lang)
+                except Exception as e:  # noqa: BLE001
+                    logger.error("[Lifespan] Warmup failed for %s: %s", lang, e, exc_info=True)
+        else:
+            logger.warning("[Lifespan] transformers pipeline is None – warmup skipped")
+    except Exception as e:  # noqa: BLE001
+        logger.error("[Lifespan] Warmup error: %s", e, exc_info=True)
+
+    elapsed = time.time() - start
+    logger.info("[Lifespan] Startup warmup finished in %.2f s", elapsed)
 
+    yield
 
-# ==================== FastAPI app ====================
+    logger.info("[Lifespan] Application shutdown")
 
 
 app = FastAPI(
     title="Eroha AI Summarizer PRO",
-    version="v3.4",
+    version="3.4",
     lifespan=lifespan,
 )
 
@@ -186,18 +137,17 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# ===================== ЭНДПОИНТЫ =====================
 
-# ==================== Routes ====================
 
-
-@app.get("/", response_model=HealthResponse)
-async def root() -> HealthResponse:
-    return HealthResponse(
-        status="ok",
-        version="v3.4",
-        endpoints=["/ping", "/check", "/summarize", "/warmup"],
-        cached_models=list(_model_cache.keys()),
-    )
+@app.get("/")
+async def root():
+    return {
+        "status": "ok",
+        "version": "v3.4",
+        "cached_models": list(_model_cache.keys()),
+        "endpoints": ["/ping", "/check", "/summarize", "/warmup"],
+    }
 
 
 @app.get("/ping")
@@ -205,71 +155,96 @@ async def ping():
     return {
         "status": "healthy",
         "cached_models": list(_model_cache.keys()),
-        "time": time.time(),
     }
 
 
 @app.get("/warmup")
-async def manual_warmup():
-    if pipeline is None:
-        return {
-            "status": "skipped",
-            "reason": "transformers pipeline unavailable",
-        }
+async def warmup():
+    try:
+        if pipeline is None:
+            return {
+                "status": "skipped",
+                "reason": "transformers pipeline is not available",
+            }
 
-    loaded = []
-    errors = {}
-    for lang in ("en", "ru"):
-        try:
-            _get_model(lang)
-            loaded.append(lang)
-        except Exception as e:  # pragma: no cover
-            errors[lang] = str(e)
+        loaded = []
+        for lang in ("en", "ru"):
+            try:
+                get_model(lang)
+                loaded.append(lang)
+            except Exception as e:  # noqa: BLE001
+                logger.error("[Warmup] Failed for %s: %s", lang, e, exc_info=True)
 
-    return {
-        "status": "ok" if not errors else "partial",
-        "loaded": loaded,
-        "errors": errors,
-        "cached_models": list(_model_cache.keys()),
-    }
+        return {
+            "status": "ok",
+            "preloaded": loaded,
+            "cache_size": len(_model_cache),
+        }
+    except Exception as e:  # noqa: BLE001
+        logger.error("[Warmup] Error: %s", e, exc_info=True)
+        raise HTTPException(status_code=500, detail="Warmup failed") from e
 
 
 @app.post("/check")
 async def check_text(req: CheckRequest):
     try:
-        lang = _safe_detect_lang(req.text)
+        text = req.clean_text()
+        lang = safe_detect_lang(text)
         return {
             "status": "success",
-            "preview": req.text[:150],
-            "length": len(req.text),
+            "preview": text[:150],
+            "length": len(text),
             "detected_language": lang,
         }
-    except Exception as e:  # pragma: no cover
+    except Exception as e:  # noqa: BLE001
         logger.error("/check error: %s", traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e
 
 
 @app.post("/summarize")
 async def summarize(req: SummarizeRequest):
-    if pipeline is None:
-        raise HTTPException(
-            status_code=503,
-            detail="transformers pipeline is not available in this environment",
-        )
-
     try:
-        lang = _safe_detect_lang(req.text)
-        logger.info("[Summarize] language=%s, length=%d", lang, len(req.text))
-        data = _summarize(req.text, lang)
-        return {"status": "success", "language": lang, **data}
-    except Exception as e:  # pragma: no cover
+        text = req.clean_text()
+        if not text:
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+
+        lang = safe_detect_lang(text)
+        model = get_model(lang)
+
+        max_input_length = 3000
+        input_text = text[:max_input_length]
+
+        result = model(input_text, max_length=180, min_length=40, do_sample=False)
+        summary = result[0]["summary_text"].replace("▁", " ").strip()
+
+        seo_json_ld = {
+            "@context": "https://schema.org",
+            "@type": "NewsArticle",
+            "headline": summary[:80],
+            "inLanguage": lang,
+            "publisher": {
+                "@type": "Organization",
+                "name": "Eroha AI Publisher",
+            },
+        }
+
+        return {
+            "status": "success",
+            "language": lang,
+            "summary": summary,
+            "summary_length": len(summary),
+            "original_length": len(text),
+            "truncated": len(text) > max_input_length,
+            "seo_json_ld": seo_json_ld,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:  # noqa: BLE001
         logger.error("/summarize error: %s", traceback.format_exc())
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e
 
 
 if __name__ == "__main__":
     import uvicorn
 
-    port = int(os.getenv("PORT", "7860"))
-    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=False)
-
+    uvicorn.run(app, host="0.0.0.0", port=7860)