1st commit

Dockerfile

@@ -0,0 +1,34 @@
+# Image légère Python
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/root/.cache/huggingface
+
+# Déps système minimales (certs, locales, build basique)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl ca-certificates git \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Fichiers app
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip \
+ && pip install -r /app/requirements.txt
+
+# Copier le code
+COPY app /app/app
+
+# (Optionnel) Pré-télécharger le modèle au build pour accélérer le premier run
+RUN ls -la
+COPY model_downloader.py /app/model_downloader.py
+RUN python /app/model_downloader.py
+
+# HF Spaces: écouter sur $PORT (par défaut 7860)
+ENV PORT=7860
+EXPOSE 7860
+
+# Lancer l'app
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,39 @@
+# Park4night Reviews Summarizer (FastAPI)
+
+FastAPI pour résumer **une liste d'avis** (multi-avis) avec stratégie hiérarchique.
+Conçu pour Space Docker Hugging Face (écoute sur `$PORT`, default 7860).
+
+## Build Docker
+
+```
+docker build -t park4night-summarizer . --progress=plain
+```
+
+## Run Docker Container
+
+```
+docker run -d -p 7860:7860 --name p4n-ai park4night-summarizer
+```
+
+
+
+
+## Endpoints
+
+- `GET /health`
+- `POST /summarize-list`  
+  Body:
+  ```json
+  {
+    "reviews": ["avis 1", "avis 2", "..."],
+    "group_size": 5,
+    "partial_target_ratio": 0.5,
+    "final_target_ratio": 0.6,
+    "num_beams": 5
+  }
+-`GET /summarize-place?place_id=645109&lang=fr`
+  Params
+  ```
+  place_id='645109'
+  lang='fr'
+  ```

app/main.py

@@ -0,0 +1,223 @@
+import os
+import warnings
+from typing import List, Optional
+
+import torch
+import httpx
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+
+# ——— Filtrer quelques warnings bruyants mais bénins ———
+warnings.filterwarnings("ignore", message="To copy construct from a tensor", category=UserWarning)
+warnings.filterwarnings("ignore", message="Unfeasible length constraints", category=UserWarning)
+
+# ——— Config ———
+MODEL_NAME = os.getenv("MODEL_NAME", "facebook/bart-large-cnn")
+TOKENIZER_MAX_LEN = int(os.getenv("TOKENIZER_MAX_LEN", "1024"))
+PORT = int(os.getenv("PORT", "7860"))
+P4N_COMM_URL = "https://park4night.com/services/V4.1/commGet.php"
+P4N_TRAD_URL = "https://park4night.com/services/V4.1/commGetTrad_cors.php"
+HTTP_TIMEOUT = float(os.getenv("HTTP_TIMEOUT", "15"))
+
+def get_device():
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    # MPS utile en dev local sur Mac ; côté HF Spaces Docker tu seras sur CPU ou GPU CUDA
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+DEVICE = get_device()
+torch.set_num_threads(int(os.getenv("TORCH_NUM_THREADS", "1")))
+
+# ——— Chargement modèle/tokenizer au démarrage ———
+tokenizer = AutoTokenizer.from_pretrained(
+    MODEL_NAME,
+    model_max_length=TOKENIZER_MAX_LEN,
+    truncation_side="right",
+)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(DEVICE)
+
+# ——— FastAPI ———
+app = FastAPI(title="Park4night Reviews Summarizer", version="1.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True,
+    allow_methods=["*"], allow_headers=["*"],
+)
+
+# ——— Schemas ———
+class SummarizeListRequest(BaseModel):
+    reviews: List[str]
+    group_size: Optional[int] = 5
+    partial_target_ratio: Optional[float] = 0.5
+    final_target_ratio: Optional[float] = 0.6
+    max_new_cap_partial: Optional[int] = 180
+    max_new_cap_final: Optional[int] = 220
+    num_beams: Optional[int] = 5
+
+class SummarizeListResponse(BaseModel):
+    summary: str
+    partial_summaries: Optional[List[str]] = None
+
+# ——— Utils ———
+def _postprocess_sentence_end(text: str) -> str:
+    text = text.strip()
+    if not text:
+        return text
+    if text[-1] not in [".", "!", "?"]:
+        # tente de couper proprement à la dernière phrase
+        if "." in text:
+            text = text.rsplit(".", 1)[0] + "."
+        else:
+            text += "."
+    return text
+
+def _generate_summary(inputs, max_new_tokens: int, num_beams: int = 5) -> str:
+    with torch.inference_mode():
+        summary_ids = model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            do_sample=False,
+            num_beams=num_beams,
+            length_penalty=1.1,
+            early_stopping=False,
+            no_repeat_ngram_size=3,
+        )
+    text = tokenizer.decode(summary_ids[0], skip_special_tokens=True)
+    return _postprocess_sentence_end(text)
+
+def _prepare_inputs(text: str):
+    return tokenizer(
+        text,
+        return_tensors="pt",
+        truncation=True,
+        max_length=TOKENIZER_MAX_LEN,
+    ).to(DEVICE)
+
+def _summarize_chunk(
+    text: str,
+    target_ratio: float = 0.5,
+    max_new_cap: int = 180,
+    num_beams: int = 5,
+) -> str:
+    inputs = _prepare_inputs(text)
+    in_tokens = inputs["input_ids"].shape[1]
+    est_new = max(40, int(in_tokens * target_ratio))
+    max_new_tokens = min(max_new_cap, est_new)
+    return _generate_summary(inputs, max_new_tokens=max_new_tokens, num_beams=num_beams)
+
+async def fetch_reviews(place_id: int, lang: str = "fr") -> List[str]:
+    """
+    Récupère les avis d'un lieu Park4night et les traduit via l'endpoint interne (context_lang).
+    Appels asynchrones pour accélérer.
+    """
+    async with httpx.AsyncClient(timeout=HTTP_TIMEOUT) as client:
+        r = await client.get(P4N_COMM_URL, params={"lieu_id": place_id})
+        r.raise_for_status()
+        data = r.json()
+        comments = data.get("commentaires", [])
+        if not comments:
+            return []
+
+        # paralléliser les traductions
+        async def _get_trad(cid: int):
+            tr = await client.get(P4N_TRAD_URL, params={"id_comm": cid, "context_lang": lang})
+            tr.raise_for_status()
+            return tr.json().get("translation", "")
+
+        tasks = [_get_trad(c["id"]) for c in comments if "id" in c]
+        translations = await asyncio_gather_limited(tasks, limit=10)
+        return [t for t in translations if t and t.strip()]
+
+async def asyncio_gather_limited(tasks, limit: int = 10):
+    """
+    Regroupe des coroutines avec un parallélisme limité.
+    """
+    import asyncio
+    semaphore = asyncio.Semaphore(limit)
+    async def sem_task(coro):
+        async with semaphore:
+            return await coro
+    return await asyncio.gather(*[sem_task(t) for t in tasks])
+
+def summarize_reviews(
+    reviews: List[str],
+    group_size: int = 5,
+    partial_target_ratio: float = 0.5,
+    final_target_ratio: float = 0.6,
+    max_new_cap_partial: int = 180,
+    max_new_cap_final: int = 220,
+    num_beams: int = 5,
+) -> SummarizeListResponse:
+    if not reviews:
+        return SummarizeListResponse(summary="", partial_summaries=[])
+
+    partial_summaries: List[str] = []
+    # Étape 1 : résumés partiels
+    for i in range(0, len(reviews), group_size):
+        group_text = "\n".join(reviews[i : i + group_size])
+        partial = _summarize_chunk(
+            group_text,
+            target_ratio=partial_target_ratio,
+            max_new_cap=max_new_cap_partial,
+            num_beams=num_beams,
+        )
+        partial_summaries.append(partial)
+
+    # Étape 2 : résumé global
+    combined = " ".join(partial_summaries)
+    final = _summarize_chunk(
+        combined,
+        target_ratio=final_target_ratio,
+        max_new_cap=max_new_cap_final,
+        num_beams=num_beams,
+    )
+
+    return SummarizeListResponse(summary=final, partial_summaries=None)
+
+# ——— Endpoints ———
+@app.get("/health")
+def health():
+    return {"status": "ok", "model": MODEL_NAME, "device": str(DEVICE)}
+
+@app.post("/summarize-list", response_model=SummarizeListResponse)
+def summarize_list(body: SummarizeListRequest):
+    if not body.reviews:
+        raise HTTPException(400, "reviews is empty")
+    return summarize_reviews(
+        reviews=body.reviews,
+        group_size=body.group_size,
+        partial_target_ratio=body.partial_target_ratio,
+        final_target_ratio=body.final_target_ratio,
+        max_new_cap_partial=body.max_new_cap_partial,
+        max_new_cap_final=body.max_new_cap_final,
+        num_beams=body.num_beams,
+    )
+
+@app.get("/summarize-place", response_model=SummarizeListResponse)
+async def summarize_place(
+    place_id: int = Query(..., description="park4night lieu_id"),
+    lang: str = Query("fr", description="langue cible (ex: fr, en, es, de, it, nl)"),
+    group_size: int = 5,
+    partial_target_ratio: float = 0.5,
+    final_target_ratio: float = 0.6,
+    num_beams: int = 5,
+):
+    reviews = await fetch_reviews(place_id, lang=lang)
+    if not reviews:
+        raise HTTPException(404, f"Aucun avis pour lieu_id={place_id}")
+    return summarize_reviews(
+        reviews=reviews,
+        group_size=group_size,
+        partial_target_ratio=partial_target_ratio,
+        final_target_ratio=final_target_ratio,
+        num_beams=num_beams,
+    )
+
+# ——— Lancement local (utile hors Spaces) ———
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=PORT, reload=False, workers=1)

model_downloader.py

@@ -0,0 +1,6 @@
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM; \
+import os; \
+name=os.getenv("MODEL_NAME","facebook/bart-large-cnn"); \
+tok=AutoTokenizer.from_pretrained(name); \
+_ = AutoModelForSeq2SeqLM.from_pretrained(name); \
+print("Model cached:", name)

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.5
+uvicorn[standard]==0.32.0
+httpx==0.27.2
+transformers==4.44.2
+accelerate==0.34.2
+torch