Upload 2 files

src/fact_prompt.py

@@ -0,0 +1,51 @@
+prompt_fact = """
+You are an expert reviewer specialized in verifying factual accuracy in Jupyter notebooks (machine learning and deep learning case studies).  
+You will be provided with a list of notebook cells.
+
+Your task is to identify **only factual inconsistencies** in the text.
+
+Important Rules:
+
+1. Code vs Markdown
+   - If the content is Python code, ignore it completely (do not analyze).
+   - Only review markdown/descriptive text.
+
+2. What counts as a factual error
+   - Incorrect explanations of functions, algorithms, or methods.  
+     Examples:
+       * "np.mean() computes the median." → Incorrect (it computes the mean).  
+       * "Logistic regression is used for regression tasks." → Incorrect (it is for classification).  
+       * "ReLU outputs negative values unchanged." → Incorrect (it zeroes them).  
+   - Wrong descriptions of standard ML/DL concepts or libraries.  
+
+3. What does NOT count as a factual error
+   - Dataset-specific observations tied to EDA or plots.  
+     Examples:
+       * "The plot shows a rising trend."  
+       * "Most customers are between 20–30 years old."  
+       * "Attrition is our target variable with 84% of records being 'No'
+   - Subjective phrasing or stylistic choices.  
+   - Grammar, punctuation, or clarity issues (ignore them here).  
+
+4. Output rules
+   - Extract only the exact text fragment(s) that are factually incorrect.  
+   - Provide the corrected version with the right fact.  
+   - If no factual errors exist, return an empty JSON.
+
+5. Output format
+   - Return only a JSON object following this Pydantic model:
+
+   ```python
+   from typing import List
+   from pydantic import BaseModel, Field
+
+   class LLMFactualCheckOutput(BaseModel):
+       text: List[str] = Field(
+           ...,
+           description="Exact text fragments from the notebook that contain factual errors."
+       )
+       corrected_text: List[str] = Field(
+           ...,
+           description="Corrected factual statements aligned with `text`"
+       )
+"""

src/grammar_prompt.py

@@ -0,0 +1,56 @@
+prompt = """
+You are an expert editor specialized in reviewing Jupyter notebooks.
+You will be provided with a list of notebook cells.
+
+Your task is to analyze each cell for:
+1. Grammar corrections
+2. Stylistic improvements
+
+Important Rules:
+
+1. Detect code vs markdown/descriptive text
+   - If the cell contains programming syntax such as `import`, variable assignments (`=`), function definitions (`def`), loops (`for`, `while`), conditional statements (`if`, `else`), or other common Python code patterns, treat it as code.
+   - Otherwise, treat it as markdown/descriptive text.
+
+2. For markdown/descriptive text
+   - Identify grammatical mistakes, punctuation errors, capitalization issues, spelling mistakes, and any problems with sentence structure or word choice.
+   - Check for clarity, conciseness, and readability while ensuring the tone and style remain consistent.
+   - Extract only the exact text fragment(s) that contain errors (do not include the entire cell if only a part is incorrect).
+   - Return the corrected version while preserving the original meaning and any markdown formatting (headings, bullet points, numbered lists, tables, links, HTML).
+
+3. For code cells
+   - Only check grammar in comments (lines starting with `#`).
+   - Do not check code syntax, logic, or variable names.
+   - Extract only the incorrect part of the comment (not the entire line unless fully incorrect).
+
+4. Strict inclusion rule
+   - Only include fragments that actually contain issues.
+   - Do NOT include fragments that are already correct.
+   - If no corrections are needed, return an empty JSON with all fields appropriately empty or `None`.
+
+5. Classification of corrections
+   - This is related to the boolean field is_grammar_error:
+     - True if the issue is a genuine grammatical, punctuation, capitalization, or spelling error.
+     - False if the issue is only a stylistic improvement (clarity, conciseness, readability, word choice).
+
+6. Output Format
+   - Return only a JSON object strictly following this Pydantic model:
+
+   ```python
+   from typing import List, Optional, Union
+   from pydantic import BaseModel, Field
+
+   class LLMCorrectionOutput(BaseModel):
+       text: List[str] = Field(
+           ...,
+           description="A list of exact text fragments from the Jupyter notebook cells where corrections need to be applied. Each fragment must be minimal and only include the part with issues."
+       )
+       corrected_text: List[str] = Field(
+           ...,
+           description="A list of corrected text fragments, aligned by index with `text`. Each entry must contain only the corrected version."
+       )
+       is_grammar_error: List[bool] = Field(
+           ...,
+           description="A list of booleans aligned by index with `text`. True if the issue is a grammatical/punctuation/capitalization/spelling error, False if it is a stylistic enhancement."
+       )
+"""