mito-ai 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py

@@ -0,0 +1,45 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.streamlit_conversion.prompts.prompt_constants import MITO_TODO_PLACEHOLDER
+
+def get_streamlit_app_creation_prompt(notebook: dict) -> str:
+    """
+    This prompt is used to create a streamlit app from a notebook.
+    """
+    return f"""Convert the following Jupyter notebook into a Streamlit application.
+
+GOAL: Create a complete, runnable Streamlit app that accurately represents the notebook. It must completely convert the notebook. 
+
+TODO PLACEHOLDER RULES:
+If you decide to leave any TODOs, you must mark them with {MITO_TODO_PLACEHOLDER}. You should use {MITO_TODO_PLACEHOLDER} instead of comments like the following: 
+- # ... (include all mappings from the notebook)
+- # ... (include all violation codes from the notebook)
+- # Fill in the rest of the code here
+- # TODO: Add more code here
+- # TODO: Add the visualization code here
+
+For each TODO, use this exact format:
+{MITO_TODO_PLACEHOLDER}: <specific description of what needs to be added>
+
+IMPORTANT:
+- The app must still be RUNNABLE even with placeholders
+- Include enough sample data to show the structure
+- Do NOT use placeholders for small/medium content - include it directly
+- Do NOT use placeholders for file paths, imports, or core logic
+- Only use placeholders when absolutely necessary. Add all of the content directly as much as possible.
+
+<Example>
+If the notebook has a list of dictionaries with 50 entries, you would write:
+
+data = [
+    {{'id': 1, 'name': 'Item A', 'category': 'Type 1', 'value': 100}},
+    {{'id': 2, 'name': 'Item B', 'category': 'Type 2', 'value': 200}},
+    {MITO_TODO_PLACEHOLDER}: Add remaining entries from the data list
+]
+</Example>
+
+Notebook to convert:
+
+{notebook}
+"""

mito_ai/streamlit_conversion/prompts/streamlit_error_correction_prompt.py

@@ -0,0 +1,28 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.streamlit_conversion.prompts.prompt_constants import unified_diff_instrucrions
+from mito_ai.streamlit_conversion.prompts.prompt_utils import add_line_numbers_to_code
+
+def get_streamlit_error_correction_prompt(error: str, streamlit_app_code: str) -> str:
+    
+    existing_streamlit_app_code_with_line_numbers = add_line_numbers_to_code(streamlit_app_code)
+    
+    return f"""You've created a Streamlit app, but it has an error in it when you try to run it.
+
+Your job is to fix the error now. Only fix the specific error that you are instructed to fix now. Do not fix other error that that you anticipate. You will be asked to fix other errors later.
+
+{unified_diff_instrucrions}
+
+===============================================
+
+EXISTING STREAMLIT APP:
+{existing_streamlit_app_code_with_line_numbers}
+
+===============================================
+
+Please create a unified diff that corrects this error. Please keep your fix concise:
+{error}
+
+"""
+

mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_prompt.py

@@ -0,0 +1,44 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from mito_ai.streamlit_conversion.prompts.prompt_constants import MITO_TODO_PLACEHOLDER, unified_diff_instrucrions
+from mito_ai.streamlit_conversion.prompts.prompt_utils import add_line_numbers_to_code
+
+def get_finish_todo_prompt(notebook: dict, existing_streamlit_app_code: str, todo_placeholder: str) -> str:
+  
+    existing_streamlit_app_code_with_line_numbers = add_line_numbers_to_code(existing_streamlit_app_code)
+    
+    return f"""You've already created the first draft of a Streamlit app representation of a Jupyter notebook, but you left yourself some TODOs marked as `{MITO_TODO_PLACEHOLDER}`. 
+
+**CRITICAL COMPLETION REQUIREMENT:**
+You have ONE and ONLY ONE opportunity to complete this TODO. If you do not finish the entire task completely, the application will be broken and unusable. This is your final chance to get it right.
+
+**COMPLETION RULES:**
+1. **NEVER leave partial work** - If the TODO asks for a list with 100 items, provide ALL 100 items
+2. **NEVER use placeholders** - This is your only opportunity to fulfill this TODO, so do not leave yourself another TODO.
+3. **NEVER assume "good enough"** - Complete the task to 100% satisfaction
+4. **If the task seems large, that's exactly why it needs to be done now** - This is your only chance
+
+**HOW TO DETERMINE IF TASK IS COMPLETE:**
+- If building a list/dictionary: Include ALL items that should be in the final data structure
+- If creating functions: Implement ALL required functionality
+- If converting a visualization: Copy over ALL of the visualization code from the notebook, including all styling and formatting.
+
+{unified_diff_instrucrions}
+
+===============================================
+
+Input Notebook that you are converting into the Streamlit app:
+{notebook}
+
+===============================================
+
+EXISTING STREAMLIT APP:
+{existing_streamlit_app_code_with_line_numbers}
+
+===============================================
+
+Please make the changes for this TODO. Only focus on this one TODO right now. You will be asked to fix others later:
+{todo_placeholder}
+
+"""

mito_ai/streamlit_conversion/streamlit_agent_handler.py

@@ -2,31 +2,26 @@
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
 import logging
+import os
 from anthropic.types import MessageParam
-from typing import List, Tuple, cast
+from typing import List, Optional, Tuple, cast, Union
 
 from mito_ai.logger import get_logger
+from mito_ai.streamlit_conversion.agent_utils import apply_patch_to_text, extract_todo_placeholders, fix_diff_headers
+from mito_ai.streamlit_conversion.prompts.streamlit_app_creation_prompt import get_streamlit_app_creation_prompt
+from mito_ai.streamlit_conversion.prompts.streamlit_error_correction_prompt import get_streamlit_error_correction_prompt
+from mito_ai.streamlit_conversion.prompts.streamlit_finish_todo_prompt import get_finish_todo_prompt
 from mito_ai.streamlit_conversion.streamlit_system_prompt import streamlit_system_prompt
-from mito_ai.streamlit_conversion.validate_and_run_streamlit_code import streamlit_code_validator
-from mito_ai.streamlit_conversion.streamlit_utils import extract_code_blocks, create_app_file, parse_jupyter_notebook_to_extract_required_content
+from mito_ai.streamlit_conversion.validate_streamlit_app import validate_app
+from mito_ai.streamlit_conversion.streamlit_utils import extract_code_blocks, create_app_file, extract_unified_diff_blocks, parse_jupyter_notebook_to_extract_required_content
 from mito_ai.utils.anthropic_utils import stream_anthropic_completion_from_mito_server
 from mito_ai.completions.models import MessageType
+from mito_ai.utils.telemetry_utils import log_streamlit_app_creation_error, log_streamlit_app_creation_retry, log_streamlit_app_creation_success
+from mito_ai.streamlit_conversion.streamlit_utils import clean_directory_check
 
 STREAMLIT_AI_MODEL = "claude-3-5-haiku-latest"
 
 class StreamlitCodeGeneration:
-    def __init__(self, notebook: dict) -> None:
-
-        self.messages: List[MessageParam] = [
-            cast(MessageParam, {
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": f"Here is my jupyter notebook content that I want to convert into a Streamlit dashboard - {notebook}"
-                }]
-            })
-        ]
-
     @property
     def log(self) -> logging.Logger:
         """Use Mito AI logger."""
@@ -54,59 +49,110 @@ class StreamlitCodeGeneration:
             accumulated_response += stream_chunk
         return accumulated_response
 
-    def add_agent_response_to_context(self, agent_response: str) -> None:
-        """Add the agent's response to the history"""
-        self.messages.append(
+    async def generate_streamlit_code(self, notebook: dict) -> str:
+        """Send a query to the agent, get its response and parse the code"""
+        
+        messages: List[MessageParam] = [
             cast(MessageParam, {
-                "role": "assistant",
+                "role": "user",
                 "content": [{
                     "type": "text",
-                    "text": agent_response
+                    "text": get_streamlit_app_creation_prompt(notebook)
                 }]
             })
-        )
-
-    async def generate_streamlit_code(self) -> str:
-        """Send a query to the agent, get its response and parse the code"""
-        agent_response = await self.get_response_from_agent(self.messages)
+        ]
+        
+        agent_response = await self.get_response_from_agent(messages)
 
         converted_code = extract_code_blocks(agent_response)
-        self.add_agent_response_to_context(converted_code)
+        
+        # Extract the TODOs from the agent's response
+        todo_placeholders = extract_todo_placeholders(agent_response)
+        
+        for todo_placeholder in todo_placeholders:
+            print(f"Processing AI TODO: {todo_placeholder}")
+            todo_prompt = get_finish_todo_prompt(notebook, converted_code, todo_placeholder)
+            todo_messages: List[MessageParam] = [
+                cast(MessageParam, {
+                    "role": "user",
+                    "content": [{
+                        "type": "text",
+                        "text": todo_prompt
+                    }]
+                })
+            ]
+            todo_response = await self.get_response_from_agent(todo_messages)
+            
+            # Apply the diff to the streamlit app
+            exctracted_diff = extract_unified_diff_blocks(todo_response)
+            fixed_diff = fix_diff_headers(exctracted_diff)
+            converted_code = apply_patch_to_text(converted_code, fixed_diff)
+                    
         return converted_code
 
 
-    async def correct_error_in_generation(self, error: str) -> str:
+    async def correct_error_in_generation(self, error: str, streamlit_app_code: str) -> str:
         """If errors are present, send it back to the agent to get corrections in code"""
-        self.messages.append(
+        messages: List[MessageParam] = [
             cast(MessageParam, {
                 "role": "user",
                 "content": [{
                     "type": "text",
-                    "text": f"When I run the streamlit app code, I get the following error: {error}\nPlease return the FULL Streamlit app code with the error corrected"
+                    "text": get_streamlit_error_correction_prompt(error, streamlit_app_code)
                 }]
             })
-        )
-        agent_response = await self.get_response_from_agent(self.messages)
-        converted_code = extract_code_blocks(agent_response)
-        self.add_agent_response_to_context(converted_code)
+        ]
+        agent_response = await self.get_response_from_agent(messages)
+        
+        # Apply the diff to the streamlit app
+        exctracted_diff = extract_unified_diff_blocks(agent_response)
+        
+        print(f"\n\nExtracted diff: {exctracted_diff}")
+        fixed_diff = fix_diff_headers(exctracted_diff)
+        streamlit_app_code = apply_patch_to_text(streamlit_app_code, fixed_diff)
+        
+        print("\n\nUpdated app code: ", streamlit_app_code)
 
-        return converted_code
+        return streamlit_app_code
 
 
-async def streamlit_handler(notebook_path: str, app_path: str) -> Tuple[bool, str]:
+async def streamlit_handler(notebook_path: str) -> Tuple[bool, Optional[str], str]:
     """Handler function for streamlit code generation and validation"""
+
+    clean_directory_check(notebook_path)
+
     notebook_code = parse_jupyter_notebook_to_extract_required_content(notebook_path)
-    streamlit_code_generator = StreamlitCodeGeneration(notebook_code)
-    streamlit_code = await streamlit_code_generator.generate_streamlit_code()
-    has_validation_error, error = streamlit_code_validator(streamlit_code)
+    streamlit_code_generator = StreamlitCodeGeneration()
+    streamlit_code = await streamlit_code_generator.generate_streamlit_code(notebook_code)
+    
+    has_validation_error, errors = validate_app(streamlit_code, notebook_path)
     tries = 0
     while has_validation_error and tries < 5:
-        streamlit_code = await streamlit_code_generator.correct_error_in_generation(error)
-        has_validation_error, error = streamlit_code_validator(streamlit_code)
+        for error in errors:
+            streamlit_code = await streamlit_code_generator.correct_error_in_generation(error, streamlit_code)
+        
+        has_validation_error, errors = validate_app(streamlit_code, notebook_path)
+        
+        if has_validation_error:
+            # TODO: We can't easily get the key type here, so for the beta release
+            # we are just defaulting to the mito server key since that is by far the most common.
+            log_streamlit_app_creation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, error)
         tries+=1
 
     if has_validation_error:
-        return False, "Error generating streamlit code by agent"
-
-    success_flag, message = create_app_file(app_path, streamlit_code)
-    return success_flag, message
+        log_streamlit_app_creation_error('mito_server_key', MessageType.STREAMLIT_CONVERSION, error)
+        return False, '', "Error generating streamlit code by agent"
+    
+    # Convert to absolute path for directory calculation
+    absolute_notebook_path = notebook_path
+    if not (notebook_path.startswith('/') or (len(notebook_path) > 1 and notebook_path[1] == ':')):
+        absolute_notebook_path = os.path.join(os.getcwd(), notebook_path)
+    
+    app_directory = os.path.dirname(absolute_notebook_path)
+    success_flag, app_path, message = create_app_file(app_directory, streamlit_code)
+    
+    if not success_flag:
+        log_streamlit_app_creation_error('mito_server_key', MessageType.STREAMLIT_CONVERSION, message)
+    
+    log_streamlit_app_creation_success('mito_server_key', MessageType.STREAMLIT_CONVERSION)
+    return success_flag, app_path, message

mito_ai/streamlit_conversion/streamlit_system_prompt.py

@@ -1,7 +1,7 @@
 # Copyright (c) Saga Inc.
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
-streamlit_system_prompt = """You are a senior data scientist and Streamlit expert specializing in converting Jupyter notebooks into professional dashboard applications.
+streamlit_system_prompt = """You are a code conversion specialist who converts Jupyter notebooks into Streamlit applications with ABSOLUTE FIDELITY.
 
 ROLE AND EXPERTISE:
 - Expert in Python, Jupyter notebooks, Streamlit, and data visualization
@@ -17,26 +17,39 @@ TASK REQUIREMENTS:
 STREAMLIT IMPLEMENTATION GUIDELINES:
 - Use appropriate Streamlit components (st.title, st.header, st.subheader, st.markdown, etc.)
 - Display all visualizations using st.pyplot(), st.plotly_chart(), or st.altair_chart() as appropriate
+- Do not convert database connections into Streamlit's secret.toml format. If the user inlined their database credentials, are importing from an environment variable, or reading from a connections file, assume that same approach will work in the streamlit app.
 - Show dataframes and tables using st.dataframe() or st.table()
 - Include all text explanations and insights from markdown cells
 - Add interactive elements where beneficial (filters, selectors, etc.)
 - Ensure professional styling and layout suitable for executives
 
-CODE STRUCTURE:
-- Generate a complete, runnable app.py file
-- Include all necessary imports
-- Handle data loading and processing
-- Organize content with clear sections and headers
-- Include comments explaining key sections
+CRITICAL REQUIREMENTS:
+1. **PRESERVE ALL CODE EXACTLY**: Every line of code, every data structure, every import must be included in full
+2. **NO PLACEHOLDERS**: Never use comments like "# Add more data here" or "# Fill in the rest"
+3. **NO SIMPLIFICATION**: Do not replace actual data with sample data or hardcoded examples
+4. **COMPLETE DATA STRUCTURES**: If a notebook has a 1000-line dictionary, include all 1000 lines
+5. **PRESERVE DATA LOADING**: If the notebook reads from files, the Streamlit app must read from the same files
+6. **NO IMPROVIZAITION**: Do not provide your own interpretations of the analysis. Just convert the existing analysis into a streamlit app.
+
+STYLE GUIDELINES: 
+- Create a professional, executive-friendly dashboard
+- If there are variables in the notebook that the streamlit app viewer would likely want to configure, then use the appropriate streamlit component to allow them to do so. For examples, if the notebook has a variable called "start_date" and "end_date", then use the st.date_input component to allow the user to select the start and end dates.
+- Do not use emojis unless they are in the notebook already
+- Do not modify the graphs or analysis. If the notebook has a graph, use the same graph in the streamlit app.
+- Always include the following code at the top of the file so the user does not use the wrong deploy button
+```python
+st.markdown(\"\"\"
+    <style>
+        #MainMenu {visibility: hidden;}
+        .stAppDeployButton {display:none;}
+        footer {visibility: hidden;}
+        .stMainBlockContainer {padding: 2rem 1rem 2rem 1rem;}
+    </style>
+\"\"\", unsafe_allow_html=True)
+```
 
 OUTPUT FORMAT:
-- Provide the complete app.py file code
-- Ensure all notebook outputs are faithfully reproduced
-- Make the dashboard professional and presentation-ready
-- Focus on clarity and executive-level communication
-- Don't give extra explanations, just give the python code 
-- Do NOT add emojis 
-- Do NOT modify the graphs or analysis
-- Do NOT provide your own interpretations for the analysis
-
-Remember: The goal is to transform technical analysis into a polished, interactive/visually appealing dashboard that executives can easily understand and navigate."""
+- Output the complete, runnable app.py file.
+- Do not output any extra text, just give the python code. 
+
+"""

mito_ai/streamlit_conversion/streamlit_utils.py

@@ -3,7 +3,9 @@
 
 import re
 import json
-from typing import Dict, Tuple, Any
+import os
+from typing import Dict, Optional, Tuple, Any
+from pathlib import Path
 
 def extract_code_blocks(message_content: str) -> str:
     """
@@ -18,7 +20,6 @@ def extract_code_blocks(message_content: str) -> str:
     if "```python" not in message_content:
         return message_content
 
-    # return message_content.split('```python\n')[1].split('\n```')[0]
     # Use regex to find all Python code blocks
     pattern = r'```python\n(.*?)```'
     matches = re.findall(pattern, message_content, re.DOTALL)
@@ -26,8 +27,19 @@ def extract_code_blocks(message_content: str) -> str:
     # Concatenate with single newlines
     return '\n'.join(matches)
 
+def extract_unified_diff_blocks(message_content: str) -> str:
+    """
+    Extract all unified_diff blocks from Claude's response.
+    """
+    if "```unified_diff" not in message_content:
+        return message_content
+    
+    pattern = r'```unified_diff\n(.*?)```'
+    matches = re.findall(pattern, message_content, re.DOTALL)
+    return '\n'.join(matches)
+
 
-def create_app_file(file_path: str, code: str) -> Tuple[bool, str]:
+def create_app_file(app_directory: str, code: str) -> Tuple[bool, str, str]:
     """
     Create app.py file and write code to it with error handling
 
@@ -40,13 +52,14 @@ def create_app_file(file_path: str, code: str) -> Tuple[bool, str]:
 
     """
     try:
-        with open(file_path+"/app.py", 'w') as f:
+        app_path = os.path.join(app_directory, "app.py")
+        with open(app_path, 'w') as f:
             f.write(code)
-        return True, f"Successfully created {file_path}"
+        return True, app_path, f"Successfully created {app_directory}"
     except IOError as e:
-        return False, f"Error creating file: {str(e)}"
+        return False, '', f"Error creating file: {str(e)}"
     except Exception as e:
-        return False, f"Unexpected error: {str(e)}"
+        return False, '', f"Unexpected error: {str(e)}"
 
 
 def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Dict[str, Any]:
@@ -54,7 +67,7 @@ def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Di
     Read a Jupyter notebook and filter cells to keep only cell_type and source fields.
 
     Args:
-        notebook_path (str): Absolute path to the .ipynb file
+        notebook_path (str): Path to the .ipynb file (can be relative or absolute)
 
     Returns:
         dict: Filtered notebook dictionary with only cell_type and source in cells
@@ -64,6 +77,11 @@ def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Di
         json.JSONDecodeError: If the file is not valid JSON
         KeyError: If the notebook doesn't have the expected structure
     """
+    # Convert to absolute path if it's not already absolute
+    # Handle both Unix-style absolute paths (starting with /) and Windows-style absolute paths
+    if not (notebook_path.startswith('/') or (len(notebook_path) > 1 and notebook_path[1] == ':')):
+        notebook_path = os.path.join(os.getcwd(), notebook_path)
+    
     try:
         # Read the notebook file
         with open(notebook_path, 'r', encoding='utf-8') as f:
@@ -94,3 +112,25 @@ def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Di
         raise json.JSONDecodeError(f"Invalid JSON in notebook file: {str(e)}", e.doc if hasattr(e, 'doc') else '', e.pos if hasattr(e, 'pos') else 0)
     except Exception as e:
         raise Exception(f"Error processing notebook: {str(e)}")
+
+
+def resolve_notebook_path(notebook_path:str) -> str:
+    # Convert to absolute path if it's not already absolute
+    # Handle both Unix-style absolute paths (starting with /) and Windows-style absolute paths
+    if not (notebook_path.startswith('/') or (len(notebook_path) > 1 and notebook_path[1] == ':')):
+        notebook_path = os.path.join(os.getcwd(), notebook_path)
+    return notebook_path
+
+def clean_directory_check(notebook_path: str) -> None:
+    notebook_path = resolve_notebook_path(notebook_path)
+    # pathlib handles the cross OS path conversion automatically
+    path = Path(notebook_path).resolve()
+    dir_path = path.parent
+
+    if not dir_path.exists():
+        raise ValueError(f"Directory does not exist: {dir_path}")
+
+    file_count = len([f for f in dir_path.iterdir() if f.is_file()])
+    if file_count > 10:
+        raise ValueError(
+            f"Too many files in directory: 10 allowed but {file_count} present. Create a new directory and retry")

mito_ai/streamlit_conversion/validate_streamlit_app.py

@@ -0,0 +1,116 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+import sys
+import os
+import time
+import requests
+import tempfile
+import shutil
+import traceback
+import ast
+import importlib.util
+import warnings
+from typing import List, Tuple, Optional, Dict, Any, Generator
+from streamlit.testing.v1 import AppTest
+from contextlib import contextmanager
+from mito_ai.streamlit_conversion.streamlit_utils import resolve_notebook_path
+
+
+# warnings.filterwarnings("ignore", message=r".*missing ScriptRunContext.*")
+# warnings.filterwarnings("ignore", category=UserWarning)
+
+warnings.filterwarnings("ignore", message=".*bare mode.*")
+
+
+class StreamlitValidator:
+    def __init__(self, port: int = 8501) -> None:
+        self.temp_dir: Optional[str] = None
+
+    def get_syntax_error(self, app_code: str) -> Optional[str]:
+        """Check if the Python code has valid syntax"""
+        try:
+            ast.parse(app_code)
+            return None
+        except SyntaxError as e:
+            error_msg = ''.join(traceback.format_exception(type(e), e, e.__traceback__))
+            return error_msg
+
+    def get_runtime_errors(self, app_code: str, app_path: str) -> Optional[List[Dict[str, Any]]]:
+        """Start the Streamlit app in a subprocess"""  
+        
+        directory = os.path.dirname(app_path)
+        
+        @contextmanager
+        def change_working_directory(path: str) -> Generator[None, Any, None]:
+            """
+            Context manager to temporarily change working directory
+            so that relative paths are still valid when we run the app
+            """
+            if path == '':
+                yield
+            
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(path)
+                yield
+            finally:
+                os.chdir(original_cwd)
+        
+        with change_working_directory(directory):
+            app_test = AppTest.from_string(app_code, default_timeout=30)
+            app_test.run()
+            
+            # Check for exceptions
+            if app_test.exception:
+                errors = [{'type': 'exception', 'details': exc.value, 'message': exc.message, 'stack_trace': exc.stack_trace} for exc in app_test.exception]
+                return errors
+                    
+            # Check for error messages
+            if app_test.error:
+                errors = [{'type': 'error', 'details': err.value} for err in app_test.error]
+                return errors
+            
+            return None
+
+    def cleanup(self) -> None:
+        """Clean up the temporary files"""
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+            self.temp_dir = None
+
+    def _validate_app(self, app_code: str, app_path: str) -> List[Dict[str, Any]]:
+        """Complete validation pipeline"""
+        errors: List[Dict[str, Any]] = []
+
+        try:
+            # Step 1: Check syntax
+            syntax_error = self.get_syntax_error(app_code)
+            if syntax_error:
+                errors.append({'type': 'syntax', 'details': syntax_error})
+
+            runtime_errors = self.get_runtime_errors(app_code, app_path)
+            
+            print('Found Runtime Errors', runtime_errors)
+            
+            if runtime_errors:
+                errors.extend(runtime_errors)
+            
+        except Exception as e:
+            errors.append({'type': 'validation', 'details': str(e)})
+
+        finally:
+            self.cleanup()
+
+        return errors
+
+def validate_app(app_code: str, notebook_path: str) -> Tuple[bool, List[str]]:
+    """Convenience function to validate Streamlit code"""
+    notebook_path = resolve_notebook_path(notebook_path)
+    
+    validator = StreamlitValidator()
+    errors = validator._validate_app(app_code, notebook_path)
+    
+    has_validation_error = len(errors) > 0
+    stringified_errors = [str(error) for error in errors]
+    return has_validation_error, stringified_errors

mito_ai/streamlit_preview/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from .manager import get_preview_manager
+from .handlers import StreamlitPreviewHandler
+
+__all__ = ['get_preview_manager', 'StreamlitPreviewHandler']