mito-ai 0.1.45__py3-none-any.whl → 0.1.47__py3-none-any.whl

mito_ai/streamlit_conversion/streamlit_agent_handler.py

@@ -1,161 +1,145 @@
 # Copyright (c) Saga Inc.
 # 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, Optional, Tuple, cast
-
-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.agent_utils import extract_todo_placeholders, get_response_from_agent
 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.prompts.update_existing_app_prompt import get_update_existing_app_prompt
 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.streamlit_conversion.streamlit_utils import extract_code_blocks, create_app_file, get_app_code_from_file, parse_jupyter_notebook_to_extract_required_content
+from mito_ai.streamlit_conversion.search_replace_utils import extract_search_replace_blocks, apply_search_replace
 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:
-    @property
-    def log(self) -> logging.Logger:
-        """Use Mito AI logger."""
-        return get_logger()
-
-    async def get_response_from_agent(self, message_to_agent: List[MessageParam]) -> str:
-        """Gets the streaming response from the agent using the mito server"""
-        model = STREAMLIT_AI_MODEL
-        max_tokens = 8192 # 64_000
-        temperature = 0.2
-
-        self.log.info("Getting response from agent...")
-        accumulated_response = ""
-        async for stream_chunk in stream_anthropic_completion_from_mito_server(
-            model = model,
-            max_tokens = max_tokens,
-            temperature = temperature,
-            system = streamlit_system_prompt,
-            messages = message_to_agent,
-            stream=True,
-            message_type=MessageType.STREAMLIT_CONVERSION,
-            reply_fn=None,
-            message_id=""
-        ):
-            accumulated_response += stream_chunk
-        return accumulated_response
+from mito_ai.utils.error_classes import StreamlitConversionError
+from mito_ai.utils.telemetry_utils import log_streamlit_app_validation_retry, log_streamlit_app_conversion_success
+from mito_ai.path_utils import AbsoluteNotebookPath, get_absolute_notebook_dir_path, get_absolute_app_path
 
-    async def generate_streamlit_code(self, notebook: dict) -> str:
-        """Send a query to the agent, get its response and parse the code"""
-        
-        prompt_text = get_streamlit_app_creation_prompt(notebook)
-        
-        messages: List[MessageParam] = [
+async def generate_new_streamlit_code(notebook: List[dict]) -> str:
+    """Send a query to the agent, get its response and parse the code"""
+    
+    prompt_text = get_streamlit_app_creation_prompt(notebook)
+    
+    messages: List[MessageParam] = [
+        cast(MessageParam, {
+            "role": "user",
+            "content": [{
+                "type": "text",
+                "text": prompt_text
+            }]
+        })
+    ]
+    agent_response = await get_response_from_agent(messages)
+    converted_code = extract_code_blocks(agent_response)
+    
+    # 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": prompt_text
+                    "text": todo_prompt
                 }]
             })
         ]
+        todo_response = await get_response_from_agent(todo_messages)
         
-        agent_response = await self.get_response_from_agent(messages)
-        converted_code = extract_code_blocks(agent_response)
-        
-        # 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
+        # Apply the search/replace to the streamlit app
+        search_replace_pairs = extract_search_replace_blocks(todo_response)
+        converted_code = apply_search_replace(converted_code, search_replace_pairs)
+                
+    return converted_code
 
 
-    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"""
-        messages: List[MessageParam] = [
-            cast(MessageParam, {
-                "role": "user",
-                "content": [{
-                    "type": "text",
-                    "text": get_streamlit_error_correction_prompt(error, streamlit_app_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 streamlit_app_code
+async def update_existing_streamlit_code(notebook: List[dict], streamlit_app_code: str, edit_prompt: str) -> str:
+    """Send a query to the agent, get its response and parse the code"""
+    prompt_text = get_update_existing_app_prompt(notebook, streamlit_app_code, edit_prompt)
+    
+    messages: List[MessageParam] = [
+        cast(MessageParam, {
+            "role": "user",
+            "content": [{
+                "type": "text",
+                "text": prompt_text
+            }]
+        })
+    ]
+    
+    agent_response = await get_response_from_agent(messages)
+    print(f"[Mito AI Search/Replace Tool]:\n {agent_response}")
+
+    # Apply the search/replace to the streamlit app
+    search_replace_pairs = extract_search_replace_blocks(agent_response)
+    converted_code = apply_search_replace(streamlit_app_code, search_replace_pairs)
+    print(f"[Mito AI Search/Replace Tool]\nConverted code\n: {converted_code}")
+    return converted_code
+
+
+async def correct_error_in_generation(error: str, streamlit_app_code: str) -> str:
+    """If errors are present, send it back to the agent to get corrections in code"""
+    messages: List[MessageParam] = [
+        cast(MessageParam, {
+            "role": "user",
+            "content": [{
+                "type": "text",
+                "text": get_streamlit_error_correction_prompt(error, streamlit_app_code)
+            }]
+        })
+    ]
+    agent_response = await get_response_from_agent(messages)
+    
+    # Apply the search/replace to the streamlit app
+    search_replace_pairs = extract_search_replace_blocks(agent_response)
+    streamlit_app_code = apply_search_replace(streamlit_app_code, search_replace_pairs)
 
+    return streamlit_app_code
 
-async def streamlit_handler(notebook_path: str) -> Tuple[bool, Optional[str], str]:
+async def streamlit_handler(notebook_path: AbsoluteNotebookPath, edit_prompt: str = "") -> None:
     """Handler function for streamlit code generation and validation"""
 
-    clean_directory_check(notebook_path)
-
+    # Convert to absolute path for consistent handling
     notebook_code = parse_jupyter_notebook_to_extract_required_content(notebook_path)
-    streamlit_code_generator = StreamlitCodeGeneration()
-
-    streamlit_code = await streamlit_code_generator.generate_streamlit_code(notebook_code)
+    app_directory = get_absolute_notebook_dir_path(notebook_path)
+    app_path = get_absolute_app_path(app_directory)
     
+    if edit_prompt != "":
+        # If the user is editing an existing streamlit app, use the update function
+        streamlit_code = get_app_code_from_file(app_path)
+        
+        if streamlit_code is None:
+            raise StreamlitConversionError("Error updating existing streamlit app because app.py file was not found.", 404)
+        
+        streamlit_code = await update_existing_streamlit_code(notebook_code, streamlit_code, edit_prompt)
+    else:
+        # Otherwise generate a new streamlit app
+        streamlit_code = await generate_new_streamlit_code(notebook_code)
+       
+    # Then, after creating/updating the app, validate that the new code runs 
     has_validation_error, errors = validate_app(streamlit_code, notebook_path)
     tries = 0
     while has_validation_error and tries < 5:
         for error in errors:
-            streamlit_code = await streamlit_code_generator.correct_error_in_generation(error, streamlit_code)
+            streamlit_code = await 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)
+            log_streamlit_app_validation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, errors)
         tries+=1
 
     if has_validation_error:
-        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)
+        final_errors = ', '.join(errors)
+        raise StreamlitConversionError(f"Streamlit agent failed generating code after max retries. Errors: {final_errors}", 500)
     
-    log_streamlit_app_creation_success('mito_server_key', MessageType.STREAMLIT_CONVERSION)
-    return success_flag, app_path, message
+    # Finally, update the app.py file with the new code
+    create_app_file(app_path, streamlit_code)
+    log_streamlit_app_conversion_success('mito_server_key', MessageType.STREAMLIT_CONVERSION, edit_prompt)

mito_ai/streamlit_conversion/streamlit_utils.py

@@ -3,9 +3,11 @@
 
 import re
 import json
-import os
-from typing import Dict, Optional, Tuple, Any
+from typing import Dict, List, Optional, Tuple, Any
+from mito_ai.path_utils import AbsoluteAppPath, AbsoluteNotebookPath
 from pathlib import Path
+from mito_ai.utils.error_classes import StreamlitConversionError
+
 
 def extract_code_blocks(message_content: str) -> str:
     """
@@ -28,19 +30,7 @@ def extract_code_blocks(message_content: str) -> str:
     result = '\n'.join(matches)
     return result
 
-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(app_directory: str, code: str) -> Tuple[bool, str, str]:
+def create_app_file(app_path: AbsoluteAppPath, code: str) -> None:
     """
     Create app.py file and write code to it with error handling
 
@@ -53,34 +43,21 @@ def create_app_file(app_directory: str, code: str) -> Tuple[bool, str, str]:
 
     """
     try:
-        app_path = os.path.join(app_directory, "app.py")
-
         with open(app_path, 'w', encoding='utf-8') as f:
             f.write(code)
-        
-        return True, app_path, f"Successfully created {app_directory}"
     except IOError as e:
-        return False, '', f"Error creating file: {str(e)}"
-    except Exception as e:
-        return False, '', f"Unexpected error: {str(e)}"
+        raise StreamlitConversionError(f"Error creating app file: {str(e)}", 500)
     
+def get_app_code_from_file(app_path: AbsoluteAppPath) -> Optional[str]:
+    with open(app_path, 'r', encoding='utf-8') as f:
+        return f.read()
 
-def get_app_path(app_directory: str) -> Optional[str]:
-    """
-    Check if the app.py file exists in the given directory.
-    """
-    app_path = os.path.join(app_directory, "app.py")
-    if not os.path.exists(app_path):
-        return None
-    return app_path
-    
-
-def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Dict[str, Any]:
+def parse_jupyter_notebook_to_extract_required_content(notebook_path: AbsoluteNotebookPath) -> List[Dict[str, Any]]:
     """
     Read a Jupyter notebook and filter cells to keep only cell_type and source fields.
 
     Args:
-        notebook_path (str): Path to the .ipynb file (can be relative or absolute)
+        notebook_path: Absolute path to the .ipynb file
 
     Returns:
         dict: Filtered notebook dictionary with only cell_type and source in cells
@@ -90,10 +67,6 @@ 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
@@ -102,43 +75,20 @@ def parse_jupyter_notebook_to_extract_required_content(notebook_path: str) -> Di
 
         # Check if 'cells' key exists
         if 'cells' not in notebook_data:
-            raise KeyError("Notebook does not contain 'cells' key")
+            raise StreamlitConversionError("Notebook does not contain 'cells' key", 400)
 
         # Filter each cell to keep only cell_type and source
-        filtered_cells = []
+        filtered_cells: List[Dict[str, Any]] = []
         for cell in notebook_data['cells']:
-            filtered_cell = {
+            filtered_cell: Dict[str, Any] = {
                 'cell_type': cell.get('cell_type', ''),
                 'source': cell.get('source', [])
             }
             filtered_cells.append(filtered_cell)
-
-        # Update the notebook data with filtered cells
-        notebook_data['cells'] = filtered_cells
-
-        return notebook_data
+            
+        return filtered_cells
 
     except FileNotFoundError:
-        raise FileNotFoundError(f"Notebook file not found: {notebook_path}")
+        raise StreamlitConversionError(f"Notebook file not found: {notebook_path}", 404)
     except json.JSONDecodeError as e:
-        # JSONDecodeError requires msg, doc, pos
-        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}")
+        raise StreamlitConversionError(f"Invalid JSON in notebook file: {str(e)}", 400)

mito_ai/streamlit_conversion/validate_streamlit_app.py

@@ -1,124 +1,106 @@
 # 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)
+from mito_ai.path_utils import AbsoluteNotebookPath, get_absolute_notebook_dir_path
 
 warnings.filterwarnings("ignore", message=".*bare mode.*")
 
+def get_syntax_error(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
 
-class StreamlitValidator:
-    def __init__(self, port: int = 8501) -> None:
-        pass
-
-    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)
+def get_runtime_errors(app_code: str, app_path: AbsoluteNotebookPath) -> Optional[List[Dict[str, Any]]]:
+    """Start the Streamlit app in a subprocess"""  
+    
+    directory = get_absolute_notebook_dir_path(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
         
-        with change_working_directory(directory):
-            # Create a temporary file that uses UTF-8 encoding so 
-            # we don't run into issues with non-ASCII characters on Windows.
-            # We use utf-8 encoding when writing the app.py file so this validation
-            # code mirrors the actual file. 
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(path)
+            yield
+        finally:
+            os.chdir(original_cwd)
+    
+    with change_working_directory(directory):
+        # Create a temporary file that uses UTF-8 encoding so 
+        # we don't run into issues with non-ASCII characters on Windows.
+        # We use utf-8 encoding when writing the app.py file so this validation
+        # code mirrors the actual file. 
 
-            # Note: Since the AppTest.from_file tries to open the file, we need to first close the file
-            # by exiting the context manager and using the delete=False flag so that the file still exists.
-            # Windows can't open the same file twice at the same time. We cleanup at the end.
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as f:
-                f.write(app_code)
-                temp_path = f.name
+        # Note: Since the AppTest.from_file tries to open the file, we need to first close the file
+        # by exiting the context manager and using the delete=False flag so that the file still exists.
+        # Windows can't open the same file twice at the same time. We cleanup at the end.
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as f:
+            f.write(app_code)
+            temp_path = f.name
 
+        try:
+            # Run Streamlit test from file with UTF-8 encoding
+            app_test = AppTest.from_file(temp_path, 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
+        finally:
+            # Clean up the temporary file
             try:
-                # Run Streamlit test from file with UTF-8 encoding
-                app_test = AppTest.from_file(temp_path, 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
-            finally:
-                # Clean up the temporary file
-                try:
-                    os.unlink(temp_path)
-                except OSError:
-                    pass  # File might already be deleted
+                os.unlink(temp_path)
+            except OSError:
+                pass  # File might already be deleted
 
-    def _validate_app(self, app_code: str, app_path: str) -> List[Dict[str, Any]]:
-        """Complete validation pipeline"""
-        errors: List[Dict[str, Any]] = []
+def check_for_errors(app_code: str, app_path: AbsoluteNotebookPath) -> 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})
+    try:
+        # Step 1: Check syntax
+        syntax_error = 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)
-            
-            if runtime_errors:
-                errors.extend(runtime_errors)
-            
-        except Exception as e:
-            errors.append({'type': 'validation', 'details': str(e)})
+        runtime_errors = get_runtime_errors(app_code, app_path)
+        if runtime_errors:
+            errors.extend(runtime_errors)
+        
+    except Exception as e:
+        errors.append({'type': 'validation', 'details': str(e)})
 
-        return errors
+    return errors
 
-def validate_app(app_code: str, notebook_path: str) -> Tuple[bool, List[str]]:
+def validate_app(app_code: str, notebook_path: AbsoluteNotebookPath) -> 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)
+    errors = check_for_errors(app_code, notebook_path)
     
     has_validation_error = len(errors) > 0
     stringified_errors = [str(error) for error in errors]