updated docker file

Dockerfile

@@ -1,21 +1,30 @@
 FROM python:3.10-slim
 
-# Set working directory
+# Set working directory inside the container
 WORKDIR /app
 
 # Install system dependencies
+# git is included for any potential future needs or if any dependency requires it for cloning
 RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
 
-# Install Python dependencies
+# Install Python dependencies from requirements.txt
+# Ensure requirements.txt is copied before installing to leverage Docker cache
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Setup Hugging Face cache
+# Download the spaCy English language model
+# This is crucial for resolving the "[E050] Can't find model 'en_core_web_sm'" error
+RUN python -m spacy download en_core_web_sm
+
+# Setup Hugging Face cache directory and permissions
+# This can help manage where Hugging Face models are stored within the container
 ENV HF_HOME=/cache
 RUN mkdir -p /cache && chmod -R 777 /cache
 
-# Copy app code
+# Copy the entire application code into the container
+# This copies your 'app' directory, including main.py, routers, models, etc.
 COPY app ./app
 
-# Run the FastAPI app
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Command to run the FastAPI application using Uvicorn
+# Binds the app to all network interfaces (0.0.0.0) on port 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/core/security.py

@@ -1,7 +1,19 @@
 from fastapi import Header, HTTPException
 
+# Define a simple API key for authentication.
+# In a production environment, this should be a more robust and securely managed key.
 API_KEY = "12345"
 
 def verify_api_key(x_api_key: str = Header(...)):
+    """
+    Dependency function to verify the API key provided in the request headers.
+
+    Args:
+        x_api_key (str): The API key expected in the 'X-API-Key' header.
+
+    Raises:
+        HTTPException: If the provided API key does not match the expected API_KEY.
+    """
     if x_api_key != API_KEY:
+        # Raise an HTTPException with 401 Unauthorized status if the key is invalid.
         raise HTTPException(status_code=401, detail="Unauthorized")

app/main.py

@@ -1,13 +1,21 @@
 from fastapi import FastAPI
+# Import routers for different functionalities
 from app.routers import analyze, paraphrase, translate, summarize
 
+# Initialize the FastAPI application
 app = FastAPI()
 
 @app.get("/")
 def root():
+    """
+    Root endpoint for the API.
+    Returns a welcome message.
+    """
     return {"message": "Welcome to Grammafree API"}
 
-app.include_router(analyze.router)
-app.include_router(paraphrase.router)
-app.include_router(translate.router)
-app.include_router(summarize.router)
+# Include the routers for different API functionalities.
+# This organizes the API into modular components.
+app.include_router(analyze.router)      # For text analysis (grammar, tone, etc.)
+app.include_router(paraphrase.router)   # For paraphrasing text
+app.include_router(translate.router)    # For translating text
+app.include_router(summarize.router)    # For summarizing text

app/routers/paraphrase.py

@@ -3,11 +3,28 @@ from pydantic import BaseModel
 from app import models, prompts
 from app.core.security import verify_api_key
 
+# Create an APIRouter instance. This will handle routes specific to paraphrasing.
 router = APIRouter()
 
 class Input(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /paraphrase endpoint.
+    It expects a single field: 'text' (string).
+    """
     text: str
 
 @router.post("/paraphrase", dependencies=[Depends(verify_api_key)])
 def paraphrase(input: Input):
-    return {"result": models.run_flan_prompt(prompts.paraphrase_prompt(input.text))}
+    """
+    Endpoint to paraphrase the given text.
+
+    Args:
+        input (Input): The request body containing the text to be paraphrased.
+        (dependencies=[Depends(verify_api_key)]): Ensures the API key is verified before execution.
+
+    Returns:
+        dict: A dictionary containing the paraphrased result.
+    """
+    # Call the FLAN-T5 model with the paraphrase prompt to get the result.
+    paraphrased_text = models.run_flan_prompt(prompts.paraphrase_prompt(input.text))
+    return {"result": paraphrased_text}

app/routers/summarize.py

@@ -3,11 +3,28 @@ from pydantic import BaseModel
 from app import models, prompts
 from app.core.security import verify_api_key
 
+# Create an APIRouter instance. This will handle routes specific to summarization.
 router = APIRouter()
 
 class Input(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /summarize endpoint.
+    It expects a single field: 'text' (string).
+    """
     text: str
 
 @router.post("/summarize", dependencies=[Depends(verify_api_key)])
 def summarize(input: Input):
-    return {"result": models.run_flan_prompt(prompts.summarize_prompt(input.text))}
+    """
+    Endpoint to summarize the given text.
+
+    Args:
+        input (Input): The request body containing the text to be summarized.
+        (dependencies=[Depends(verify_api_key)]): Ensures the API key is verified before execution.
+
+    Returns:
+        dict: A dictionary containing the summarized result.
+    """
+    # Call the FLAN-T5 model with the summarize prompt to get the result.
+    summarized_text = models.run_flan_prompt(prompts.summarize_prompt(input.text))
+    return {"result": summarized_text}

app/routers/translate.py

@@ -3,12 +3,29 @@ from pydantic import BaseModel
 from app import models
 from app.core.security import verify_api_key
 
+# Create an APIRouter instance. This will handle routes specific to translation.
 router = APIRouter()
 
 class TranslateInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /translate endpoint.
+    It expects two fields: 'text' (string) and 'target_lang' (string).
+    """
     text: str
     target_lang: str
 
 @router.post("/translate", dependencies=[Depends(verify_api_key)])
 def translate(input: TranslateInput):
-    return {"result": models.run_translation(input.text, input.target_lang)}
+    """
+    Endpoint to translate the given text to a target language.
+
+    Args:
+        input (TranslateInput): The request body containing the text and target language.
+        (dependencies=[Depends(verify_api_key)]): Ensures the API key is verified before execution.
+
+    Returns:
+        dict: A dictionary containing the translated result.
+    """
+    # Call the translation model with the text and target language.
+    translated_text = models.run_translation(input.text, input.target_lang)
+    return {"result": translated_text}