Upload 4 files

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,217 @@
+import os
+import logging
+import sys
+import argparse
+from fastapi import FastAPI, File, Form, UploadFile, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+import pandas as pd
+import tempfile
+import shutil
+from models import Grammar, Error
+from grammar_checker import (
+    check_grammar,
+    check_grammar_from_file,
+    check_grammar_qa,
+    display_results,
+    DEFAULT_PROPER_NOUNS,
+)
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Grammar Checker API",
+    description="API for checking grammar in text, files, and quiz questions",
+    docs_url="/",
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Define allowed file extensions
+ALLOWED_EXTENSIONS = {".txt", ".docx", ".xlsx"}
+
+
+class GrammarCheckResponse(BaseModel):
+    output_file: str
+    message: str
+    records: List[Dict[str, Any]] = []
+
+
+@app.post("/check-grammar-quiz/", response_model=GrammarCheckResponse)
+async def check_grammar(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    limit: Optional[int] = None,
+):
+    """
+    Process an Excel file with questions and answers, check grammar, and return the corrected data.
+
+    Args:
+        file: The input Excel file
+        limit: Limit the number of records to process. If None, process all records.
+
+    Returns:
+        JSON response with the path to the output file and processed records
+    """
+    # Create temp directory to store files
+    temp_dir = tempfile.mkdtemp()
+    input_path = os.path.join(temp_dir, file.filename)
+    output_filename = f"corrected_{file.filename}"
+    output_path = os.path.join(temp_dir, output_filename)
+
+    # Save uploaded file
+    try:
+        with open(input_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error saving file: {str(e)}")
+
+    # Process the file
+    try:
+        result_file, processed_records = process_grammar_check(input_path, output_path, limit)
+        background_tasks.add_task(cleanup_temp_files, temp_dir)
+        return GrammarCheckResponse(
+            output_file=result_file, 
+            message="Grammar check completed successfully",
+            records=processed_records
+        )
+    except Exception as e:
+        background_tasks.add_task(cleanup_temp_files, temp_dir)
+        raise HTTPException(status_code=500, detail=f"Error processing file: {str(e)}")
+
+
+def cleanup_temp_files(temp_dir: str):
+    """Clean up temporary files"""
+    shutil.rmtree(temp_dir)
+
+
+def process_grammar_check(input_file, output_file, limit=None):
+    """
+    Process an Excel file with questions and answers, check grammar, and save the corrected data.
+
+    Args:
+        input_file (str): Path to the input Excel file
+        output_file (str): Path to save the output Excel file
+        limit (int, optional): Limit the number of records to process. If None, process all records.
+
+    Returns:
+        tuple: (Path to the output file, List of processed records)
+    """
+    # Read the input file
+    df = pd.read_excel(input_file, sheet_name="Sheet1")
+    records = df.to_dict(orient="records")
+
+    # Process the records
+    data_processed = []
+    for i, record in enumerate(records):
+        if limit is not None and i >= limit:
+            break
+
+        dict_result = check_grammar_qa(record)
+        temp_dict = record.copy()
+        temp_dict["Question"] = dict_result["output"]["Question"]
+        temp_dict["Answer Option A"] = dict_result["output"].get(
+            "Answer Option A", None
+        )
+        temp_dict["Answer Option B"] = dict_result["output"].get(
+            "Answer Option B", None
+        )
+        temp_dict["Answer Option C"] = dict_result["output"].get(
+            "Answer Option C", None
+        )
+        temp_dict["Answer Option D"] = dict_result["output"].get(
+            "Answer Option D", None
+        )
+        temp_dict["wrong_locations"] = dict_result["wrong_locations"]
+
+        data_processed.append(temp_dict)
+
+    # Create a DataFrame from the processed data and write to Excel
+    output_df = pd.DataFrame(data_processed)
+    output_df.to_excel(output_file, index=False)
+
+    return output_file, data_processed
+
+
+def allowed_file(filename: str) -> bool:
+    """
+    Check if the uploaded file has an allowed extension.
+
+    Args:
+        filename: The name of the uploaded file
+
+    Returns:
+        True if the file extension is allowed, False otherwise
+    """
+    return os.path.splitext(filename)[1].lower() in ALLOWED_EXTENSIONS
+
+
+class TextRequest(BaseModel):
+    text: str
+    proper_nouns: Optional[str] = DEFAULT_PROPER_NOUNS
+
+
+@app.post("/check-text")
+async def check_text(body: TextRequest):
+    """Process text input and check grammar."""
+    try:
+        if not body.text:
+            raise HTTPException(status_code=400, detail="No text provided")
+
+        # Check grammar using LangChain
+        result = check_grammar(body.text, body.proper_nouns)
+
+        # Convert Pydantic model to dict for JSON response
+        return result.dict()
+
+    except Exception as e:
+        logging.error(f"Error processing text: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/check-file")
+async def check_file(
+    file: UploadFile, proper_nouns: Optional[str] = Form(DEFAULT_PROPER_NOUNS)
+):
+    """Process file upload and check grammar."""
+    try:
+        # Check if a valid file was uploaded
+        if file.filename == "":
+            raise HTTPException(status_code=400, detail="No file selected")
+
+        # Check if the file has an allowed extension
+        if not allowed_file(file.filename):
+            raise HTTPException(
+                status_code=400,
+                detail=f"File type not supported. Allowed types: {', '.join(ALLOWED_EXTENSIONS)}",
+            )
+
+        # Process the file
+        file_content = await file.read()
+        result = check_grammar_from_file(file_content, file.filename, proper_nouns)
+
+        # Convert Pydantic model to dict for JSON response
+        return result.dict()
+
+    except Exception as e:
+        logging.error(f"Error processing file: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8080)

grammar_checker.py

@@ -0,0 +1,555 @@
+import os
+from loguru import logger
+import json
+import io
+import tempfile
+from typing import List, Dict, Any, Annotated, Optional
+from langchain_openai import AzureChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from models import Grammar, Error
+import docx
+from rich.console import Console
+from rich.table import Table
+from rich.box import ROUNDED
+import re
+import pandas as pd
+
+# Configure logging
+logger.add("grammar_checker.log", rotation="500 MB", level="DEBUG")
+
+# Create console for rich output
+console = Console()
+
+# Get Azure OpenAI credentials from environment variables
+AZURE_OPENAI_API_KEY = os.environ.get("AZURE_OPENAI_API_KEY")
+AZURE_OPENAI_ENDPOINT = os.environ.get("AZURE_OPENAI_ENDPOINT")
+AZURE_OPENAI_DEPLOYMENT_NAME = os.environ.get("AZURE_OPENAI_DEPLOYMENT")
+AZURE_OPENAI_API_VERSION = os.environ.get("API_VERSION")
+llm = AzureChatOpenAI(
+    temperature=0,
+    api_key=AZURE_OPENAI_API_KEY,
+    azure_endpoint=AZURE_OPENAI_ENDPOINT,
+    azure_deployment=AZURE_OPENAI_DEPLOYMENT_NAME,
+    api_version=AZURE_OPENAI_API_VERSION,
+    model="gpt-4o",
+)
+# Constants for text splitting
+CHUNK_SIZE = 1000  # Approximate characters per page
+CHUNK_OVERLAP = 250  # Overlap between chunks to maintain context
+
+# Common tech terms and proper nouns that should not be flagged as errors
+DEFAULT_PROPER_NOUNS = """
+API, APIs, HTML, CSS, JavaScript, TypeScript, Python, Java, C++, SQL, NoSQL, 
+MongoDB, PostgreSQL, MySQL, Redis, Docker, Kubernetes, AWS, Azure, GCP, 
+HTTP, HTTPS, REST, GraphQL, JSON, XML, YAML, React, Angular, Vue, Node.js, 
+Express, Flask, Django, Spring, TensorFlow, PyTorch, Scikit-learn, npm, pip, 
+GitHub, GitLab, Bitbucket, Jira, Confluence, Slack, OAuth, JWT, SSL, TLS
+"""
+
+from typing import TypedDict, Dict
+
+
+def check_grammar_question(data: Dict[str, Any]) -> Dict[str, str]:
+    """
+    Check grammar for a question and return corrected text.
+    """
+    system_message = """
+    You are a spellchecker for a question and answer pair. Related to IT and programming.
+    You will be given a question and answer pair.
+    You will need to check the grammar of the question and answer pair.
+    You will need to return the corrected question and answer pair in a dictionary. If any of the fields are not errors, you should return the original value.
+
+    Output should be a dictionary with same keys as the input dictionary.
+    """
+    input_message = """
+    Here are input dictionary:
+    {data}
+    """
+    prompt = ChatPromptTemplate.from_messages(
+        [("system", system_message), ("user", input_message)]
+    )
+
+    class GrammarResult(TypedDict):
+        output: Annotated[
+            Dict[str, str], ..., "A dictionary with same keys as the input dictionary."
+        ]
+        wrong_locations: Annotated[Optional[str], ..., "point out errors briefly. Leave blank if there are no errors."]
+
+    chain = prompt | llm.with_structured_output(GrammarResult)
+    result = chain.invoke({"data": data})
+    return result
+
+
+def check_grammar_qa(
+    qa_dict: Dict[str, Any], proper_nouns: str = DEFAULT_PROPER_NOUNS
+) -> Dict[str, str]:
+    """
+    Check grammar for a QA dictionary and return corrected text.
+
+    Args:
+        qa_dict: Dictionary containing question and answer options
+        proper_nouns: A string of proper nouns to preserve
+
+    Returns:
+        Dictionary with corrected text for each field
+    """
+    corrected_dict = {}
+    
+    # Only process the Question and Answer Options A-D
+    if "Question" in qa_dict and not pd.isna(qa_dict["Question"]):
+        corrected_dict["Question"] = qa_dict["Question"]
+    
+    # Process answer options
+    for option in ["Answer Option A", "Answer Option B", "Answer Option C", "Answer Option D"]:
+        if option in qa_dict and not pd.isna(qa_dict[option]):
+            corrected_dict[option] = qa_dict[option]
+
+    return check_grammar_question(corrected_dict)
+
+
+def extract_text_from_docx(file_content: bytes) -> str:
+    """
+    Extract text from a .docx file.
+
+    Args:
+        file_content: The bytes content of the .docx file
+
+    Returns:
+        The extracted text as a string
+    """
+    try:
+        # Create a temporary file to save the content
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as temp_file:
+            temp_file.write(file_content)
+            temp_file_path = temp_file.name
+
+        # Open the temporary docx file and extract text
+        doc = docx.Document(temp_file_path)
+        full_text = []
+        for para in doc.paragraphs:
+            full_text.append(para.text)
+
+        # Clean up the temporary file
+        os.unlink(temp_file_path)
+
+        return "\n".join(full_text)
+    except Exception as e:
+        logger.error(f"Error extracting text from docx: {str(e)}")
+        raise Exception(f"Failed to extract text from docx: {str(e)}")
+
+
+def extract_text_from_file(file_content: bytes, file_extension: str) -> str:
+    """
+    Extract text from a file based on its extension.
+
+    Args:
+        file_content: The bytes content of the file
+        file_extension: The file extension (.txt, .docx, etc.)
+
+    Returns:
+        The extracted text as a string
+    """
+    if file_extension.lower() == ".txt":
+        # For txt files, simply decode the content
+        return file_content.decode("utf-8", errors="replace")
+    elif file_extension.lower() == ".docx":
+        # For docx files, use the docx extraction function
+        return extract_text_from_docx(file_content)
+    else:
+        raise ValueError(f"Unsupported file extension: {file_extension}")
+
+
+class SentenceBasedTextSplitter(RecursiveCharacterTextSplitter):
+    def __init__(self, chunk_size: int, chunk_overlap: int = 0):
+        super().__init__(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+        self.chunk_size = chunk_size
+
+    def split_text(self, text: str):
+        sentence_endings = re.compile(r"(?<=[.!?])\s+")
+        sentences = sentence_endings.split(text)
+
+        chunks = []
+        current_chunk = ""
+
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= self.chunk_size:
+                current_chunk += sentence + " "
+            else:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                current_chunk = sentence + " "
+        # Ensure the last chunk includes the remaining sentence if it exists
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+
+        return chunks
+
+
+def split_text(text: str) -> List[str]:
+    """
+    Split text into chunks of appropriate size for processing.
+
+    Args:
+        text: The full text to split
+
+    Returns:
+        A list of text chunks
+    """
+    # splitter = RecursiveCharacterTextSplitter(
+    #     chunk_size=CHUNK_SIZE,
+    #     chunk_overlap=CHUNK_OVERLAP,
+    #     length_function=len,
+    #     is_separator_regex=False,
+    # )
+    splitter = SentenceBasedTextSplitter(
+        chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP
+    )
+    chunks = splitter.split_text(text)
+    logger.debug(f"Split text into {len(chunks)} chunks")
+    return chunks
+
+
+def create_grammar_prompt(text: str, proper_nouns: str = DEFAULT_PROPER_NOUNS) -> str:
+    """
+    Create a grammar checking prompt for the given text with proper nouns.
+
+    Args:
+        text: The text to check for grammar issues
+        proper_nouns: A string of proper nouns to preserve
+
+    Returns:
+        A formatted prompt string
+    """
+    return f"""
+    Rewrite the provided text to be clear and grammatically correct while preserving technical accuracy. Focus on:
+
+    1. Correcting spelling, punctuation, and grammar errors
+    2. Maintaining technical terminology and code snippets
+    3. Ensuring consistent tense, voice, and formatting
+    4. Clarifying function descriptions, parameters, and return values
+    5. Proper use of capitalization, acronyms, and abbreviations
+    6. Improving clarity and conciseness
+    7. Respect markdown and code formatting such as underscores, asterisks, backticks, code blocks, and links
+    8. Ensure proper nouns and acronyms are correctly spelled and capitalized
+    
+    Here's a list of proper nouns and technical terms you should preserve:
+    {proper_nouns}
+
+    Preserve code-specific formatting and syntax. Prioritize original text if unsure about technical terms.
+
+    Make sure when you show the before vs after text, include a larger phrase or sentence for context.
+
+    In the response:
+    - For 'spelling', 'punctuation', and 'grammar' keys: Provide only changed items with original text, corrected text, and explanation.
+    
+    Ensure that the original text is actually referenced from the given text below:
+
+    {text}
+    """
+
+
+def process_api_response(content: str) -> Dict[str, List[Dict[str, str]]]:
+    """
+    Process the API response to extract the JSON result.
+
+    Args:
+        content: The API response content
+
+    Returns:
+        A dictionary with grammar error categories
+    """
+    # Try to find JSON pattern
+    json_start = content.find("{")
+    json_end = content.rfind("}") + 1
+
+    if json_start == -1 or json_end == 0:
+        logger.error(f"Could not find JSON in response: {content}")
+        raise ValueError("API response did not contain valid JSON")
+
+    json_str = content[json_start:json_end]
+    logger.debug(f"Extracted JSON: {json_str[:100]}...")
+
+    # Parse the JSON
+    try:
+        result = json.loads(json_str)
+    except json.JSONDecodeError as je:
+        logger.error(f"JSON decode error: {str(je)}")
+        logger.error(f"JSON string was: {json_str}")
+        # Create a default structure
+        result = {"spelling": [], "punctuation": [], "grammar": []}
+
+    return result
+
+
+def merge_grammar_results(
+    results: List[Dict[str, List[Dict[str, str]]]],
+) -> Dict[str, List[Dict[str, str]]]:
+    """
+    Merge multiple grammar check results into a single result.
+
+    Args:
+        results: A list of grammar check results
+
+    Returns:
+        A merged grammar check result
+    """
+    merged = {"spelling": [], "punctuation": [], "grammar": []}
+
+    for result in results:
+        for category in ["spelling", "punctuation", "grammar"]:
+            if category in result:
+                merged[category].extend(result[category])
+
+    return merged
+
+
+def validate_corrections(
+    result: Dict[str, List[Dict[str, str]]],
+) -> Dict[str, List[Dict[str, str]]]:
+    """
+    Validate grammar corrections to ensure they're meaningful.
+
+    Args:
+        result: The grammar check result
+
+    Returns:
+        Validated grammar check result
+    """
+    validated = {"spelling": [], "punctuation": [], "grammar": []}
+
+    for category in ["spelling", "punctuation", "grammar"]:
+        for error in result.get(category, []):
+            # Skip if before and after are the same
+            if error["before"] == error["after"]:
+                continue
+
+            # Skip if only whitespace changes
+            if error["before"].strip() == error["after"].strip():
+                continue
+
+            validated[category].append(error)
+
+    return validated
+
+
+def apply_corrections(original_text: str, errors: List[Error]) -> str:
+    """
+    Apply all grammar corrections to the original text.
+
+    Args:
+        original_text: The original text with errors
+        errors: List of Error objects with before/after corrections
+
+    Returns:
+        Fully corrected text
+    """
+    # Process individual errors one at a time
+    # Make a copy of the original text
+    corrected = original_text
+
+    # First, find the position of each error in the original text
+    error_positions = []
+    for error in errors:
+        pos = corrected.find(error.before)
+        if pos != -1:
+            error_positions.append((pos, error))
+
+    # Sort by position in descending order (to replace from end to start)
+    # This way, earlier replacements don't affect positions of later ones
+    error_positions.sort(key=lambda x: x[0], reverse=True)
+
+    # Apply each correction
+    for pos, error in error_positions:
+        corrected = corrected[:pos] + error.after + corrected[pos + len(error.before) :]
+
+    return corrected
+
+
+def check_grammar(text: str, proper_nouns: str = DEFAULT_PROPER_NOUNS) -> Grammar:
+    """
+    Check the grammar of the given text using LangChain and Azure OpenAI.
+
+    Args:
+        text: The text to check for grammar issues
+        proper_nouns: A string of proper nouns to preserve
+
+    Returns:
+        Grammar object containing categorized errors
+    """
+    try:
+        # Split text into chunks if it's too long
+        chunks = split_text(text)
+
+        # Initialize LangChain with Azure OpenAI
+
+        logger.debug(
+            f"Using Azure OpenAI with deployment: {AZURE_OPENAI_DEPLOYMENT_NAME}"
+        )
+
+        # Create system message for JSON format
+        system_message = """You are a spellchecker database that outputs grammar errors and corrected text in JSON.
+The JSON object must use the schema that has 'spelling', 'punctuation', and 'grammar' keys, each with a list of objects containing 'before', 'after', and 'explanation'.
+It is strictly imperative that you return as JSON. DO NOT return any other characters other than valid JSON as your response."""
+
+        # Create a prompt template and chain using the pipe syntax
+        prompt = ChatPromptTemplate.from_messages(
+            [("system", system_message), ("user", "{prompt}")]
+        )
+        chain = prompt | llm
+
+        # Process each chunk in a batch
+        logger.debug(f"Processing {len(chunks)} chunks in batch...")
+
+        if len(chunks) == 1:
+            # For single chunks, just use invoke directly
+            prompt_text = create_grammar_prompt(chunks[0], proper_nouns)
+            response = chain.invoke({"prompt": prompt_text})
+            content = response.content
+            logger.debug(f"Received single response from API: {content[:200]}...")
+            result = process_api_response(content)
+        else:
+            # For multiple chunks, use batch processing
+            prompt_batch = [
+                {"prompt": create_grammar_prompt(chunk, proper_nouns)}
+                for chunk in chunks
+            ]
+            responses = chain.batch(prompt_batch)
+            logger.debug(f"Received {len(responses)} batch responses from API")
+
+            # Process each response
+            results = []
+            for response in responses:
+                content = response.content
+                result = process_api_response(content)
+                results.append(result)
+
+            # Merge the results
+            result = merge_grammar_results(results)
+
+        # Validate corrections to ensure they're meaningful
+        validated_result = validate_corrections(result)
+
+        # Create Error objects for each category
+        spelling_errors = [Error(**err) for err in validated_result.get("spelling", [])]
+        punctuation_errors = [
+            Error(**err) for err in validated_result.get("punctuation", [])
+        ]
+        grammar_errors = [Error(**err) for err in validated_result.get("grammar", [])]
+
+        # Apply corrections to get fully corrected text
+        corrected_text = apply_corrections(
+            text, spelling_errors + punctuation_errors + grammar_errors
+        )
+
+        # Return a Grammar object
+        return Grammar(
+            spelling=spelling_errors,
+            punctuation=punctuation_errors,
+            grammar=grammar_errors,
+            file_path="",  # Will be updated for file uploads
+            corrected_text=corrected_text,  # Add the corrected text
+        )
+
+    except Exception as e:
+        logger.error(f"Error checking grammar: {str(e)}")
+        raise Exception(f"Failed to analyze text: {str(e)}")
+
+
+def check_grammar_from_file(
+    file_content: bytes, filename: str, proper_nouns: str = DEFAULT_PROPER_NOUNS
+) -> Grammar:
+    """
+    Check grammar from an uploaded file.
+
+    Args:
+        file_content: The bytes content of the file
+        filename: The name of the uploaded file
+        proper_nouns: A string of proper nouns to preserve
+
+    Returns:
+        Grammar object containing categorized errors
+    """
+    try:
+        _, file_extension = os.path.splitext(filename)
+        text = extract_text_from_file(file_content, file_extension)
+
+        # Check grammar on the extracted text
+        grammar_result = check_grammar(text, proper_nouns)
+
+        # Update the file path
+        grammar_result.file_path = filename
+
+        return grammar_result
+    except Exception as e:
+        logger.error(f"Error checking grammar from file: {str(e)}")
+        raise Exception(f"Failed to analyze file: {str(e)}")
+
+
+def display_results(response: Grammar, path: str = "", repo_link: str = "") -> int:
+    """
+    Display the grammar check results using Rich.
+
+    Args:
+        response: The Grammar object with check results
+        path: Path to the file that was checked
+        repo_link: Optional repository link (for GitHub URLs)
+
+    Returns:
+        Total number of errors found
+    """
+    # Replace local file path with GitHub URL if repo_link is provided
+    if repo_link and response.file_path:
+        # Use os.path.split to handle path separators correctly
+        parts = os.path.normpath(response.file_path).split(os.path.sep)
+        relative_path = os.path.basename(response.file_path)
+        path = f"{repo_link.rstrip('/')}/blob/main/{relative_path}"
+    elif path:
+        # Use the provided path
+        pass
+    elif response.file_path:
+        # Use the file path from the response
+        path = response.file_path
+    else:
+        # Default text
+        path = "Text input"
+
+    # Print the file path
+    console.print(f"\n[bold cyan]File: {path}[/bold cyan]")
+
+    total_errors = 0
+
+    # Display each error category
+    for category in ["spelling", "punctuation", "grammar"]:
+        table = Table(title=f"{category.capitalize()} Corrections", box=ROUNDED)
+        table.add_column("Original", justify="left", style="bold red")
+        table.add_column("Corrected", justify="left", style="bold green")
+        table.add_column("Explanation", justify="left", style="italic")
+
+        errors = getattr(response, category)
+        for error in errors:
+            if error.before != error.after:
+                table.add_row(error.before, error.after, error.explanation)
+                table.add_row("", "", "")  # Add an empty row for spacing
+                total_errors += 1
+
+        if errors:
+            console.print(table)
+        else:
+            no_errors_msg = f"No {category} errors found."
+            console.print(f"[blue]{no_errors_msg}[/blue]")
+
+    console.print(
+        f"[bold {'green' if total_errors == 0 else 'red'}]Total errors found: {total_errors}[/bold]"
+    )
+
+    # Display corrected text if available
+    if response.corrected_text:
+        console.print("\n[bold cyan]Fully Corrected Text:[/bold cyan]")
+        console.print(response.corrected_text)
+
+    # Write output to a file
+    with open("grammar_results.txt", "w") as f:
+        f.write(console.export_text())
+
+    return total_errors

models.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class Error(BaseModel):
+    """Model for individual grammar errors."""
+    before: str
+    after: str
+    explanation: str
+
+class Grammar(BaseModel):
+    """Model for grammar check results."""
+    spelling: List[Error]
+    punctuation: List[Error]
+    grammar: List[Error]
+    file_path: Optional[str] = None
+    corrected_text: Optional[str] = None