added new routes

app/core/security.py

@@ -1,8 +1,14 @@
 from fastapi import Header, HTTPException
+import os
 
 # Define a simple API key for authentication.
 # In a production environment, this should be a more robust and securely managed key.
-API_KEY = "12345"
+# Load API_KEY from an environment variable for security.
+# Fallback to a default for local development if not set, but warn about it.
+API_KEY = os.getenv("GRAMMAFREE_API_KEY", "12345") # Use a strong default for production!
+
+if API_KEY == "12345":
+    print("WARNING: Using default API_KEY. Set GRAMMAFREE_API_KEY environment variable in production!")
 
 def verify_api_key(x_api_key: str = Header(...)):
     """

app/main.py

@@ -1,6 +1,25 @@
 from fastapi import FastAPI
-# Import routers for different functionalities
-from app.routers import analyze, paraphrase, translate, summarize
+import logging # Import logging module
+
+# Configure basic logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Import all individual routers for different functionalities
+from app.routers import (
+    grammar,
+    punctuation,
+    sentence_correctness,
+    tone,
+    voice,
+    inclusive_language,
+    vocabulary,
+    conciseness,
+    readability,
+    paraphrase,
+    translate,
+    summarize
+)
 
 # Initialize the FastAPI application
 app = FastAPI()
@@ -11,11 +30,19 @@ def root():
     Root endpoint for the API.
     Returns a welcome message.
     """
+    logger.info("Root endpoint accessed.")
     return {"message": "Welcome to Grammafree API"}
 
-# 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
+# Include all the individual routers for modular API structure.
+app.include_router(grammar.router)            # Grammar correction and diffs
+app.include_router(punctuation.router)        # Punctuation fixes
+app.include_router(sentence_correctness.router) # Sentence correctness feedback
+app.include_router(tone.router)               # Tone detection and suggestions
+app.include_router(voice.router)              # Active/Passive voice detection
+app.include_router(inclusive_language.router) # Inclusive language rewriting
+app.include_router(vocabulary.router)         # Vocabulary enhancement
+app.include_router(conciseness.router)        # Conciseness suggestions
+app.include_router(readability.router)        # Readability scores
+app.include_router(paraphrase.router)         # Existing paraphrasing functionality
+app.include_router(translate.router)          # Existing translation functionality
+app.include_router(summarize.router)          # Existing summarization functionality

app/prompts.py

@@ -95,3 +95,27 @@ def tone_analysis_prompt(text: str) -> str:
         str: The generated prompt.
     """
     return f"Analyze the tone of the following text and suggest improvements if needed: {text}"
+
+def vocabulary_prompt(text: str) -> str:
+    """
+    Generates a prompt to suggest vocabulary improvements for the given text.
+
+    Args:
+        text (str): The original text.
+
+    Returns:
+        str: The generated prompt.
+    """
+    return f"For the following text, identify any weak or overused words and suggest stronger, more precise synonyms or alternative phrasing. Provide suggestions as a list of 'original word/phrase -> suggested word/phrase': {text}"
+
+def conciseness_prompt(text: str) -> str:
+    """
+    Generates a prompt to make the given text more concise.
+
+    Args:
+        text (str): The original text.
+
+    Returns:
+        str: The generated prompt.
+    """
+    return f"Rewrite the following text to be more concise, removing any unnecessary words or phrases while retaining the original meaning: {text}"

app/routers/analyze.py

@@ -1,153 +0,0 @@
-from fastapi import APIRouter, Depends, Request
-from pydantic import BaseModel
-from app import models, prompts
-from app.core.security import verify_api_key
-import language_tool_python
-import spacy
-import difflib # Import the difflib module for text comparisons
-
-router = APIRouter()
-
-# Load the spaCy English language model for natural language processing tasks,
-# such as dependency parsing for active/passive voice detection.
-# IMPORTANT: If you get an OSError: [E050] Can't find model 'en_core_web_sm',
-# you need to run: python -m spacy download en_core_web_sm in your terminal.
-try:
-    nlp = spacy.load("en_core_web_sm")
-except OSError:
-    print("SpaCy model 'en_core_web_sm' not found. Please run: python -m spacy download en_core_web_sm")
-    # You might want to raise an HTTPException or provide a dummy NLP object
-    # if the model is crucial for the application to function.
-    # For now, we'll let it fail if not installed, as it's a critical dependency.
-    raise
-
-# Initialize LanguageTool for grammar, spelling, and style checking.
-# 'en-US' specifies the English (United States) language.
-tool = language_tool_python.LanguageTool('en-US')
-
-class AnalyzeInput(BaseModel):
-    """
-    Pydantic BaseModel for validating the input request body for the /analyze endpoint.
-    It expects a single field: 'text' (string).
-    """
-    text: str
-
-# Apply the verify_api_key dependency at the router level for this endpoint.
-# The Request object is now correctly handled without being wrapped by Depends.
-@router.post("/analyze", dependencies=[Depends(verify_api_key)])
-def analyze_text(payload: AnalyzeInput):
-    """
-    Analyzes the provided text for grammar, punctuation, sentence correctness,
-    tone, active/passive voice, and inclusive pronoun suggestions.
-
-    Args:
-        payload (AnalyzeInput): The request body containing the text to be analyzed.
-        (dependencies=[Depends(verify_api_key)]): Ensures the API key is verified before execution.
-
-    Returns:
-        dict: A dictionary containing various analysis results structured as per requirements.
-    """
-    text = payload.text
-
-    # --- 1. Grammar Suggestions with Diffs ---
-    # Get the grammatically corrected version of the original text.
-    # Note: The 'vennify/t5-base-grammar-correction' model's performance
-    # can vary. For more robust corrections, especially for subtle spelling
-    # and grammar errors, consider a larger or fine-tuned model if needed.
-    corrected_grammar = models.run_grammar_correction(text)
-    
-    grammar_changes = []
-    # Use difflib to find differences between the original and corrected text.
-    # We split by words to get word-level diffs, which are easier to interpret.
-    s = difflib.SequenceMatcher(None, text.split(), corrected_grammar.split())
-    
-    # Iterate through the operations (opcodes) generated by SequenceMatcher.
-    # 'equal', 'replace', 'delete', 'insert' are the types of operations.
-    for opcode, i1, i2, j1, j2 in s.get_opcodes():
-        if opcode == 'replace':
-            # If words are replaced, format as "'original_word' -> 'corrected_word'"
-            original_part = ' '.join(text.split()[i1:i2])
-            corrected_part = ' '.join(corrected_grammar.split()[j1:j2])
-            grammar_changes.append(f"'{original_part}' \u2192 '{corrected_part}'") # Using Unicode arrow
-        elif opcode == 'delete':
-            # If words are deleted, format as "'deleted_word' removed"
-            deleted_part = ' '.join(text.split()[i1:i2])
-            grammar_changes.append(f"'{deleted_part}' removed")
-        elif opcode == 'insert':
-            # If words are inserted, format as "'inserted_word' added"
-            inserted_part = ' '.join(corrected_grammar.split()[j1:j2])
-            grammar_changes.append(f"'{inserted_part}' added")
-
-    # --- 2. Punctuation Fixes and 3. Sentence Correctness Feedback ---
-    # LanguageTool checks the original text for various issues including punctuation.
-    matches = tool.check(text)
-    
-    punctuation_issues = []
-    sentence_correctness_feedback = []
-    
-    for m in matches:
-        # Check if the rule ID (from LanguageTool) contains "PUNCTUATION" to categorize it.
-        if 'PUNCTUATION' in m.ruleId.upper():
-            punctuation_issues.append(m.message)
-        else:
-            # All other issues are considered general sentence correctness feedback.
-            sentence_correctness_feedback.append(m.message)
-
-    # --- 4. Tone Detection and Suggestion ---
-    # Classify the tone of the original text using the fine-tuned emotion classifier.
-    detected_tone = models.classify_tone(text)
-    
-    tone_suggestion_text = ""
-    # Provide a simple tone suggestion based on the detected tone.
-    # This logic can be expanded for more sophisticated suggestions based on context or user goals.
-    if detected_tone in ["neutral", "joy", "sadness", "anger", "fear", "disgust", "surprise"]:
-        # For simplicity, we'll try to make neutral/joy more formal, and other strong emotions more neutral/calm.
-        if detected_tone in ["neutral", "joy"]:
-            tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "formal"))
-        else: # For emotions like anger, sadness, fear, etc., suggest a more neutral/calm tone
-            tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "neutral and calm"))
-    else:
-        # If no specific suggestion, indicate that the detected tone is generally fine.
-        tone_suggestion_text = f"The detected tone '{detected_tone}' seems appropriate for general communication."
-
-
-    # --- 5. Active/Passive Voice Detection and Suggestion ---
-    doc = nlp(text) # Process the text with spaCy for linguistic analysis
-    voice_detected = "active"
-    voice_suggestion = "None \u2014 active voice is fine here." # Using Unicode em dash for better readability
-
-    # Iterate through tokens to find passive auxiliary verbs (e.g., "is", "was", "been" when followed by a past participle).
-    # A simple heuristic: if any token's dependency is 'auxpass', it's likely part of a passive construction.
-    for token in doc:
-        if token.dep_ == "auxpass":
-            voice_detected = "passive"
-            # If passive voice is detected, ask FLAN-T5 to rewrite it in active voice.
-            better_voice_prompt = prompts.active_voice_prompt(text)
-            voice_suggestion = models.run_flan_prompt(better_voice_prompt)
-            break # Exit loop once passive voice is detected, no need to check further
-
-    # --- 6. Inclusive Pronoun Suggestion ---
-    # Use FLAN-T5 with a specific prompt to suggest more inclusive language.
-    inclusive_pronouns_suggestion = models.run_flan_prompt(prompts.pronoun_friendly_prompt(text))
-
-    # --- Construct the final response matching the example output structure ---
-    return {
-        "grammar": {
-            "corrected": corrected_grammar,
-            "changes": grammar_changes
-        },
-        "punctuation": {
-            "issues": punctuation_issues,
-            "suggestions": [] # The grammar correction and diffs implicitly handle suggestions here
-        },
-        "sentence_correctness": sentence_correctness_feedback,
-        "tone_analysis": {
-            "detected": detected_tone,
-            "suggestion": tone_suggestion_text
-        },
-        "voice": {
-            "detected": voice_detected,
-            "suggestion": voice_suggestion
-        },
-        "inclusive_pronouns": inclusive_pronouns_suggestion
-    }

app/routers/conciseness.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models, prompts
+from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class ConcisenessInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /conciseness_check endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/conciseness_check", dependencies=[Depends(verify_api_key)])
+def conciseness_check(payload: ConcisenessInput):
+    """
+    Provides suggestions for making text more concise.
+
+    Args:
+        payload (ConcisenessInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing the concise version of the text.
+    """
+    text = payload.text
+    
+    try:
+        concise_text = models.run_flan_prompt(prompts.conciseness_prompt(text))
+        
+        return {
+            "concise_version": concise_text
+        }
+    except Exception as e:
+        logger.error(f"Error in conciseness_check: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during conciseness checking: {e}"
+        )

app/routers/grammar.py

@@ -0,0 +1,61 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models
+from app.core.security import verify_api_key
+import difflib
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class GrammarInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /grammar_check endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/grammar_check", dependencies=[Depends(verify_api_key)])
+def grammar_check(payload: GrammarInput):
+    """
+    Corrects the grammar of the provided text and shows changes.
+
+    Args:
+        payload (GrammarInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing the corrected text and a list of changes.
+    """
+    original_text = payload.text
+    
+    try:
+        corrected_text = models.run_grammar_correction(original_text)
+        
+        grammar_changes = []
+        s = difflib.SequenceMatcher(None, original_text.split(), corrected_text.split())
+        
+        for opcode, i1, i2, j1, j2 in s.get_opcodes():
+            if opcode == 'replace':
+                original_part = ' '.join(original_text.split()[i1:i2])
+                corrected_part = ' '.join(corrected_text.split()[j1:j2])
+                grammar_changes.append(f"'{original_part}' \u2192 '{corrected_part}'")
+            elif opcode == 'delete':
+                deleted_part = ' '.join(original_text.split()[i1:i2])
+                grammar_changes.append(f"'{deleted_part}' removed")
+            elif opcode == 'insert':
+                inserted_part = ' '.join(corrected_text.split()[j1:j2])
+                grammar_changes.append(f"'{inserted_part}' added")
+
+        return {
+            "grammar": {
+                "corrected": corrected_text,
+                "changes": grammar_changes
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in grammar_check: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during grammar checking: {e}"
+        )

app/routers/inclusive_language.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models, prompts
+from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class InclusiveLanguageInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /inclusive_language endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/inclusive_language", dependencies=[Depends(verify_api_key)])
+def inclusive_language_check(payload: InclusiveLanguageInput):
+    """
+    Provides suggestions for rewriting text using inclusive language.
+
+    Args:
+        payload (InclusiveLanguageInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing the rewritten text with inclusive language.
+    """
+    text = payload.text
+    
+    try:
+        inclusive_text = models.run_flan_prompt(prompts.pronoun_friendly_prompt(text))
+        
+        return {
+            "inclusive_pronouns": inclusive_text
+        }
+    except Exception as e:
+        logger.error(f"Error in inclusive_language_check: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during inclusive language check: {e}"
+        )

app/routers/paraphrase.py

@@ -1,12 +1,14 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
 from pydantic import BaseModel
 from app import models, prompts
 from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
 
-# Create an APIRouter instance. This will handle routes specific to paraphrasing.
 router = APIRouter()
 
-class Input(BaseModel):
+class ParaphraseInput(BaseModel): # Renamed Input to ParaphraseInput for clarity
     """
     Pydantic BaseModel for validating the input request body for the /paraphrase endpoint.
     It expects a single field: 'text' (string).
@@ -14,17 +16,24 @@ class Input(BaseModel):
     text: str
 
 @router.post("/paraphrase", dependencies=[Depends(verify_api_key)])
-def paraphrase(input: Input):
+def paraphrase(payload: ParaphraseInput): # Renamed input to payload for consistency
     """
-    Endpoint to paraphrase the given text.
+    Paraphrases the provided 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.
+        payload (ParaphraseInput): The request body containing the text to be paraphrased.
 
     Returns:
-        dict: A dictionary containing the paraphrased result.
+        dict: A dictionary containing the paraphrased text.
     """
-    # 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}
+    text = payload.text
+    
+    try:
+        paraphrased_text = models.run_flan_prompt(prompts.paraphrase_prompt(text))
+        return {"result": paraphrased_text}
+    except Exception as e:
+        logger.error(f"Error in paraphrase: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during paraphrasing: {e}"
+        )

app/routers/punctuation.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app.core.security import verify_api_key
+import language_tool_python
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Initialize LanguageTool. This will be the same instance as used for punctuation.
+# Ensure Java is installed in your environment.
+try:
+    tool = language_tool_python.LanguageTool('en-US')
+except Exception as e:
+    logger.error(f"Failed to initialize LanguageTool: {e}", exc_info=True)
+    # If LanguageTool cannot be initialized, raise an error or handle gracefully
+    # For an MVP, we might let the app start but fail on requests that use it.
+    # A more robust solution might mark the endpoint as unavailable.
+    tool = None # Set to None if initialization fails
+
+class PunctuationInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /punctuation_check endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/punctuation_check", dependencies=[Depends(verify_api_key)])
+def punctuation_check(payload: PunctuationInput):
+    """
+    Checks the provided text for punctuation errors.
+
+    Args:
+        payload (PunctuationInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing a list of punctuation issues.
+    """
+    if tool is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Punctuation check service is not available (LanguageTool failed to initialize)."
+        )
+
+    text = payload.text
+    
+    try:
+        matches = tool.check(text)
+        
+        punctuation_issues = []
+        for m in matches:
+            if 'PUNCTUATION' in m.ruleId.upper():
+                punctuation_issues.append(m.message)
+                
+        return {
+            "punctuation": {
+                "issues": punctuation_issues,
+                "suggestions": [] # Suggestions might be handled by overall grammar correction
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in punctuation_check: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during punctuation checking: {e}"
+        )

app/routers/readability.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app.core.security import verify_api_key
+import textstat # Import the textstat library
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class ReadabilityInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /readability_score endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/readability_score", dependencies=[Depends(verify_api_key)])
+def readability_score(payload: ReadabilityInput):
+    """
+    Calculates various readability scores for the provided text.
+
+    Args:
+        payload (ReadabilityInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing various readability scores.
+    """
+    text = payload.text
+    
+    try:
+        # Calculate different readability scores using textstat
+        flesch_reading_ease = textstat.flesch_reading_ease(text)
+        flesch_kincaid_grade = textstat.flesch_kincaid_grade(text)
+        gunning_fog = textstat.gunning_fog(text)
+        smog_index = textstat.smog_index(text)
+        coleman_liau_index = textstat.coleman_liau_index(text)
+        automated_readability_index = textstat.automated_readability_index(text)
+        
+        return {
+            "readability_scores": {
+                "flesch_reading_ease": flesch_reading_ease,
+                "flesch_kincaid_grade": flesch_kincaid_grade,
+                "gunning_fog_index": gunning_fog,
+                "smog_index": smog_index,
+                "coleman_liau_index": coleman_liau_index,
+                "automated_readability_index": automated_readability_index
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in readability_score: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during readability score calculation: {e}"
+        )

app/routers/sentence_correctness.py

@@ -0,0 +1,62 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app.core.security import verify_api_key
+import language_tool_python
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Initialize LanguageTool. This will be the same instance as used for punctuation.
+# Ensure Java is installed in your environment.
+try:
+    tool = language_tool_python.LanguageTool('en-US')
+except Exception as e:
+    logger.error(f"Failed to initialize LanguageTool for sentence correctness: {e}", exc_info=True)
+    tool = None
+
+class SentenceCorrectnessInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /sentence_correctness endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/sentence_correctness", dependencies=[Depends(verify_api_key)])
+def sentence_correctness_check(payload: SentenceCorrectnessInput):
+    """
+    Provides feedback on sentence-level correctness (e.g., fragments, subject-verb agreement).
+
+    Args:
+        payload (SentenceCorrectnessInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing a list of sentence correctness feedback.
+    """
+    if tool is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Sentence correctness service is not available (LanguageTool failed to initialize)."
+        )
+
+    text = payload.text
+    
+    try:
+        matches = tool.check(text)
+        
+        sentence_correctness_feedback = []
+        for m in matches:
+            # Exclude punctuation issues, as they are handled in a separate endpoint
+            if 'PUNCTUATION' not in m.ruleId.upper():
+                sentence_correctness_feedback.append(m.message)
+                
+        return {
+            "sentence_correctness": sentence_correctness_feedback
+        }
+    except Exception as e:
+        logger.error(f"Error in sentence_correctness_check: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during sentence correctness checking: {e}"
+        )

app/routers/summarize.py

@@ -1,12 +1,14 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
 from pydantic import BaseModel
 from app import models, prompts
 from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
 
-# Create an APIRouter instance. This will handle routes specific to summarization.
 router = APIRouter()
 
-class Input(BaseModel):
+class SummarizeInput(BaseModel): # Renamed Input to SummarizeInput for clarity
     """
     Pydantic BaseModel for validating the input request body for the /summarize endpoint.
     It expects a single field: 'text' (string).
@@ -14,17 +16,24 @@ class Input(BaseModel):
     text: str
 
 @router.post("/summarize", dependencies=[Depends(verify_api_key)])
-def summarize(input: Input):
+def summarize(payload: SummarizeInput): # Renamed input to payload for consistency
     """
-    Endpoint to summarize the given text.
+    Summarizes the provided 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.
+        payload (SummarizeInput): The request body containing the text to be summarized.
 
     Returns:
-        dict: A dictionary containing the summarized result.
+        dict: A dictionary containing the summarized text.
     """
-    # 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}
+    text = payload.text
+    
+    try:
+        summarized_text = models.run_flan_prompt(prompts.summarize_prompt(text))
+        return {"result": summarized_text}
+    except Exception as e:
+        logger.error(f"Error in summarize: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during summarization: {e}"
+        )

app/routers/tone.py

@@ -0,0 +1,56 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models, prompts
+from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class ToneInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /tone_analysis endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/tone_analysis", dependencies=[Depends(verify_api_key)])
+def tone_analysis(payload: ToneInput):
+    """
+    Analyzes the tone of the provided text and suggests improvements.
+
+    Args:
+        payload (ToneInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing the detected tone and a suggestion.
+    """
+    text = payload.text
+    
+    try:
+        detected_tone = models.classify_tone(text)
+        
+        tone_suggestion_text = ""
+        # Provide a simple tone suggestion based on the detected tone.
+        # This logic can be expanded for more sophisticated suggestions based on context or user goals.
+        if detected_tone in ["neutral", "joy", "sadness", "anger", "fear", "disgust", "surprise"]:
+            if detected_tone in ["neutral", "joy"]:
+                tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "formal"))
+            else: # For emotions like anger, sadness, fear, etc., suggest a more neutral/calm tone
+                tone_suggestion_text = models.run_flan_prompt(prompts.tone_prompt(text, "neutral and calm"))
+        else:
+            tone_suggestion_text = f"The detected tone '{detected_tone}' seems appropriate for general communication."
+
+        return {
+            "tone_analysis": {
+                "detected": detected_tone,
+                "suggestion": tone_suggestion_text
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in tone_analysis: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during tone analysis: {e}"
+        )

app/routers/translate.py

@@ -1,9 +1,11 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
 from pydantic import BaseModel
 from app import models
 from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
 
-# Create an APIRouter instance. This will handle routes specific to translation.
 router = APIRouter()
 
 class TranslateInput(BaseModel):
@@ -15,17 +17,25 @@ class TranslateInput(BaseModel):
     target_lang: str
 
 @router.post("/translate", dependencies=[Depends(verify_api_key)])
-def translate(input: TranslateInput):
+def translate(payload: TranslateInput): # Renamed input to payload for consistency
     """
-    Endpoint to translate the given text to a target language.
+    Translates the provided 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.
+        payload (TranslateInput): The request body containing the text and target language.
 
     Returns:
-        dict: A dictionary containing the translated result.
+        dict: A dictionary containing the translated text.
     """
-    # Call the translation model with the text and target language.
-    translated_text = models.run_translation(input.text, input.target_lang)
-    return {"result": translated_text}
+    text = payload.text
+    target_lang = payload.target_lang
+    
+    try:
+        translated_text = models.run_translation(text, target_lang)
+        return {"result": translated_text}
+    except Exception as e:
+        logger.error(f"Error in translate: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during translation: {e}"
+        )

app/routers/vocabulary.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models, prompts
+from app.core.security import verify_api_key
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class VocabularyInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /vocabulary_suggestions endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/vocabulary_suggestions", dependencies=[Depends(verify_api_key)])
+def vocabulary_suggestions(payload: VocabularyInput):
+    """
+    Provides suggestions for vocabulary improvement (e.g., stronger synonyms).
+
+    Args:
+        payload (VocabularyInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing vocabulary suggestions.
+    """
+    text = payload.text
+    
+    try:
+        suggestions_raw = models.run_flan_prompt(prompts.vocabulary_prompt(text))
+        
+        return {
+            "vocabulary_suggestions": suggestions_raw
+        }
+    except Exception as e:
+        logger.error(f"Error in vocabulary_suggestions: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during vocabulary suggestion: {e}"
+        )

app/routers/voice.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, Depends, HTTPException, status # Import HTTPException and status
+from pydantic import BaseModel
+from app import models, prompts
+from app.core.security import verify_api_key
+import spacy
+import logging # Import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Load the spaCy English language model.
+try:
+    nlp = spacy.load("en_core_web_sm")
+except OSError as e:
+    logger.error(f"SpaCy model 'en_core_web_sm' not found. Please run: python -m spacy download en_core_web_sm. Error: {e}", exc_info=True)
+    nlp = None # Set to None if initialization fails
+    # Re-raising here to prevent server startup if critical dependency is missing
+    raise RuntimeError("SpaCy model 'en_core_web_sm' not loaded. Please install it.")
+
+
+class VoiceInput(BaseModel):
+    """
+    Pydantic BaseModel for validating the input request body for the /voice_analysis endpoint.
+    It expects a single field: 'text' (string).
+    """
+    text: str
+
+@router.post("/voice_analysis", dependencies=[Depends(verify_api_key)])
+def voice_analysis(payload: VoiceInput):
+    """
+    Detects active/passive voice and suggests improvements.
+
+    Args:
+        payload (VoiceInput): The request body containing the text to be analyzed.
+
+    Returns:
+        dict: A dictionary containing the detected voice and a suggestion.
+    """
+    if nlp is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Voice analysis service is not available (SpaCy model failed to load)."
+        )
+
+    text = payload.text
+    
+    try:
+        doc = nlp(text)
+        
+        voice_detected = "active"
+        voice_suggestion = "None \u2014 active voice is fine here."
+    
+        for token in doc:
+            if token.dep_ == "auxpass":
+                voice_detected = "passive"
+                better_voice_prompt = prompts.active_voice_prompt(text)
+                voice_suggestion = models.run_flan_prompt(better_voice_prompt)
+                break
+    
+        return {
+            "voice": {
+                "detected": voice_detected,
+                "suggestion": voice_suggestion
+            }
+        }
+    except Exception as e:
+        logger.error(f"Error in voice_analysis: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"An error occurred during voice analysis: {e}"
+        )

requirements.txt

@@ -8,3 +8,4 @@ spacy
 nltk
 language-tool-python
 scikit-learn
+textstat