Upload 13 files

src/v2/.env

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=gl-U2FsdGVkX186Ze7PMRRd2oHk9V9gAmDv+vMuS3vneQ544WvS4bFhUA7Jfnj+/CYU
+OPENAI_API_BASE=https://aibe.mygreatlearning.com/openai/v1

src/v2/assets.py

@@ -0,0 +1,2 @@
+logo = "https://mma.prnewswire.com/media/1458111/Great_Learning_Logo.jpg?p=facebook"
+icon = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAMAAABF0y+mAAAAY1BMVEVHcEz////////////////////////////////////////////1+P3v9PuwyetRjdkAac/S3fEyftUNcdJsnN2wvuLd5/aDodhFY7oAJqQAGKJ2ickDM6hGiNe+yecSU7yerNm6H2eSAAAADHRSTlMANIK95v9f4h7TQ0I4MwE6AAAA+ElEQVR4AWSRBQKEMAwEscWlcrj+/5WX0uCDM5WIc+J6fgAEvuc6b8IIJ1H4UHGCB0l8uRQf0sNlYPJiJweR8ZqsykpYJAx2ZbufVELviJL3NS6000gJ9SNqMCbmaJ8ntKgaPIgodxiUFi3euI7Hi1b44Dk+iEqL5it9JzD5Ca1gKGqDZBk4+z+hfzB0PTGMYB5yHMhN0yV52dk86mVZ6ktGNqD5Cqi4pG9Tqe26VvY1LJ4tQq71WrO84nG5fMs69W2+yw5MdBZ+66d+GjciBxNeLVtITpSkBJPcm51vK7kFB/F/aMmEV1AQLseNL4HhS5qEEzXe7AAAqbAXH67DSm4AAAAASUVORK5CYII="

src/v2/colab_handler.py

@@ -0,0 +1,253 @@
+import re
+import json
+import os
+from pathlib import Path
+from typing import List, Dict, Any
+
+class ColabNotebookProcessor:
+    """Processes Jupyter notebooks to replace Google Colab specific code with local equivalents"""
+    
+    def __init__(self, notebook_dir: str = "/tmp/Notebook"):
+        self.notebook_dir = Path(notebook_dir)
+        self.dataset_files = self._get_available_datasets()
+        self.dataset_mapping = self._create_dataset_mapping()
+    
+    def _get_available_datasets(self) -> List[str]:
+        """Get list of available dataset files in the notebook directory"""
+        if not self.notebook_dir.exists():
+            return []
+        
+        dataset_extensions = {'.csv', '.xlsx', '.xls', '.json', '.txt', '.parquet'}
+        return [f.name for f in self.notebook_dir.iterdir() 
+                if f.suffix.lower() in dataset_extensions and f.is_file()]
+    
+    def _create_dataset_mapping(self) -> Dict[str, str]:
+        """Create mapping for common dataset references"""
+        mapping = {}
+        
+        # If we have datasets, create common mappings
+        for filename in self.dataset_files:
+            name_without_ext = Path(filename).stem
+            
+            # Direct mappings
+            mapping[filename] = filename
+            mapping[name_without_ext] = filename
+            mapping[filename.lower()] = filename
+            mapping[name_without_ext.lower()] = filename
+            
+            # Common patterns
+            if filename.lower().endswith('.csv'):
+                mapping['data.csv'] = filename
+                mapping['dataset.csv'] = filename
+                mapping['train.csv'] = filename
+                mapping['test.csv'] = filename
+        
+        return mapping
+    
+    def process_notebook(self, notebook_path: str) -> str:
+        """Process notebook and return path to modified notebook"""
+        with open(notebook_path, 'r', encoding='utf-8') as f:
+            notebook = json.load(f)
+        
+        # Process each cell
+        for cell in notebook.get('cells', []):
+            if cell.get('cell_type') == 'code':
+                cell['source'] = self._process_code_cell(cell.get('source', []))
+        
+        # Save modified notebook
+        modified_path = str(Path(notebook_path).parent / f"modified_{Path(notebook_path).name}")
+        with open(modified_path, 'w', encoding='utf-8') as f:
+            json.dump(notebook, f, indent=2)
+        
+        return modified_path
+    
+    def _process_code_cell(self, source_lines: List[str]) -> List[str]:
+        """Process individual code cell to replace Colab-specific code"""
+        if isinstance(source_lines, str):
+            source_lines = source_lines.splitlines(True)
+        
+        processed_lines = []
+        skip_next = False
+        
+        for i, line in enumerate(source_lines):
+            if skip_next:
+                skip_next = False
+                continue
+                
+            processed_line = self._process_line(line)
+            
+            # Handle multi-line Colab patterns
+            if self._is_colab_drive_mount(line):
+                # Skip the mount line and add a comment
+                processed_lines.append("# Google Drive mount replaced with local file access\n")
+                continue
+            elif self._is_colab_files_upload(line):
+                # Replace file upload with dataset selection
+                processed_lines.append(self._replace_file_upload(line))
+                continue
+            
+            processed_lines.append(processed_line)
+        
+        return processed_lines
+    
+    def _process_line(self, line: str) -> str:
+        """Process individual line for Colab replacements"""
+        original_line = line
+        
+        # Skip/comment out Colab-specific imports
+        if self._is_colab_import(line):
+            return f"# {line}" if not line.strip().startswith('#') else line
+        
+        # Replace Google Drive paths with local paths
+        line = self._replace_drive_paths(line)
+        
+        # Replace Colab file operations
+        line = self._replace_file_operations(line)
+        
+        # Replace uploaded file references
+        line = self._replace_uploaded_files(line)
+        
+        return line
+    
+    def _is_colab_import(self, line: str) -> bool:
+        """Check if line contains Colab-specific imports"""
+        colab_imports = [
+            'from google.colab import drive',
+            'from google.colab import files',
+            'from google.colab import auth',
+            'import google.colab'
+        ]
+        
+        line_stripped = line.strip()
+        return any(imp in line_stripped for imp in colab_imports)
+    
+    def _is_colab_drive_mount(self, line: str) -> bool:
+        """Check if line is a drive mount operation"""
+        return 'drive.mount(' in line or 'drive.mount (' in line
+    
+    def _is_colab_files_upload(self, line: str) -> bool:
+        """Check if line is a files upload operation"""
+        return 'files.upload(' in line or 'files.upload (' in line
+    
+    def _replace_drive_paths(self, line: str) -> str:
+        """Replace Google Drive paths with local paths"""
+        # Common drive path patterns
+        drive_patterns = [
+            (r'/content/drive/My Drive/', './'),
+            (r'/content/drive/MyDrive/', './'),
+            (r'/content/drive/', './'),
+            (r'/content/', './'),
+            (r'"/content/drive/[^"]*"', lambda m: self._find_dataset_match(m.group())),
+            (r"'/content/drive/[^']*'", lambda m: self._find_dataset_match(m.group())),
+        ]
+        
+        for pattern, replacement in drive_patterns:
+            if callable(replacement):
+                line = re.sub(pattern, replacement, line)
+            else:
+                line = re.sub(pattern, replacement, line)
+        
+        return line
+    
+    def _replace_file_operations(self, line: str) -> str:
+        """Replace file operations with local equivalents"""
+        # Replace common file reading patterns
+        if 'pd.read_csv(' in line:
+            line = self._replace_pandas_read(line, 'csv')
+        elif 'pd.read_excel(' in line:
+            line = self._replace_pandas_read(line, 'excel')
+        
+        return line
+    
+    def _replace_pandas_read(self, line: str, file_type: str) -> str:
+        """Replace pandas read operations with local file paths"""
+        # Extract filename from the line if possible
+        pattern = r'["\']([^"\']+)["\']'
+        matches = re.findall(pattern, line)
+        
+        if matches:
+            original_path = matches[0]
+            # Try to find a matching local dataset
+            local_file = self._find_best_dataset_match(original_path, file_type)
+            if local_file:
+                line = line.replace(original_path, local_file)
+        
+        return line
+    
+    def _replace_uploaded_files(self, line: str) -> str:
+        """Replace references to uploaded files with local dataset files"""
+        # Pattern for uploaded file references
+        if 'uploaded[' in line and self.dataset_files:
+            # Replace with first available dataset
+            line = f"# Uploaded file replaced with local dataset: {self.dataset_files[0]}\n"
+            line += f"# Original: {line.strip()}\n"
+            line += f"# Use: '{self.dataset_files[0]}' instead\n"
+        
+        return line
+    
+    def _replace_file_upload(self, line: str) -> str:
+        """Replace file upload with comment about available datasets"""
+        comment = "# File upload replaced with local datasets\n"
+        if self.dataset_files:
+            comment += f"# Available datasets: {', '.join(self.dataset_files)}\n"
+        else:
+            comment += "# No datasets found in directory\n"
+        return comment
+    
+    def _find_dataset_match(self, quoted_path: str) -> str:
+        """Find best matching dataset for a quoted path"""
+        # Remove quotes
+        path = quoted_path.strip('\'"')
+        filename = os.path.basename(path)
+        
+        # Try direct match first
+        if filename in self.dataset_files:
+            return f'"{filename}"'
+        
+        # Try mapping
+        if filename in self.dataset_mapping:
+            return f'"{self.dataset_mapping[filename]}"'
+        
+        # Try partial matches
+        for dataset in self.dataset_files:
+            if filename.lower() in dataset.lower() or dataset.lower() in filename.lower():
+                return f'"{dataset}"'
+        
+        # Return first available dataset if any
+        if self.dataset_files:
+            return f'"{self.dataset_files[0]}"'
+        
+        return quoted_path  # Return original if no match found
+    
+    def _find_best_dataset_match(self, original_path: str, file_type: str) -> str:
+        """Find the best matching dataset file"""
+        filename = os.path.basename(original_path)
+        
+        # Filter by file type if specified
+        type_filtered = []
+        if file_type == 'csv':
+            type_filtered = [f for f in self.dataset_files if f.lower().endswith('.csv')]
+        elif file_type == 'excel':
+            type_filtered = [f for f in self.dataset_files if f.lower().endswith(('.xlsx', '.xls'))]
+        else:
+            type_filtered = self.dataset_files
+        
+        # Try exact match
+        if filename in type_filtered:
+            return filename
+        
+        # Try name without extension
+        name_without_ext = os.path.splitext(filename)[0]
+        for dataset in type_filtered:
+            if os.path.splitext(dataset)[0] == name_without_ext:
+                return dataset
+        
+        # Return first file of the right type
+        if type_filtered:
+            return type_filtered[0]
+        
+        # Return first available dataset
+        if self.dataset_files:
+            return self.dataset_files[0]
+        
+        return filename  # Return original if no datasets available

src/v2/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/v2/grammar_chain.py

@@ -0,0 +1,71 @@
+import os
+from notebook_parser import NotebookParser
+from grammar_prompt import prompt
+from fact_prompt import prompt_fact
+from langchain_core.runnables import RunnableLambda,RunnableParallel
+from langchain_openai import ChatOpenAI
+from output_schema import LLMCorrectionOutput,LLMFactualCheckOutput
+import pandas as pd
+
+from dotenv import load_dotenv
+load_dotenv()
+
+def grammar_pipeline():
+
+    parse_notebook = RunnableLambda(lambda path: NotebookParser(notebook_path=path).extract(code=True, markdown=True))
+
+    prepare_message = RunnableLambda(
+        lambda cells: {
+            "role": "user",
+            "content": [{"type": "text", "text": prompt}] + [{"type": "text", "text": "The list of cells are : "}] + cells
+        },
+    )
+
+    llm = ChatOpenAI(model='gpt-4o-mini',temperature=0, api_key = os.getenv('OPENAI_API_KEY'), base_url = os.getenv('OPENAI_API_BASE'))
+
+    invoke_llm = RunnableLambda(
+    lambda message: llm.with_structured_output(LLMCorrectionOutput).invoke([message])
+    )
+
+    extract_suggestions = RunnableLambda(
+    lambda result: {'Is Grammar Error?':result.is_grammar_error,'Grammar_Text':result.text,'Grammar_Suggestions':result.corrected_text}
+    )
+
+    notebook_chain = (
+        parse_notebook
+        | prepare_message
+        | invoke_llm
+        | extract_suggestions
+    )
+
+    return notebook_chain
+
+def fact_pipeline():
+
+    parse_notebook = RunnableLambda(lambda path: NotebookParser(notebook_path=path).extract(code=True, markdown=True))
+
+    prepare_message = RunnableLambda(
+        lambda cells: {
+            "role": "user",
+            "content": [{"type": "text", "text": prompt_fact}] + [{"type": "text", "text": "The list of cells are : "}] + cells
+        },
+    )
+
+    llm = ChatOpenAI(model='gpt-4o-mini',temperature=0, api_key = os.getenv('OPENAI_API_KEY'), base_url = os.getenv('OPENAI_API_BASE'))
+
+    invoke_llm = RunnableLambda(
+    lambda message: llm.with_structured_output(LLMFactualCheckOutput).invoke([message])
+    )
+
+    extract_suggestions = RunnableLambda(
+    lambda result: {'Fact_Text':result.text,'Fact_Suggestions':result.corrected_text}
+    )
+
+    notebook_chain = (
+        parse_notebook
+        | prepare_message
+        | invoke_llm
+        | extract_suggestions
+    )
+
+    return notebook_chain

src/v2/grammar_exec.py

@@ -0,0 +1,21 @@
+from grammar_chain import grammar_pipeline,fact_pipeline
+from utilities import safe_concurrent_batch
+import pandas as pd
+import os
+
+def execute(path):
+
+    notebooks = [path+'//'+f for f in os.listdir(path) if f.endswith(".ipynb")]
+
+    grammar = safe_concurrent_batch(grammar_pipeline(),notebooks,max_workers=1)[0]
+
+    fact = safe_concurrent_batch(fact_pipeline(),notebooks,max_workers=1)[0]
+
+    if grammar["status"] == "success" and fact['status']=='success':
+        grammar_df = pd.DataFrame(grammar["output"])
+        fact_df = pd.DataFrame(fact["output"])
+        result = pd.concat([grammar_df,fact_df], axis=1)
+    else:
+        result = pd.DataFrame(columns=['Unable to Process'])
+
+    return result

src/v2/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."
+       )
+"""

src/v2/notebook.py

@@ -0,0 +1,404 @@
+import os,sys,shutil,subprocess,json,re,ast,tempfile,nbformat,logging,argparse
+import pandas as pd
+from pathlib import Path
+from colab_handler import ColabNotebookProcessor
+
+# -------- Logging --------
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
+# -------- Executor Class --------
+class NotebookExecutor:
+    def __init__(self, working_dir: str | None = None, verbose: bool = False, output_csv: str = "/tmp/Notebook/notebook_execution_report.csv"):
+        self.working_dir = Path(working_dir) if working_dir else Path("/tmp/Notebook")
+        self.verbose = verbose
+        self.results = []
+        self.output_csv = output_csv
+        self.colab_processor = ColabNotebookProcessor(str(self.working_dir))
+
+    def setup_working_dir(self):
+        """Create working directory"""
+        self.working_dir.mkdir(parents=True, exist_ok=True)
+        if self.verbose:
+            logger.info(f"Working directory: {self.working_dir}")
+
+    def clean_working_dir(self):
+        """Remove working directory"""
+        try:
+            if self.working_dir.exists():
+                shutil.rmtree(self.working_dir)
+                if self.verbose:
+                    logger.info(f"Cleaned working directory: {self.working_dir}")
+        except Exception as e:
+            logger.warning(f"Unable to fully clean working dir: {e}")
+
+    def _read_notebook_json(self, notebook_path: Path):
+        try:
+            with open(str(notebook_path), "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            raise RuntimeError(f"Failed to read notebook JSON: {e}")
+
+    def list_available_datasets(self):
+        """List available datasets in the working directory"""
+        dataset_extensions = {'.csv', '.xlsx', '.xls', '.json', '.txt', '.parquet'}
+        datasets = [f.name for f in self.working_dir.iterdir() 
+                   if f.suffix.lower() in dataset_extensions and f.is_file()]
+        
+        if self.verbose and datasets:
+            logger.info(f"Available datasets: {', '.join(datasets)}")
+        
+        return datasets
+
+    def extract_imports_from_notebook(self, notebook_path: Path):
+        """Extract third-party imports from notebook via AST (best-effort)."""
+        imports = set()
+        try:
+            nb_json = self._read_notebook_json(notebook_path)
+        except Exception:
+            return set()
+
+        for cell in nb_json.get("cells", []):
+            if cell.get("cell_type") != "code":
+                continue
+            source = cell.get("source", "")
+            if isinstance(source, list):
+                source = "\n".join(source)
+            try:
+                tree = ast.parse(source)
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.Import):
+                        for alias in node.names:
+                            imports.add(alias.name.split(".")[0])
+                    elif isinstance(node, ast.ImportFrom):
+                        if node.module:
+                            imports.add(node.module.split(".")[0])
+            except Exception:
+                # ignore parsing errors in individual cells
+                continue
+
+        # Filter standard-library modules (non-exhaustive)
+        stdlib = {
+            'os','sys','json','re','math','random','datetime','time','collections',
+            'itertools','functools','operator','pathlib','urllib','http','xml','html',
+            'csv','sqlite3','pickle','logging','unittest','argparse','configparser',
+            'io','typing','warnings','copy','string','textwrap','unicodedata','struct',
+            'codecs','calendar','hashlib','hmac','secrets','statistics', 'subprocess'
+        }
+        
+        # Filter out Google Colab specific imports as they're handled separately
+        colab_modules = {'google', 'colab'}
+        
+        third_party = imports - stdlib - colab_modules
+        return third_party
+
+    def install_packages(self, python_executable: Path, packages: set | list):
+        """Install packages into the environment (best-effort). Returns (success, stderr_text)"""
+        if not packages:
+            return True, ""
+        
+        # map common names -> pip packages
+        package_mapping = {
+            'sklearn': 'scikit-learn',
+            'cv2': 'opencv-python',
+            'PIL': 'Pillow',
+            'bs4': 'beautifulsoup4',
+        }
+
+        mapped = [package_mapping.get(p, p) for p in packages]
+
+        # Install packages one-by-one so errors are isolated
+        for pkg in mapped:
+            try:
+                proc = subprocess.run([str(python_executable), "-m", "pip", "install", pkg],
+                                      capture_output=True, text=True, timeout=600)
+                if proc.returncode != 0:
+                    stderr = proc.stderr or proc.stdout or f"pip install returned {proc.returncode}"
+                    logger.warning(f"Failed to install {pkg}: {stderr.strip()[:400]}")
+                    return False, stderr
+            except subprocess.TimeoutExpired:
+                msg = f"Timeout while installing {pkg}"
+                logger.warning(msg)
+                return False, msg
+            except Exception as e:
+                msg = f"Error while installing {pkg}: {e}"
+                logger.warning(msg)
+                return False, msg
+
+        return True, ""
+
+    def extract_notebook_error(self, stderr_text: str):
+        """Attempt to extract concise error message from papermill/pip stderr."""
+        if not stderr_text:
+            return "Unknown error occurred"
+        lines = stderr_text.strip().splitlines()
+        # Look for Traceback or Exception lines
+        for line in reversed(lines):
+            if any(keyword in line for keyword in ("Traceback", "Error", "Exception", "ModuleNotFoundError", "ImportError")):
+                return line.strip()
+        # fallback to last non-empty line
+        for line in reversed(lines):
+            if line.strip():
+                return line.strip()
+        return lines[-1] if lines else "Unknown error"
+
+    def display_cell_execution_details(self, output_notebook_path: Path):
+        """Verbose: show last executed cells (best-effort)."""
+        try:
+            nb = nbformat.read(str(output_notebook_path), as_version=4)
+        except Exception as e:
+            logger.info(f"Could not read output notebook for cell details: {e}")
+            return
+
+        logger.info("CELL-BY-CELL EXECUTION DETAILS (showing up to 10 code cells)")
+        shown = 0
+        for i, cell in enumerate(nb.cells, start=1):
+            if cell.cell_type != "code":
+                continue
+            shown += 1
+            logger.info(f"--- CELL {i} ---")
+            src_preview = ("\n".join(cell.source.splitlines()[:6]) + ("\n..." if len(cell.source.splitlines()) > 6 else ""))
+            logger.info("SOURCE (first lines):\n" + src_preview)
+            if getattr(cell, "outputs", None):
+                for output in cell.outputs[-2:]:  # show last two outputs per cell
+                    if output.output_type == "stream":
+                        text = getattr(output, "text", "")
+                        logger.info("STREAM OUTPUT:\n" + ("\n".join(text.splitlines()[-4:])))
+                    elif output.output_type == "error":
+                        ename = getattr(output, "ename", "")
+                        evalue = getattr(output, "evalue", "")
+                        logger.info(f"ERROR: {ename}: {evalue}")
+            if shown >= 10:
+                break
+
+    def run_notebook(self, notebook_path: str | Path, timeout: int = 1800):
+        """
+        Run a single notebook with Colab code replacement and dataset support.
+        Returns a dict: {'notebook': <name>, 'status': 'Pass'|'Fail', 'error_message': <msg>}
+        """
+        try:
+            if isinstance(notebook_path, str):
+                if notebook_path.startswith('/'):
+                    notebook_full_path = Path(notebook_path)
+                else:
+                    notebook_full_path = Path('/tmp/Notebook') / notebook_path
+            else:
+                notebook_full_path = Path(notebook_path)
+        except Exception as e:
+            return {"notebook": str(notebook_path), "status": "Fail", "error_message": f"Invalid path: {e}"}
+
+        notebook_name = notebook_full_path.name
+        notebook_dir = Path('/tmp/Notebook')
+
+        # Check if notebook exists
+        if not notebook_full_path.exists():
+            return {"notebook": notebook_name, "status": "Fail", "error_message": f"Notebook not found at: {notebook_full_path}"}
+
+        # List available datasets
+        datasets = self.list_available_datasets()
+        if datasets:
+            logger.info(f"Processing notebook with {len(datasets)} available dataset(s)")
+
+        # Process notebook for Colab compatibility
+        try:
+            processed_notebook_path = self.colab_processor.process_notebook(str(notebook_full_path))
+            if self.verbose:
+                logger.info(f"Processed notebook for Colab compatibility: {processed_notebook_path}")
+        except Exception as e:
+            logger.warning(f"Failed to process Colab compatibility: {e}")
+            processed_notebook_path = str(notebook_full_path)
+
+        # create fresh venv in the notebook folder
+        env_path = notebook_dir / "venv"
+        if env_path.exists():
+            try:
+                shutil.rmtree(env_path)
+            except Exception:
+                pass
+
+        # create venv
+        try:
+            venv_proc = subprocess.run([sys.executable, "-m", "venv", str(env_path)], capture_output=True, text=True, timeout=120)
+            if venv_proc.returncode != 0:
+                stderr = venv_proc.stderr or venv_proc.stdout
+                return {"notebook": notebook_name, "status": "Fail",
+                        "error_message": f"Failed to create venv: {stderr.strip()[:400]}"}
+        except subprocess.TimeoutExpired:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": "Timeout while creating virtual environment"}
+        except Exception as e:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": f"Error creating venv: {e}"}
+
+        # python executable inside venv
+        if os.name == "nt":
+            python_exec = env_path / "Scripts" / "python.exe"
+        else:
+            python_exec = env_path / "bin" / "python"
+
+        if not python_exec.exists():
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": f"Python executable not found in venv: {python_exec}"}
+
+        # Upgrade pip and install pinned minimal tooling
+        try:
+            # Upgrade pip
+            up_proc = subprocess.run([str(python_exec), "-m", "pip", "install", "--upgrade", "pip"],
+                                     capture_output=True, text=True, timeout=120)
+            if up_proc.returncode != 0:
+                logger.warning("pip upgrade returned non-zero; continuing if possible")
+
+            # Install pinned papermill / ipykernel / jupyter (stable versions)
+            pinned = [
+                "papermill==2.5.0",
+                "ipykernel==6.29.5",
+                "jupyter==1.0.0"
+            ]
+            install_proc = subprocess.run([str(python_exec), "-m", "pip", "install"] + pinned,
+                                          capture_output=True, text=True, timeout=600)
+            if install_proc.returncode != 0:
+                stderr_text = install_proc.stderr or install_proc.stdout or "pip install returned non-zero"
+                return {"notebook": notebook_name, "status": "Fail",
+                        "error_message": f"Failed to setup environment (pip install core packages): {stderr_text.strip()[:800]}"}
+        except subprocess.TimeoutExpired:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": "Timeout installing core packages"}
+        except Exception as e:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": f"Error installing core packages: {e}"}
+
+        # Install common data-science packages (helps many notebooks run without per-notebook pip)
+        common_packages = ["numpy", "pandas", "matplotlib", "seaborn", "scikit-learn", "plotly"]
+        try:
+            common_proc = subprocess.run([str(python_exec), "-m", "pip", "install"] + common_packages,
+                                         capture_output=True, text=True, timeout=600)
+            if common_proc.returncode != 0:
+                logger.warning("Installing common packages returned non-zero; continuing")
+        except Exception:
+            logger.warning("Unexpected error during common package install; continuing")
+
+        # Extract inferred imports and try to install them (best-effort)
+        # Use the original notebook for import detection, not the processed one
+        inferred = self.extract_imports_from_notebook(notebook_full_path)
+        if inferred:
+            success, stderr_text = self.install_packages(python_exec, inferred)
+            if not success:
+                return {"notebook": notebook_name, "status": "Fail",
+                        "error_message": f"Failed to install inferred packages: {stderr_text.strip()[:800]}"}
+
+        # Create kernel name and install kernel
+        kernel_name = f"nb_{re.sub(r'[^A-Za-z0-9_]', '_', notebook_name)}"
+        try:
+            kernel_proc = subprocess.run([str(python_exec), "-m", "ipykernel", "install", "--user",
+                                          "--name", kernel_name, "--display-name", f"Python ({kernel_name})"],
+                                         capture_output=True, text=True, timeout=60)
+            if kernel_proc.returncode != 0:
+                stderr_text = kernel_proc.stderr or kernel_proc.stdout or "ipykernel install returned non-zero"
+                return {"notebook": notebook_name, "status": "Fail",
+                        "error_message": f"Failed to install kernel: {stderr_text.strip()[:800]}"}
+        except subprocess.TimeoutExpired:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": "Timeout while installing kernel"}
+        except Exception as e:
+            return {"notebook": notebook_name, "status": "Fail",
+                    "error_message": f"Error installing kernel: {e}"}
+
+        # Execute notebook with papermill (use the processed notebook)
+        output_path = notebook_dir / "output.ipynb"
+        try:
+            exec_proc = subprocess.run([str(python_exec), "-m", "papermill",
+                                        processed_notebook_path, str(output_path),
+                                        "--kernel", kernel_name, "--no-progress-bar"],
+                                       capture_output=True, text=True, timeout=timeout, cwd=str(notebook_dir))
+            if exec_proc.returncode == 0:
+                status = "Pass"
+                error_message = ""
+                if self.verbose:
+                    logger.info("Notebook executed successfully")
+                    if output_path.exists():
+                        self.display_cell_execution_details(output_path)
+            else:
+                status = "Fail"
+                stderr_text = (exec_proc.stderr or "") + "\n" + (exec_proc.stdout or "")
+                concise = self.extract_notebook_error(stderr_text)
+                error_message = f"Execution failed: {concise}"
+                if self.verbose:
+                    logger.error(error_message)
+                    if output_path.exists():
+                        self.display_cell_execution_details(output_path)
+        except subprocess.TimeoutExpired:
+            status = "Fail"
+            error_message = f"Execution timed out after {timeout} seconds"
+        except Exception as e:
+            status = "Fail"
+            error_message = f"Papermill execution error: {e}"
+
+        # cleanup processed notebook
+        try:
+            if processed_notebook_path != str(notebook_full_path) and os.path.exists(processed_notebook_path):
+                os.remove(processed_notebook_path)
+        except Exception:
+            pass
+
+        # cleanup venv if present (best-effort)
+        try:
+            if env_path.exists():
+                shutil.rmtree(env_path)
+        except Exception:
+            logger.info("Could not remove venv directory (non-fatal)")
+
+        result = {"notebook": notebook_name, "status": status, "error_message": error_message}
+        # store result
+        self.results.append(result)
+        # update CSV incrementally
+        self._update_csv_report()
+        return result
+
+    def _update_csv_report(self):
+        """Write incremental CSV with columns notebook,status,error_message"""
+        try:
+            df = pd.DataFrame(self.results)
+            # Ensure consistent column ordering
+            cols = ['notebook', 'status', 'error_message']
+            for c in cols:
+                if c not in df.columns:
+                    df[c] = ""
+            df = df[cols]
+            df.to_csv(self.output_csv, index=False)
+            if self.verbose:
+                logger.info(f"Wrote report to {self.output_csv}")
+        except Exception as e:
+            logger.warning(f"Failed to write CSV report: {e}")
+
+# -------- Public entrypoint --------
+def execute_notebook(path: str, timeout: int = 1800, verbose: bool = False, output_csv: str = "notebook_execution_report.csv"):
+    """
+    Public function to execute a single notebook with Colab support and dataset integration.
+
+    Args:
+        path: path to the uploaded .ipynb file (string)
+        timeout: execution timeout in seconds (default 1800)
+        verbose: enable verbose logging
+        output_csv: path to write CSV report (default notebook_execution_report.csv)
+
+    Returns:
+        result dict: {'notebook': <name>, 'status': 'Pass'|'Fail', 'error_message': <msg>}
+    """
+    executor = NotebookExecutor(verbose=verbose, output_csv=output_csv)
+    executor.setup_working_dir()
+    result = executor.run_notebook(path, timeout=timeout)
+    return result
+
+# -------- CLI main (optional) --------
+def main_call(notebook):
+    """Main function for executing notebook with enhanced Colab and dataset support"""
+    executor = NotebookExecutor(verbose=True)  # Enable verbose for better debugging
+    executor.setup_working_dir()
+
+    result = executor.run_notebook(notebook, timeout=1800)
+    
+    return result

src/v2/notebook_parser.py

@@ -0,0 +1,117 @@
+import json,re
+
+class NotebookParser:
+    def __init__(self, notebook_path: str):
+        """Initialize with path to a Jupyter notebook file."""
+        self.notebook_path = notebook_path
+        with open(notebook_path, "r", encoding="utf-8") as f:
+            self.nb_json = json.load(f)
+
+
+    def extract(self, code: bool = False, code_output: bool = False, markdown: bool = False, plots: bool = False):
+        """
+        Extracts notebook content in order of appearance.
+
+        Args:
+            code (bool): include code cells
+            code_output (bool): include code cell outputs
+            markdown (bool): include markdown cells
+            plots (bool): include image outputs (PNG/JPEG, including markdown images)
+
+        Returns:
+            List[dict]: list of content blocks for LLM consumption
+        """
+        content = []
+        image_pattern = re.compile(r"!\[.*?\]\((.*?)\)")
+
+        for cell in self.nb_json.get("cells", []):
+            cell_type = cell.get("cell_type")
+
+            if markdown and cell_type == "markdown":
+                text = "".join(cell.get("source", []))
+                if text.strip():
+                    if plots:
+                        content.append({"type": "text", "text": text})
+                    else:
+                        text_no_images = image_pattern.sub("", text).strip()
+                        if text_no_images:
+                            content.append({"type": "text", "text": text_no_images})
+
+                    if plots:
+                        for match in image_pattern.findall(text):
+                            if match.startswith("data:image/png;base64,"):
+                                content.append({
+                                    "type": "image",
+                                    "source_type": "base64",
+                                    "data": match.replace("data:image/png;base64,", ""),
+                                    "mime_type": "image/png"
+                                })
+                            elif match.startswith("data:image/jpeg;base64,"):
+                                content.append({
+                                    "type": "image",
+                                    "source_type": "base64",
+                                    "data": match.replace("data:image/jpeg;base64,", ""),
+                                    "mime_type": "image/jpeg"
+                                })
+                            else:
+                                content.append({
+                                    "type": "text",
+                                    "text": f"[Image: {match}]"
+                                })
+
+            elif code and cell_type == "code":
+                code_text = "".join(cell.get("source", []))
+                if code_text.strip():
+                    content.append({
+                        "type": "text",
+                        "text": f"{code_text}"
+                    })
+
+            if code_output and cell_type == "code":
+                for output in cell.get("outputs", []):
+                    if "data" in output:
+                        data = output["data"]
+
+                        if plots and "image/png" in data:
+                            content.append({
+                                "type": "image",
+                                "source_type": "base64",
+                                "data": data["image/png"],
+                                "mime_type": "image/png"
+                            })
+                        elif plots and "image/jpeg" in data:
+                            content.append({
+                                "type": "image",
+                                "source_type": "base64",
+                                "data": data["image/jpeg"],
+                                "mime_type": "image/jpeg"
+                            })
+
+                        elif "text/plain" in data:
+                            text_out = "".join(data["text/plain"])
+                            if text_out.strip():
+                                content.append({
+                                    "type": "text",
+                                    "text": f"{text_out}"
+                                })
+
+                    if output.get("output_type") == "stream":
+                        text_out = "".join(output.get("text", []))
+                        if text_out.strip():
+                            content.append({
+                                "type": "text",
+                                "text": f"{text_out}"
+                            })
+
+                    if output.get("output_type") == "error":
+                        ename = output.get("ename", "")
+                        evalue = output.get("evalue", "")
+                        traceback = "\n".join(output.get("traceback", []))
+                        content.append({
+                            "type": "text",
+                            "text": f"{ename}: {evalue}\n{traceback}"
+                        })
+
+        return content
+
+

src/v2/output_schema.py

@@ -0,0 +1,37 @@
+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."
+    )
+
+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`."
+        )
+
+class EvaluationSuggestions(BaseModel):
+    key_suggestions: List[str] = Field(
+        description="A list of actionable suggestions that highlight the most critical improvements across business context, objectives, conclusions & recommendations, and alignment."
+    )
+
+class NotebookFlowEvaluation(BaseModel):
+    suggestions: List[str] = Field(
+        ..., 
+        description="Actionable suggestions to improve the notebook's logical flow, instructional design, or overall quality."
+    )

src/v2/setup.py

@@ -0,0 +1,9 @@
+import streamlit as st
+from assets import logo,icon
+
+def page_setup():
+    st.set_page_config(
+    page_title="Great Lens",
+    page_icon=icon)
+
+    st.logo(logo,size='large',link='https://www.mygreatlearning.com/')

src/v2/streamlit_app_modified.py

@@ -0,0 +1,152 @@
+import streamlit as st
+import os
+from setup import page_setup
+from utilities import save_notebook, save_datasets
+from grammar_exec import execute
+from notebook import main_call
+import pandas as pd
+from pathlib import Path
+
+
+col1, col2, col3 = st.columns([2, 4, 1])
+with col2:
+    st.title(":blue[Great] Lens 🕵️‍♂️")
+
+# File upload section
+st.subheader("📁 Upload Files")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("**Upload Notebook**")
+    notebook = st.file_uploader(
+        label='Select Jupyter Notebook',
+        accept_multiple_files=False,
+        type=['ipynb'],
+        help="Upload a .ipynb file to analyze"
+    )
+
+with col2:
+    st.markdown("**Upload Datasets (Optional)**")
+    datasets = st.file_uploader(
+        label='Select Dataset Files',
+        accept_multiple_files=True,
+        type=['csv', 'xlsx', 'xls', 'json', 'txt', 'parquet'],
+        help="Upload datasets that your notebook references"
+    )
+
+# Display uploaded files info
+if datasets:
+    st.info(f"📊 {len(datasets)} dataset(s) uploaded: {', '.join([f.name for f in datasets])}")
+
+if notebook:
+    st.success(f"📓 Notebook uploaded: {notebook.name}")
+    
+    # Save files to /tmp/Notebook
+    save_notebook(notebook)
+    if datasets:
+        save_datasets(datasets)
+        st.info("✅ Datasets saved to notebook directory")
+    
+    results_tab, grammar_tab = st.tabs(['Execution', 'Grammar/Fact']) 
+    
+    with results_tab:
+        with st.spinner("🔄 Executing notebook..."):
+            try:
+                notebook_dir_path = Path("/tmp/Notebook")
+                notebook_files = [f for f in notebook_dir_path.iterdir() if f.suffix == '.ipynb']
+                
+                if not notebook_files:
+                    st.error("No notebook found in directory")
+                else:
+                    notebook_path = notebook_files[0]
+                    st.write(f'🚀 Processing notebook: {notebook_path.name}')
+                    
+                    # Show available datasets
+                    dataset_files = [f for f in notebook_dir_path.iterdir() 
+                                   if f.suffix.lower() in ['.csv', '.xlsx', '.xls', '.json', '.txt', '.parquet']]
+                    
+                    if dataset_files:
+                        st.info(f"📁 Available datasets: {', '.join([f.name for f in dataset_files])}")
+                    
+                    results = main_call(notebook_path)
+                    
+                    # Display results in a more user-friendly way
+                    if isinstance(results, dict):
+                        col1, col2 = st.columns([1, 3])
+                        with col1:
+                            if results['status'] == 'Pass':
+                                st.success("✅ **Status: PASSED**")
+                            else:
+                                st.error("❌ **Status: FAILED**")
+                        
+                        with col2:
+                            st.write(f"**Notebook:** {results['notebook']}")
+                            if results['error_message']:
+                                st.error(f"**Error:** {results['error_message']}")
+                    else:
+                        st.dataframe(results)
+                        
+            except Exception as e:
+                st.error(f"❌ Error processing notebook: {str(e)}")
+    
+    with grammar_tab:
+        try:
+            with st.spinner("🔍 Analyzing grammar and facts..."):
+                results = execute("/tmp/Notebook")
+                
+                if not results.empty:
+                    # Display grammar results in a more readable format
+                    st.subheader("📝 Grammar & Style Analysis")
+                    
+                    if 'Grammar_Text' in results.columns and len(results['Grammar_Text'].dropna()) > 0:
+                        grammar_issues = results[results['Grammar_Text'].notna()]
+                        
+                        for idx, row in grammar_issues.iterrows():
+                            if row['Is Grammar Error?']:
+                                st.warning(f"**Grammar Error:** {row['Grammar_Text']}")
+                                st.info(f"**Suggestion:** {row['Grammar_Suggestions']}")
+                            else:
+                                st.info(f"**Style Suggestion:** {row['Grammar_Text']}")
+                                st.success(f"**Improvement:** {row['Grammar_Suggestions']}")
+                            st.divider()
+                    
+                    st.subheader("🎯 Factual Accuracy Analysis")
+                    
+                    if 'Fact_Text' in results.columns and len(results['Fact_Text'].dropna()) > 0:
+                        fact_issues = results[results['Fact_Text'].notna()]
+                        
+                        for idx, row in fact_issues.iterrows():
+                            st.error(f"**Factual Error:** {row['Fact_Text']}")
+                            st.success(f"**Correction:** {row['Fact_Suggestions']}")
+                            st.divider()
+                    
+                    # Show raw dataframe as well
+                    with st.expander("📊 View Raw Results"):
+                        st.dataframe(results)
+                else:
+                    st.success("✅ No grammar or factual issues found!")
+                    
+        except Exception as e:
+            st.error(f"❌ Unable to process grammar/facts: {str(e)}")
+
+# Add some helpful information
+st.sidebar.markdown("## 💡 How to Use")
+st.sidebar.markdown("""
+1. **Upload Notebook**: Select your .ipynb file
+2. **Upload Datasets**: Add any CSV, Excel, or other data files your notebook uses
+3. **Execution Tab**: See if your notebook runs successfully
+4. **Grammar/Fact Tab**: Check for text quality and factual accuracy
+
+### 🔧 Colab Support
+The tool automatically handles Google Colab specific code:
+- Replaces Drive mounts with local file access
+- Uses your uploaded datasets instead of Colab file uploads
+- Skips Colab-specific imports that won't work locally
+""")
+
+st.sidebar.markdown("## 📋 Supported Formats")
+st.sidebar.markdown("""
+**Notebooks:** .ipynb  
+**Datasets:** .csv, .xlsx, .xls, .json, .txt, .parquet
+""")

src/v2/utilities.py

@@ -0,0 +1,94 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+from pathlib import Path
+import os
+import shutil
+
+def save_notebook(notebook):
+    """Save uploaded notebook to /tmp/Notebook directory"""
+    folder_path = Path("/tmp/Notebook")
+
+    if folder_path.exists() and folder_path.is_dir():
+        shutil.rmtree(folder_path)
+
+    folder_path.mkdir(parents=True, exist_ok=True)
+
+    if notebook:
+        file_path = notebook.name
+        with open(os.path.join(folder_path, file_path), "wb") as file:
+            file.write(notebook.getbuffer())
+
+def save_datasets(datasets):
+    """Save uploaded datasets to /tmp/Notebook directory"""
+    folder_path = Path("/tmp/Notebook")
+    
+    # Ensure directory exists
+    folder_path.mkdir(parents=True, exist_ok=True)
+    
+    if datasets:
+        for dataset in datasets:
+            file_path = dataset.name
+            with open(os.path.join(folder_path, file_path), "wb") as file:
+                file.write(dataset.getbuffer())
+
+def get_dataset_files(directory_path):
+    """Get list of dataset files in the directory"""
+    folder_path = Path(directory_path)
+    if not folder_path.exists():
+        return []
+    
+    dataset_extensions = {'.csv', '.xlsx', '.xls', '.json', '.txt', '.parquet'}
+    dataset_files = [f for f in folder_path.iterdir() 
+                    if f.suffix.lower() in dataset_extensions and f.is_file()]
+    
+    return dataset_files
+
+def create_dataset_mapping(directory_path):
+    """Create a mapping of common dataset names to actual files"""
+    dataset_files = get_dataset_files(directory_path)
+    mapping = {}
+    
+    for file in dataset_files:
+        # Create various possible references to this file
+        filename = file.name
+        name_without_ext = file.stem
+        
+        # Common patterns notebooks might use
+        mapping[filename] = filename
+        mapping[name_without_ext] = filename
+        mapping[filename.lower()] = filename
+        mapping[name_without_ext.lower()] = filename
+        
+        # Common generic names
+        if filename.lower().startswith('data'):
+            mapping['data.csv'] = filename
+            mapping['dataset.csv'] = filename
+        
+        # If it's the first/only CSV, make it the default
+        if file.suffix.lower() == '.csv' and 'default.csv' not in mapping:
+            mapping['default.csv'] = filename
+            
+    return mapping
+
+def safe_concurrent_batch(chain, inputs, max_workers=2):
+    """Process inputs concurrently with error handling"""
+    results = []
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_input = {executor.submit(chain.invoke, inp): inp for inp in inputs}
+        
+        for future in tqdm(as_completed(future_to_input), total=len(inputs), desc="Processing"):
+            inp = future_to_input[future]
+            try:
+                output = future.result()
+                results.append({
+                    "input": inp,
+                    "output": output,
+                    "status": "success"
+                })
+            except Exception as e:
+                results.append({
+                    "input": inp,
+                    "output": None,
+                    "status": f"failed: {str(e)}"
+                })
+    return results