lets run this

.dockerignore

@@ -0,0 +1,43 @@
+# ── Version control ───────────────────────────────────────────────────────────
+.git
+.gitignore
+
+# ── Python bytecode ───────────────────────────────────────────────────────────
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+dist/
+build/
+
+# ── Virtual environments ──────────────────────────────────────────────────────
+.venv/
+venv/
+env/
+
+# ── Notebooks / research ──────────────────────────────────────────────────────
+research/
+*.ipynb
+.ipynb_checkpoints/
+
+# ── Logs ──────────────────────────────────────────────────────────────────────
+logs/
+*.log
+
+# ── Training data (large – not needed at inference time) ──────────────────────
+artifacts/data_ingestion/
+artifacts/data_transformation/
+artifacts/data_validation/
+
+# ── Intermediate training checkpoints (only final model is needed) ────────────
+artifacts/model_trainer/checkpoint-*/
+
+# ── Evaluation outputs (optional, not needed to serve) ────────────────────────
+artifacts/model_evaluation/
+
+# ── Misc ──────────────────────────────────────────────────────────────────────
+.env
+.env.*
+*.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,53 @@
+# ── Base image ────────────────────────────────────────────────────────────────
+# Use slim Python 3.11 image to keep the final image as small as possible.
+FROM python:3.11-slim
+
+# ── System dependencies ───────────────────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        git \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Working directory ─────────────────────────────────────────────────────────
+WORKDIR /app
+
+# ── Install Python dependencies ───────────────────────────────────────────────
+# Copy only the files needed for the package install first so Docker can cache
+# this expensive layer and only rebuild it when requirements change.
+COPY requirements.txt setup.py README.md ./
+COPY src/ ./src/
+
+RUN pip install --no-cache-dir --upgrade pip \
+ && pip install --no-cache-dir -r requirements.txt
+
+# ── Copy the rest of the application ─────────────────────────────────────────
+COPY config/    ./config/
+COPY params.yaml .
+COPY app.py      .
+COPY main.py     .
+
+# ── Copy trained model artifacts ──────────────────────────────────────────────
+# Only the inference artefacts are needed at runtime – skip training data.
+COPY artifacts/model_trainer/pegasus-samsum-model/ \
+        ./artifacts/model_trainer/pegasus-samsum-model/
+COPY artifacts/model_trainer/tokenizer/ \
+        ./artifacts/model_trainer/tokenizer/
+
+# ── Non-root user (security best practice) ───────────────────────────────────
+RUN useradd -m -u 1000 appuser \
+ && chown -R appuser:appuser /app
+USER appuser
+
+# ── Port ──────────────────────────────────────────────────────────────────────
+# • Hugging Face Spaces: must be 7860
+# • Render / Railway / Fly.io: inject PORT env-var and the app picks it up
+# • Oracle Cloud / local: default falls back to 7860 as well
+EXPOSE 7860
+
+# ── Health check ──────────────────────────────────────────────────────────────
+# Docker / orchestrators will mark the container unhealthy if /health fails.
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:${PORT:-7860}/health')"
+
+# ── Start server ──────────────────────────────────────────────────────────────
+CMD ["python", "app.py"]

app.py

@@ -1,20 +1,60 @@
-from fastapi import FastAPI
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
 import uvicorn
 import subprocess
 import sys
+import os
 from starlette.responses import RedirectResponse
 from fastapi.responses import Response
 from textSummarizer.pipeline.prediction import PredictionPipeline
 
-app = FastAPI(title="AI Text Summarizer", version="1.0.0")
+# ── Shared state ──────────────────────────────────────────────────────────────
+_pipeline: PredictionPipeline | None = None
 
-@app.get("/", tags=["authentication"] )
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Load the model once at startup and keep it in memory."""
+    global _pipeline
+    _pipeline = PredictionPipeline()
+    _pipeline.load_model()          # pre-warms tokenizer + model into RAM
+    yield
+    _pipeline = None                # clean up on shutdown
+
+
+app = FastAPI(
+    title="AI Text Summarizer",
+    version="1.0.0",
+    description="Abstractive text summarization powered by Pegasus/T5.",
+    lifespan=lifespan,
+)
+
+
+# ── Request / Response schemas ────────────────────────────────────────────────
+class SummarizeRequest(BaseModel):
+    text: str
+
+
+class SummarizeResponse(BaseModel):
+    summary: str
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+@app.get("/", tags=["root"])
 async def index():
     return RedirectResponse(url="/docs")
 
 
-@app.get("/train")
+@app.get("/health", tags=["health"])
+async def health_check():
+    """Lightweight endpoint for UptimeRobot / keep-alive pings."""
+    return {"status": "healthy", "model_loaded": _pipeline is not None}
+
+
+@app.get("/train", tags=["training"])
 async def training():
+    """Kick off the full training pipeline (long-running)."""
     try:
         result = subprocess.run(
             [sys.executable, "main.py"],
@@ -26,18 +66,23 @@ async def training():
     except subprocess.TimeoutExpired:
         return Response("Training timed out!", status_code=504)
     except Exception as e:
-        return Response(f"Error Occurred! {e}", status_code=500)
-    
-    
-@app.post("/predict")
-async def predict_route(text):
+        return Response(f"Error: {e}", status_code=500)
+
+
+@app.post("/predict", response_model=SummarizeResponse, tags=["inference"])
+async def predict_route(request: SummarizeRequest):
+    """Summarize the provided text."""
+    if _pipeline is None:
+        raise HTTPException(status_code=503, detail="Model is not loaded yet.")
     try:
-        
-        obj = PredictionPipeline()
-        text = obj.predict(text)
-        return text
+        summary = _pipeline.predict(request.text)
+        return SummarizeResponse(summary=summary)
     except Exception as e:
-        raise e
-    
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ── Entry-point ───────────────────────────────────────────────────────────────
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    # PORT env-var lets each platform (HF Spaces=7860, Render=10000, etc.) inject its own port
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

src/textSummarizer/pipeline/prediction.py

@@ -1,23 +1,37 @@
 from textSummarizer.config.configuration import ConfigurationManager
+from textSummarizer.logging import logger
 from transformers import AutoTokenizer
-from transformers import pipeline
+from transformers import pipeline as hf_pipeline
+
 
 class PredictionPipeline:
+    """Wraps the summarisation model. Call load_model() once to pre-warm,
+    then call predict() for every inference request.  The pipeline object is
+    cached on the instance so the model is only loaded from disk once."""
+
     def __init__(self):
         self.config = ConfigurationManager().get_model_evaluation_config()
-        
-        
-    def predict(self, text):
-        tokenizer = AutoTokenizer.from_pretrained(self.config.tokenizer_path)
-        gen_kwargs = {"length_penalty": 0.8, "num_beams": 8 , "max_length":128 }
-        
-        pipe = pipeline('summarization', model=self.config.model_path, tokenizer=tokenizer)
-        
-        print("Dialogue:")
-        print(text)
-        
-        output = pipe(text, **gen_kwargs)[0]['summary_text']
-        print("\nModel Summary:")
-        print(output)
-        
+        self._pipe = None           # lazy-loaded / pre-warmed via load_model()
+
+    # ------------------------------------------------------------------
+    def load_model(self) -> None:
+        """Load the tokenizer and model into memory (call once at startup)."""
+        logger.info("Loading summarisation model from %s", self.config.model_path)
+        tokenizer = AutoTokenizer.from_pretrained(str(self.config.tokenizer_path))
+        self._pipe = hf_pipeline(
+            "summarization",
+            model=str(self.config.model_path),
+            tokenizer=tokenizer,
+        )
+        logger.info("Model loaded and ready.")
+
+    # ------------------------------------------------------------------
+    def predict(self, text: str) -> str:
+        """Return the summary for *text*. Loads the model on first call if not
+        already pre-warmed (useful for standalone / testing usage)."""
+        if self._pipe is None:
+            self.load_model()
+
+        gen_kwargs = {"length_penalty": 0.8, "num_beams": 8, "max_length": 128}
+        output: str = self._pipe(text, **gen_kwargs)[0]["summary_text"]
         return output