mito-ai 0.1.33__py3-none-any.whl → 0.1.49__py3-none-any.whl

mito_ai/log/handlers.py

@@ -3,16 +3,22 @@
 
 from dataclasses import dataclass
 import json
-from typing import Any, Final
+from typing import Any, Final, Literal
 import tornado
 import os
 from jupyter_server.base.handlers import APIHandler
-from mito_ai.utils.telemetry_utils import log
+from mito_ai.utils.telemetry_utils import MITO_SERVER_KEY, USER_KEY, log
 
 
 class LogHandler(APIHandler):
     """Handler for logging"""
     
+    def initialize(self, key_type: Literal['mito_server_key', 'user_key']) -> None:
+        """Initialize the log handler"""
+        
+        # The key_type is required so that we know if we can log pro users
+        self.key_type = key_type
+        
     @tornado.web.authenticated
     def put(self) -> None:
         """Log an event"""
@@ -26,6 +32,7 @@ class LogHandler(APIHandler):
         log_event = data['log_event']
         params = data.get('params', {})
         
-        log(log_event, params)
+        key_type = MITO_SERVER_KEY if self.key_type == "mito_server_key" else USER_KEY
+        log(log_event, params, key_type=key_type)
 
 

mito_ai/log/urls.py

@@ -5,7 +5,7 @@ from typing import Any, List, Tuple
 from jupyter_server.utils import url_path_join
 from mito_ai.log.handlers import LogHandler
 
-def get_log_urls(base_url: str) -> List[Tuple[str, Any, dict]]:
+def get_log_urls(base_url: str, key_type: str) -> List[Tuple[str, Any, dict]]:
     """Get all log related URL patterns.
 
     Args:
@@ -15,7 +15,7 @@ def get_log_urls(base_url: str) -> List[Tuple[str, Any, dict]]:
         List of (url_pattern, handler_class, handler_kwargs) tuples
     """
     BASE_URL = base_url + "/mito-ai"
-    
+        
     return [
-        (url_path_join(BASE_URL, "log"), LogHandler, {}),
+        (url_path_join(BASE_URL, "log"), LogHandler, {"key_type": key_type}),
     ]

mito_ai/openai_client.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 from typing import Any, AsyncGenerator, Callable, Dict, List, Optional, Union
 
+from mito_ai.utils.mito_server_utils import ProviderCompletionException
 import openai
 from openai.types.chat import ChatCompletionMessageParam
 from traitlets import Instance, Unicode, default, validate
@@ -36,8 +37,6 @@ from mito_ai.utils.telemetry_utils import (
 
 OPENAI_MODEL_FALLBACK = "gpt-4.1"
 
-OPENAI_FAST_MODEL = "gpt-4.1-nano"
-
 class OpenAIClient(LoggingConfigurable):
     """Provide AI feature through OpenAI services."""
 
@@ -222,26 +221,20 @@ This attribute is observed by the websocket provider to push the error to the cl
         )
         return client
 
-    def _resolve_model(self, model: Optional[str] = None, response_format_info: Optional[ResponseFormatInfo] = None) -> str:
+    def _adjust_model_for_azure_or_ollama(self, model: str) -> str:
         
         # If they have set an Azure OpenAI model, then we always use it
         if is_azure_openai_configured() and constants.AZURE_OPENAI_MODEL is not None:
             self.log.debug(f"Resolving to Azure OpenAI model: {constants.AZURE_OPENAI_MODEL}")
             return constants.AZURE_OPENAI_MODEL
         
-        # Otherwise, we use the fast model for anything other than the agent mode
-        if response_format_info:
-            return OPENAI_FAST_MODEL
-        
         # If they have set an Ollama model, then we use it
         if constants.OLLAMA_MODEL is not None:
             return constants.OLLAMA_MODEL
         
-        # If they have set a model, then we use it
-        if model:
-            return model
+        # Otherwise, we use the model they provided
+        return model
         
-        return OPENAI_MODEL_FALLBACK
 
     async def request_completions(
             self,
@@ -263,39 +256,33 @@ This attribute is observed by the websocket provider to push the error to the cl
         # Reset the last error
         self.last_error = None
         completion = None
+        
+        # Note: We don't catch exceptions here because we want them to bubble up 
+        # to the providers file so we can handle all client exceptions in one place.
 
-        try:
-            
-            # Make sure we are using the correct model
-            # TODO: If we bring back inline completions or another action that needs to 
-            # respond fast, we must require the user to configure a fast model with Azure as well. 
-            model = self._resolve_model(model, response_format_info)
-
-            # Handle other providers as before
-            completion_function_params = get_open_ai_completion_function_params(
-                model, messages, False, response_format_info
+        # Handle other providers as before
+        completion_function_params = get_open_ai_completion_function_params(
+            message_type, model, messages, False, response_format_info
+        )
+        
+        # If they have set an Azure OpenAI or Ollama model, then we use it
+        completion_function_params["model"] = self._adjust_model_for_azure_or_ollama(completion_function_params["model"])
+
+        if self._active_async_client is not None:
+            response = await self._active_async_client.chat.completions.create(**completion_function_params)
+            completion = response.choices[0].message.content or ""
+        else: 
+            last_message_content = str(messages[-1].get("content", "")) if messages else None
+            completion = await get_ai_completion_from_mito_server(
+                last_message_content,
+                completion_function_params,
+                self.timeout,
+                self.max_retries,
+                message_type,
             )
 
-            if self._active_async_client is not None:
-                response = await self._active_async_client.chat.completions.create(**completion_function_params)
-                completion = response.choices[0].message.content or ""
-            else: 
-                last_message_content = str(messages[-1].get("content", "")) if messages else None
-                completion = await get_ai_completion_from_mito_server(
-                    last_message_content,
-                    completion_function_params,
-                    self.timeout,
-                    self.max_retries,
-                    message_type,
-                )
-
-                update_mito_server_quota(message_type)
+        return completion
 
-            return completion
-                
-        except BaseException as e:
-            self.last_error = CompletionError.from_exception(e)
-            raise
     
     async def stream_completions(
         self,
@@ -315,9 +302,6 @@ This attribute is observed by the websocket provider to push the error to the cl
         # Reset the last error
         self.last_error = None
         accumulated_response = ""
-        
-        # Validate that the model is supported.
-        model = self._resolve_model(model, response_format_info)
             
         # Send initial acknowledgment
         reply_fn(CompletionReply(
@@ -329,8 +313,10 @@ This attribute is observed by the websocket provider to push the error to the cl
 
         # Handle other providers as before
         completion_function_params = get_open_ai_completion_function_params(
-            model, messages, True, response_format_info
+            message_type, model, messages, True, response_format_info
         )
+        
+        completion_function_params["model"] = self._adjust_model_for_azure_or_ollama(completion_function_params["model"])
 
         try:
             if self._active_async_client is not None:

mito_ai/path_utils.py

@@ -0,0 +1,70 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import NewType
+import os
+from mito_ai.utils.error_classes import StreamlitPreviewError
+
+# Type definitions for better type safety
+AbsoluteNotebookPath = NewType('AbsoluteNotebookPath', str)
+AbsoluteNotebookDirPath = NewType('AbsoluteNotebookDirPath', str)
+AbsoluteAppPath = NewType('AbsoluteAppPath', str)
+AppFileName = NewType("AppFileName", str)
+
+def get_absolute_notebook_path(notebook_path: str) -> AbsoluteNotebookPath:
+    """
+    Convert any notebook path to an absolute path.
+    
+    Args:
+        notebook_path: Path to the notebook (can be relative or absolute)
+        
+    Returns:
+        AbsoluteNotebookPath: The absolute path to the notebook
+        
+    Raises:
+        ValueError: If the path is invalid or empty
+    """
+    if not notebook_path or not notebook_path.strip():
+        raise StreamlitPreviewError("Notebook path cannot be empty", 400)
+    
+    absolute_path = os.path.abspath(notebook_path)
+    return AbsoluteNotebookPath(absolute_path)
+    
+
+def get_absolute_notebook_dir_path(notebook_path: AbsoluteNotebookPath) -> AbsoluteNotebookDirPath:
+    """
+    Get the absolute directory containing the notebook.
+    """
+    return AbsoluteNotebookDirPath(os.path.dirname(notebook_path))
+
+def get_absolute_app_path(app_directory: AbsoluteNotebookDirPath, app_file_name: AppFileName) -> AbsoluteAppPath:
+    """
+    Get the absolute path to the app
+    """
+    return AbsoluteAppPath(os.path.join(app_directory, app_file_name))
+
+def get_app_file_name(notebook_id: str) -> AppFileName:
+    """
+    Converts the notebook id into the corresponding app id
+    """
+    mito_app_name = notebook_id.replace('mito-notebook-', 'mito-app-')
+    return AppFileName(f'{mito_app_name}.py')
+
+def does_app_path_exist(app_path: AbsoluteAppPath) -> bool:
+    """
+    Check if the app file exists
+    """
+    return os.path.exists(app_path)
+
+def does_notebook_id_have_corresponding_app(notebook_id: str, notebook_path: str) -> bool:
+    """
+    Given a notebook_id and raw notebook_path checks if the notebook has a corresponding
+    app by converting the notebook_path into an absolute path and converting the notebook_id
+    into an app name
+    """
+
+    app_file_name = get_app_file_name(notebook_id)
+    notebook_path = get_absolute_notebook_path(notebook_path)
+    app_directory = get_absolute_notebook_dir_path(notebook_path)
+    app_path = get_absolute_app_path(app_directory, app_file_name)
+    return does_app_path_exist(app_path)

mito_ai/streamlit_conversion/agent_utils.py

@@ -0,0 +1,37 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import List, Tuple
+import re
+from anthropic.types import MessageParam
+from mito_ai.streamlit_conversion.prompts.streamlit_system_prompt import streamlit_system_prompt
+from mito_ai.utils.anthropic_utils import stream_anthropic_completion_from_mito_server
+from mito_ai.streamlit_conversion.prompts.prompt_constants import MITO_TODO_PLACEHOLDER
+from mito_ai.completions.models import MessageType
+
+STREAMLIT_AI_MODEL = "claude-sonnet-4-5-20250929"
+
+def extract_todo_placeholders(agent_response: str) -> List[str]:
+    """Extract TODO placeholders from the agent's response"""
+    return [line.strip() for line in agent_response.split('\n') if MITO_TODO_PLACEHOLDER in line]
+
+async def get_response_from_agent(message_to_agent: List[MessageParam]) -> str:
+    """Gets the streaming response from the agent using the mito server"""
+    model = STREAMLIT_AI_MODEL
+    max_tokens = 64000 # TODO: If we move to haiku, we must reset this to 8192
+    temperature = 0.2
+
+    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

mito_ai/streamlit_conversion/prompts/prompt_constants.py

@@ -0,0 +1,172 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+MITO_TODO_PLACEHOLDER = "# MITO_TODO_PLACEHOLDER"
+
+search_replace_instructions = f"""
+RESPONSE FORMAT: You can edit the existing code using the **SEARCH_REPLACE format** for exact string matching and replacement.
+
+**STRUCTURE:**
+```search_replace
+>>>>>>> SEARCH
+[exact code currently in the file]
+=======
+[new code to replace it with]
+<<<<<<< REPLACE
+```
+
+**COMPONENTS:**
+```search_replace - This is the start of the search/replace block
+- `>>>>>>> SEARCH` - Exact text that EXISTS NOW in the file (7 chevrons)
+- `=======` - Separator between the search and replace blocks (7 equals signs)  
+- `<<<<<<< REPLACE` - Replacement text (7 chevrons)
+
+---
+
+**CRITICAL RULES - READ CAREFULLY:**
+
+1. **SEARCH = CURRENT STATE ONLY**
+   - The SEARCH block must contain ONLY code that currently exists in the file
+   - NEVER include new code, future code, or code you wish existed in the SEARCH block
+   - Copy exact text from the current file, character-for-character
+   
+2. **EXACT MATCHING REQUIRED**
+   - Every space, tab, newline must match perfectly
+   - Preserve exact indentation (spaces vs tabs)
+   - Include trailing newlines if present
+   - No approximations - even one character difference will fail
+
+3. **SIZE LIMITS**
+   - There are no size limits to each search/replace block, however, it is generally preferable to keep the SEARCH blocks small and focused on one change. 
+   - For large changes, use multiple smaller search/replace blocks
+
+4. **UNIQUENESS**
+   - Include enough context to make the SEARCH block unique
+   - If text appears multiple times, add surrounding lines
+   - Ensure there's only ONE match in the file
+
+5. **VERIFICATION CHECKLIST** (before generating each block):
+   ✓ Is every line in my SEARCH block currently in the file?
+   ✓ Did I copy the exact spacing and whitespace?
+   ✓ Will this match exactly once?
+   
+6. **SEARCH REPLACE BLOCK STRUCTURE**
+   - You must adhere to to the exact search_replace structure as shown in the examples.
+
+---
+
+**MULTIPLE REPLACEMENTS:**
+- You can include multiple search/replace blocks in one response
+- Each block is independent and processed separately
+- Use separate ```search_replace blocks for each change
+
+<Example 1: Updating existing content>
+
+```search_replace
+>>>>>>> SEARCH
+st.title("Old Title")
+=======
+st.title("New Title")
+<<<<<<< REPLACE
+```
+</Example 1>
+
+<Example 2: Adding new content>
+
+```search_replace
+>>>>>>> SEARCH
+st.title("My App")
+=======
+st.title("My App")
+st.header("Welcome")
+st.write("This is a test app")
+<<<<<<< REPLACE
+```
+</Example 2>
+
+<Example 3: Deleting existing content>
+
+```search_replace
+>>>>>>> SEARCH
+st.write("Old message")
+=======
+<<<<<<< REPLACE
+```
+</Example 3>
+
+<Example 4: Multiple replacements in one response>
+
+```search_replace
+>>>>>>> SEARCH
+st.title("Old Title")
+=======
+st.title("New Title")
+<<<<<<< REPLACE
+```
+
+```search_replace
+>>>>>>> SEARCH
+st.write("Old message")
+=======
+st.write("New message")
+<<<<<<< REPLACE
+```
+</Example 4>
+
+<Example 5: Using extra context to identify the correct code to replace>
+
+In the below example, assume that the code st.write("Old message") appears multiple times in the file, so we use extra context lines to identify the correct code to replace.
+
+```search_replace
+>>>>>>> SEARCH
+# This is a unique comment
+st.write("Old message")
+=======
+# This is a unique comment
+st.write("New message")
+<<<<<<< REPLACE
+```
+</Example 5>
+
+<Example 6: Search/replace while respecting whitespace and indentation>
+
+```search_replace
+>>>>>>> SEARCH
+data_list = [
+    {{'id': 1, 'name': 'Item A'}},
+    {MITO_TODO_PLACEHOLDER}: Add remaining entries from notebook
+]
+=======
+data_list = [
+    {{'id': 1, 'name': 'Item A'}},
+    {{'id': 2, 'name': 'Item B'}},
+    {{'id': 3, 'name': 'Item C'}},
+    {{'id': 4, 'name': 'Item D'}}
+]
+<<<<<<< REPLACE
+```
+</Example 6>
+
+<Example 7: Tab structure changes>
+
+```search_replace
+>>>>>>> SEARCH
+tab1, tab2 = st.tabs(["Cat", "Dog"])
+
+with tab1:
+    st.header("A cat")
+    st.image("https://static.streamlit.io/examples/cat.jpg", width=200)
+with tab2:
+    st.header("A dog")
+    st.image("https://static.streamlit.io/examples/dog.jpg", width=200)
+=======
+st.header("A cat")
+st.image("https://static.streamlit.io/examples/cat.jpg", width=200)
+st.header("A dog")
+st.image("https://static.streamlit.io/examples/dog.jpg", width=200)
+<<<<<<< REPLACE
+```
+</Example 7>
+
+Your response must consist **only** of valid search_replace blocks.
+"""

mito_ai/streamlit_conversion/prompts/prompt_utils.py

@@ -0,0 +1,10 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+def add_line_numbers_to_code(code: str) -> str:
+    """Add line numbers to the code"""
+    code_with_line_numbers = ""
+    for i, line in enumerate(code.split('\n'), 1):
+        code_with_line_numbers += f"{i:3d}: {line}\n"
+        
+    return code_with_line_numbers

mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py

@@ -0,0 +1,46 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+from typing import List
+from mito_ai.streamlit_conversion.prompts.prompt_constants import MITO_TODO_PLACEHOLDER
+
+def get_streamlit_app_creation_prompt(notebook: List[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 search_replace_instructions
+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.
+
+{search_replace_instructions}
+
+===============================================
+
+EXISTING STREAMLIT APP:
+{existing_streamlit_app_code_with_line_numbers}
+
+===============================================
+
+Please create a search/replace block that corrects this error. Please keep your fix concise:
+{error}
+
+"""
+

mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_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 typing import List
+from mito_ai.streamlit_conversion.prompts.prompt_constants import MITO_TODO_PLACEHOLDER, search_replace_instructions
+from mito_ai.streamlit_conversion.prompts.prompt_utils import add_line_numbers_to_code
+
+def get_finish_todo_prompt(notebook: List[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.
+
+{search_replace_instructions}
+
+===============================================
+
+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/prompts/streamlit_system_prompt.py

@@ -0,0 +1,56 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+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
+- Experienced in creating executive-ready dashboards for business stakeholders
+- Skilled in translating technical analysis into clear, interactive presentations
+
+TASK REQUIREMENTS:
+1. Convert Jupyter notebook content into a complete Streamlit application (app.py)
+2. Preserve ALL outputs from code cells and markdown cells as they appear in the notebook
+3. Maintain the logical flow and structure of the original analysis
+4. Create an executive-friendly dashboard suitable for company leadership
+
+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
+- Just create the streamlit app code, do not include a _main_ function block. The file will be run directly using `streamlit run app.py`.
+
+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:
+- Output the complete, runnable app.py file.
+- Do not output any extra text, just give the python code. 
+
+"""