From 79fe29e1b0c97dbf74eb863e9ebfe8ecd28473d4 Mon Sep 17 00:00:00 2001 From: Aaron Diamond-Reivich Date: Mon, 8 Dec 2025 13:12:37 -0500 Subject: [PATCH 1/4] Implement Vizro dashboard generation POC MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Convert Mito's code generation system from Streamlit to Vizro. Updated prompts to generate Vizro dashboard applications instead of Streamlit apps, disabled validation for the POC, and modified the preview manager to launch Vizro apps on dynamically allocated ports. Added vizro as a project dependency. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../prompts/streamlit_app_creation_prompt.py | 10 +-- .../streamlit_error_correction_prompt.py | 8 +- .../prompts/streamlit_finish_todo_prompt.py | 12 +-- .../prompts/streamlit_system_prompt.py | 85 ++++++++++++------- .../prompts/update_existing_app_prompt.py | 14 +-- .../streamlit_agent_handler.py | 34 ++++---- mito-ai/mito_ai/streamlit_preview/manager.py | 59 +++++++------ mito-ai/pyproject.toml | 1 + 8 files changed, 130 insertions(+), 93 deletions(-) diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py index 5c41b9e2b..07898dbca 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_app_creation_prompt.py @@ -6,14 +6,14 @@ def get_streamlit_app_creation_prompt(notebook: List[dict]) -> str: """ - This prompt is used to create a streamlit app from a notebook. + This prompt is used to create a vizro app from a notebook. """ - return f"""Convert the following Jupyter notebook into a Streamlit application. + return f"""Convert the following Jupyter notebook into a Vizro dashboard application. -GOAL: Create a complete, runnable Streamlit app that accurately represents the notebook. It must completely convert the notebook. +GOAL: Create a complete, runnable Vizro 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: +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 @@ -43,4 +43,4 @@ def get_streamlit_app_creation_prompt(notebook: List[dict]) -> str: Notebook to convert: {notebook} -""" \ No newline at end of file +""" diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_error_correction_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_error_correction_prompt.py index 6a8eebc3c..312025df8 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_error_correction_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_error_correction_prompt.py @@ -5,10 +5,10 @@ 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. + + return f"""You've created a Vizro dashboard 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. @@ -16,7 +16,7 @@ def get_streamlit_error_correction_prompt(error: str, streamlit_app_code: str) - =============================================== -EXISTING STREAMLIT APP: +EXISTING VIZRO APP: {existing_streamlit_app_code_with_line_numbers} =============================================== diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_prompt.py index 753e4c84e..89ae89900 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_finish_todo_prompt.py @@ -6,10 +6,10 @@ 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}`. + + return f"""You've already created the first draft of a Vizro dashboard 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. @@ -29,12 +29,12 @@ def get_finish_todo_prompt(notebook: List[dict], existing_streamlit_app_code: st =============================================== -Input Notebook that you are converting into the Streamlit app: +Input Notebook that you are converting into the Vizro dashboard: {notebook} =============================================== -EXISTING STREAMLIT APP: +EXISTING VIZRO APP: {existing_streamlit_app_code_with_line_numbers} =============================================== @@ -42,4 +42,4 @@ def get_finish_todo_prompt(notebook: List[dict], existing_streamlit_app_code: st 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} -""" \ No newline at end of file +""" diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py index bdf14fe9e..22cb5c835 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py @@ -1,56 +1,81 @@ # 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. +streamlit_system_prompt = """You are a code conversion specialist who converts Jupyter notebooks into Vizro dashboard applications with ABSOLUTE FIDELITY. ROLE AND EXPERTISE: -- Expert in Python, Jupyter notebooks, Streamlit, and data visualization +- Expert in Python, Jupyter notebooks, Vizro, 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) +1. Convert Jupyter notebook content into a complete Vizro dashboard 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.) +VIZRO IMPLEMENTATION GUIDELINES: +- Use Vizro's declarative structure: vm.Page, vm.Dashboard, vm.Graph, vm.Table, vm.Card, etc. +- Import vizro.plotly.express as px for charts (scatter, histogram, line, bar, etc.) +- Display visualizations using vm.Graph(figure=px.chart_type(...)) +- Show dataframes and tables using vm.Table(figure=df) +- Include text content using vm.Card(text="...") +- Add interactive elements using vm.Filter() and vm.Parameter() where beneficial +- Do not convert database connections. 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 vizro app. - 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`. +- Structure the app as: load data → create page(s) with components → build dashboard → run + +VIZRO APP STRUCTURE: +```python +import vizro.plotly.express as px +from vizro import Vizro +import vizro.models as vm + +# Data loading and processing code here + +# Create page with components +page = vm.Page( + title="Dashboard Title", + components=[ + vm.Graph(figure=px.scatter(...)), + vm.Table(figure=df), + vm.Card(text="Insights and explanations") + ], + controls=[ + vm.Filter(column="category"), + ], +) + +# Build and run dashboard +dashboard = vm.Dashboard(pages=[page]) +Vizro().build(dashboard).run() +``` 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. +5. **PRESERVE DATA LOADING**: If the notebook reads from files, the Vizro 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 vizro dashboard. + +COMPONENT MAPPING: +- Code cells that generate plots → vm.Graph(figure=px.chart_type(...)) +- DataFrames → vm.Table(figure=df) +- Markdown cells with text → vm.Card(text="...") +- Variables that users might want to filter → vm.Filter(column="...") +- Maintain the order of outputs as they appear in the notebook -STYLE GUIDELINES: +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. +- If there are variables in the notebook that viewers would likely want to configure, use vm.Filter or vm.Parameter - 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(\"\"\" - -\"\"\", unsafe_allow_html=True) -``` +- Do not modify the graphs or analysis. If the notebook has a graph, use the same graph in the vizro app +- Always end with: Vizro().build(dashboard).run() OUTPUT FORMAT: -- Output the complete, runnable app.py file. -- Do not output any extra text, just give the python code. +- Output the complete, runnable app.py file +- Do not output any extra text, just give the python code +- The file will be run directly using Python (not streamlit run) -""" \ No newline at end of file +""" diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/update_existing_app_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/update_existing_app_prompt.py index d9875b0d5..e34c97bf4 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/update_existing_app_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/update_existing_app_prompt.py @@ -7,14 +7,14 @@ def get_update_existing_app_prompt(notebook: List[dict], streamlit_app_code: str, edit_prompt: str) -> str: """ - This prompt is used to update an existing streamlit app. + This prompt is used to update an existing vizro app. """ - + existing_streamlit_app_code_with_line_numbers = add_line_numbers_to_code(streamlit_app_code) - + return f""" -GOAL: You've previously created a first draft of the Streamlit app. Now the user reviewed it and provided feedback.Update the existing streamlit app according to the feedback provided by the user. Use the input notebook to help you understand what code needs to be added, changed, or modified to fulfill the user's edit request. +GOAL: You've previously created a first draft of the Vizro dashboard app. Now the user reviewed it and provided feedback. Update the existing vizro app according to the feedback provided by the user. Use the input notebook to help you understand what code needs to be added, changed, or modified to fulfill the user's edit request. **CRITICAL COMPLETION REQUIREMENT:** You have ONE and ONLY ONE opportunity to complete this edit request. 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. @@ -34,12 +34,12 @@ def get_update_existing_app_prompt(notebook: List[dict], streamlit_app_code: str =============================================== -INPUT NOTEBOOK: +INPUT NOTEBOOK: {notebook} =============================================== -EXISTING STREAMLIT APP: +EXISTING VIZRO APP: {existing_streamlit_app_code_with_line_numbers} =============================================== @@ -47,4 +47,4 @@ def get_update_existing_app_prompt(notebook: List[dict], streamlit_app_code: str USER EDIT REQUEST: {edit_prompt} -""" \ No newline at end of file +""" diff --git a/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py b/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py index ea365a696..eb8656898 100644 --- a/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py +++ b/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py @@ -120,24 +120,24 @@ async def streamlit_handler(notebook_path: AbsoluteNotebookPath, app_file_name: # 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 - errors = validate_app(streamlit_code, notebook_path) - tries = 0 - while len(errors)>0 and tries < 5: - for error in errors: - streamlit_code = await correct_error_in_generation(error, streamlit_code) - - errors = validate_app(streamlit_code, notebook_path) - - if len(errors)>0: - # 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_validation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, errors) - tries+=1 + # Validation disabled for Vizro POC + # errors = validate_app(streamlit_code, notebook_path) + # tries = 0 + # while len(errors)>0 and tries < 5: + # for error in errors: + # streamlit_code = await correct_error_in_generation(error, streamlit_code) + # + # errors = validate_app(streamlit_code, notebook_path) + # + # if len(errors)>0: + # # 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_validation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, errors) + # tries+=1 - if len(errors)>0: - final_errors = ', '.join(errors) - raise StreamlitConversionError(f"Streamlit agent failed generating code after max retries. Errors: {final_errors}", 500) + # if len(errors)>0: + # final_errors = ', '.join(errors) + # raise StreamlitConversionError(f"Streamlit agent failed generating code after max retries. Errors: {final_errors}", 500) # Finally, update the app.py file with the new code create_app_file(app_path, streamlit_code) diff --git a/mito-ai/mito_ai/streamlit_preview/manager.py b/mito-ai/mito_ai/streamlit_preview/manager.py index 58a3abc94..0d4b7e636 100644 --- a/mito-ai/mito_ai/streamlit_preview/manager.py +++ b/mito-ai/mito_ai/streamlit_preview/manager.py @@ -38,36 +38,47 @@ def get_free_port(self) -> int: return port def start_streamlit_preview(self, app_directory: AbsoluteNotebookDirPath, app_file_name: AppFileName, preview_id: str) -> int: - """Start a streamlit preview process. - + """Start a vizro preview process. + Args: - app_code: The streamlit app code to run + app_code: The vizro app code to run preview_id: Unique identifier for this preview - + Returns: Tuple of (success, message, port) """ - + try: - + # Get free port port = self.get_free_port() - - # Start streamlit process + + # For Vizro, we need to modify the app.py to use the port we allocated + # Read the app file and inject the port configuration + import os + app_path = os.path.join(app_directory, app_file_name) + with open(app_path, 'r') as f: + app_code = f.read() + + # Replace the run() call with run(port=X) + # Handle both .run() and .run(...) + import re + if re.search(r'\.run\(\s*\)', app_code): + # Simple case: .run() with no arguments + app_code = re.sub(r'\.run\(\s*\)', f'.run(port={port})', app_code) + elif re.search(r'\.run\(', app_code): + # Has arguments - insert port as first argument + app_code = re.sub(r'\.run\(', f'.run(port={port}, ', app_code) + + # Write back the modified code + with open(app_path, 'w') as f: + f.write(app_code) + + # Start python process to run the Vizro app cmd = [ - "streamlit", "run", app_file_name, - "--server.port", str(port), - "--server.headless", "true", - "--server.address", "localhost", - "--server.enableXsrfProtection", "false", - "--server.runOnSave", "true", # auto-reload when app is saved - "--logger.level", "error" + "python", app_file_name ] - - # TODO: Security considerations for production: - # - Consider enabling XSRF protection if needed, but we might already get this with the APIHandler? - # - Add authentication headers to streamlit - + proc = subprocess.Popen( cmd, stdout=subprocess.PIPE, @@ -81,7 +92,7 @@ def start_streamlit_preview(self, app_directory: AbsoluteNotebookDirPath, app_fi if not ready: proc.terminate() proc.wait() - raise StreamlitPreviewError("Streamlit app failed to start as app is not ready", 500) + raise StreamlitPreviewError("Vizro app failed to start as app is not ready", 500) # Register the process with self._lock: @@ -90,11 +101,11 @@ def start_streamlit_preview(self, app_directory: AbsoluteNotebookDirPath, app_fi port=port, ) - self.log.info(f"Started streamlit preview {preview_id} on port {port}") + self.log.info(f"Started vizro preview {preview_id} on port {port}") return port - + except Exception as e: - self.log.error(f"Error starting streamlit preview: {e}") + self.log.error(f"Error starting vizro preview: {e}") raise StreamlitPreviewError(f"Failed to start preview: {str(e)}", 500) def _wait_for_app_ready(self, port: int, timeout: int = 30) -> bool: diff --git a/mito-ai/pyproject.toml b/mito-ai/pyproject.toml index 60845d089..0863830dd 100644 --- a/mito-ai/pyproject.toml +++ b/mito-ai/pyproject.toml @@ -43,6 +43,7 @@ dependencies = [ # Mito App Dependencies "pipreqs", "streamlit", + "vizro", # LLM Dependencies "openai>=1.0.0", "google-genai", From 3b55c1d768b96a3e0cc5650368b8ab8dcd7e2201 Mon Sep 17 00:00:00 2001 From: Aaron Diamond-Reivich Date: Tue, 9 Dec 2025 16:45:18 -0500 Subject: [PATCH 2/4] Fix Vizro app generation and launch issues MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Update system prompt with @capture decorator requirements for vm.Graph and vm.Table - Add comprehensive examples showing correct vs incorrect Vizro patterns - Fix port injection to remove existing port arguments before adding new ones - Use sys.executable for subprocess to ensure correct Python interpreter - Add detailed guidance for chart type conversions using @capture("graph") 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../prompts/streamlit_system_prompt.py | 118 ++++++++++++++++-- mito-ai/mito_ai/streamlit_preview/manager.py | 14 ++- 2 files changed, 119 insertions(+), 13 deletions(-) diff --git a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py index 22cb5c835..5c1b46775 100644 --- a/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py +++ b/mito-ai/mito_ai/streamlit_conversion/prompts/streamlit_system_prompt.py @@ -16,30 +16,118 @@ VIZRO IMPLEMENTATION GUIDELINES: - Use Vizro's declarative structure: vm.Page, vm.Dashboard, vm.Graph, vm.Table, vm.Card, etc. -- Import vizro.plotly.express as px for charts (scatter, histogram, line, bar, etc.) -- Display visualizations using vm.Graph(figure=px.chart_type(...)) -- Show dataframes and tables using vm.Table(figure=df) +- Import vizro.plotly.express as px for simple charts +- Display visualizations using vm.Graph with @capture("graph") decorated functions +- Show dataframes and tables using vm.Table with @capture("table") decorated functions - Include text content using vm.Card(text="...") - Add interactive elements using vm.Filter() and vm.Parameter() where beneficial - Do not convert database connections. 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 vizro app. - Ensure professional styling and layout suitable for executives -- Structure the app as: load data → create page(s) with components → build dashboard → run +- Structure the app as: load data → define @capture functions → create page(s) with components → build dashboard → run + +CRITICAL VIZRO CONSTRAINTS: + +**1. vm.Graph ONLY accepts @capture("graph") decorated functions, NOT raw Plotly figures!** + +WRONG - This will NOT work: +```python +import plotly.graph_objects as go +fig = go.Figure(go.Bar(x=[1,2,3], y=[4,5,6])) +vm.Graph(figure=fig) # ERROR! Cannot use go.Figure directly +``` + +CORRECT - Use @capture("graph") decorator: +```python +from vizro.models.types import capture + +@capture("graph") +def my_bar_chart(data_frame): + import plotly.graph_objects as go + fig = go.Figure(go.Bar( + x=data_frame['category'], + y=data_frame['value'] + )) + fig.update_layout(title='My Chart') + return fig + +# Then use it: +vm.Graph(figure=my_bar_chart(df)) +``` + +**2. vm.Table ONLY accepts @capture("table") decorated functions, NOT raw DataFrames!** + +WRONG - This will NOT work: +```python +vm.Table(figure=df) # ERROR! Cannot use DataFrame directly +vm.Table(figure=df.head(100)) # ERROR! Still wrong +``` + +CORRECT - Use @capture("table") decorator: +```python +from vizro.models.types import capture + +@capture("table") +def my_table(data_frame): + from dash import dash_table + return dash_table.DataTable( + data=data_frame.to_dict('records'), + columns=[{"name": i, "id": i} for i in data_frame.columns], + page_size=20, + style_table={'overflowX': 'auto'}, + style_cell={'textAlign': 'left', 'padding': '10px'}, + style_header={'backgroundColor': 'lightgrey', 'fontWeight': 'bold'} + ) + +# Then use it: +vm.Table(figure=my_table(df)) +``` VIZRO APP STRUCTURE: ```python +import pandas as pd import vizro.plotly.express as px from vizro import Vizro import vizro.models as vm +from vizro.models.types import capture # Data loading and processing code here +df = pd.read_csv('data.csv') + +# Define graph functions with @capture("graph") +@capture("graph") +def my_bar_chart(data_frame): + import plotly.graph_objects as go + fig = go.Figure(go.Bar(x=data_frame['x'], y=data_frame['y'])) + fig.update_layout(title='My Chart', height=500) + return fig + +@capture("graph") +def my_scatter_chart(data_frame): + import plotly.graph_objects as go + fig = go.Figure(go.Scatter(x=data_frame['x'], y=data_frame['y'], mode='markers')) + return fig + +# Define table function with @capture("table") +@capture("table") +def data_table(data_frame): + from dash import dash_table + return dash_table.DataTable( + data=data_frame.to_dict('records'), + columns=[{"name": i, "id": i} for i in data_frame.columns], + page_size=20, + style_table={'overflowX': 'auto'}, + style_cell={'textAlign': 'left', 'padding': '10px'}, + style_header={'backgroundColor': 'lightgrey', 'fontWeight': 'bold'} + ) # Create page with components page = vm.Page( title="Dashboard Title", components=[ - vm.Graph(figure=px.scatter(...)), - vm.Table(figure=df), - vm.Card(text="Insights and explanations") + vm.Card(text="# Dashboard Overview\\n\\nThis dashboard shows..."), + vm.Graph(figure=my_bar_chart(df)), + vm.Graph(figure=my_scatter_chart(df)), + vm.Table(figure=data_table(df.head(100))) ], controls=[ vm.Filter(column="category"), @@ -57,20 +145,28 @@ 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 Vizro 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 vizro dashboard. +6. **NO IMPROVISATION**: Do not provide your own interpretations of the analysis. Just convert the existing analysis into a vizro dashboard. +7. **USE @capture DECORATORS**: Always use @capture("graph") for vm.Graph and @capture("table") for vm.Table - NEVER pass raw figures or DataFrames COMPONENT MAPPING: -- Code cells that generate plots → vm.Graph(figure=px.chart_type(...)) -- DataFrames → vm.Table(figure=df) +- Code cells that generate plots → @capture("graph") function + vm.Graph(figure=func(df)) +- DataFrames to display → @capture("table") function + vm.Table(figure=func(df)) - Markdown cells with text → vm.Card(text="...") - Variables that users might want to filter → vm.Filter(column="...") - Maintain the order of outputs as they appear in the notebook +CHART TYPE CONVERSIONS (all must use @capture("graph")): +- matplotlib/seaborn plots → convert to go.Figure inside @capture("graph") function +- go.Bar → @capture("graph") function returning go.Figure(go.Bar(...)) +- go.Scatter → @capture("graph") function returning go.Figure(go.Scatter(...)) +- go.Histogram → @capture("graph") function returning go.Figure(go.Histogram(...)) +- px.scatter_mapbox → @capture("graph") function returning go.Figure with go.Scattermapbox + STYLE GUIDELINES: - Create a professional, executive-friendly dashboard - If there are variables in the notebook that viewers would likely want to configure, use vm.Filter or vm.Parameter - 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 vizro app +- Do not modify the graphs or analysis. If the notebook has a graph, convert it to Vizro-compatible format using @capture - Always end with: Vizro().build(dashboard).run() OUTPUT FORMAT: diff --git a/mito-ai/mito_ai/streamlit_preview/manager.py b/mito-ai/mito_ai/streamlit_preview/manager.py index 0d4b7e636..e99b7f8a1 100644 --- a/mito-ai/mito_ai/streamlit_preview/manager.py +++ b/mito-ai/mito_ai/streamlit_preview/manager.py @@ -3,6 +3,7 @@ import socket import subprocess +import sys import time import threading import requests @@ -61,8 +62,15 @@ def start_streamlit_preview(self, app_directory: AbsoluteNotebookDirPath, app_fi app_code = f.read() # Replace the run() call with run(port=X) - # Handle both .run() and .run(...) + # First, remove any existing port= arguments to avoid duplicates import re + # Remove existing port=XXXX arguments (with optional trailing comma and space) + app_code = re.sub(r'port=\d+,?\s*', '', app_code) + # Clean up any resulting empty parentheses or double commas + app_code = re.sub(r'\.run\(\s*,', '.run(', app_code) + app_code = re.sub(r',\s*\)', ')', app_code) + + # Now inject the new port if re.search(r'\.run\(\s*\)', app_code): # Simple case: .run() with no arguments app_code = re.sub(r'\.run\(\s*\)', f'.run(port={port})', app_code) @@ -75,8 +83,10 @@ def start_streamlit_preview(self, app_directory: AbsoluteNotebookDirPath, app_fi f.write(app_code) # Start python process to run the Vizro app + # Use sys.executable to ensure we use the same Python interpreter + # that's running JupyterLab (with all dependencies installed) cmd = [ - "python", app_file_name + sys.executable, app_file_name ] proc = subprocess.Popen( From 49d39c681a73fcb6f30de20feff617f271fd705c Mon Sep 17 00:00:00 2001 From: Aaron Diamond-Reivich Date: Tue, 9 Dec 2025 16:51:59 -0500 Subject: [PATCH 3/4] Add Vizro app validation to catch errors before launch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Re-enables the validation loop for Vizro dashboards with a new validate_vizro_app module that checks syntax and runtime errors by building the dashboard in a subprocess without running the server. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../streamlit_agent_handler.py | 36 ++-- .../validate_vizro_app.py | 159 ++++++++++++++++++ 2 files changed, 177 insertions(+), 18 deletions(-) create mode 100644 mito-ai/mito_ai/streamlit_conversion/validate_vizro_app.py diff --git a/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py b/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py index eb8656898..5b7b429f8 100644 --- a/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py +++ b/mito-ai/mito_ai/streamlit_conversion/streamlit_agent_handler.py @@ -8,7 +8,7 @@ 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.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.validate_vizro_app import validate_vizro_app 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 @@ -120,24 +120,24 @@ async def streamlit_handler(notebook_path: AbsoluteNotebookPath, app_file_name: # Otherwise generate a new streamlit app streamlit_code = await generate_new_streamlit_code(notebook_code) - # Validation disabled for Vizro POC - # errors = validate_app(streamlit_code, notebook_path) - # tries = 0 - # while len(errors)>0 and tries < 5: - # for error in errors: - # streamlit_code = await correct_error_in_generation(error, streamlit_code) - # - # errors = validate_app(streamlit_code, notebook_path) - # - # if len(errors)>0: - # # 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_validation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, errors) - # tries+=1 + # Validate the generated Vizro app + errors = validate_vizro_app(streamlit_code, notebook_path) + tries = 0 + while len(errors) > 0 and tries < 5: + for error in errors: + streamlit_code = await correct_error_in_generation(error, streamlit_code) - # if len(errors)>0: - # final_errors = ', '.join(errors) - # raise StreamlitConversionError(f"Streamlit agent failed generating code after max retries. Errors: {final_errors}", 500) + errors = validate_vizro_app(streamlit_code, notebook_path) + + if len(errors) > 0: + # 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_validation_retry('mito_server_key', MessageType.STREAMLIT_CONVERSION, errors) + tries += 1 + + if len(errors) > 0: + final_errors = ', '.join(errors) + raise StreamlitConversionError(f"Vizro agent failed generating code after max retries. Errors: {final_errors}", 500) # Finally, update the app.py file with the new code create_app_file(app_path, streamlit_code) diff --git a/mito-ai/mito_ai/streamlit_conversion/validate_vizro_app.py b/mito-ai/mito_ai/streamlit_conversion/validate_vizro_app.py new file mode 100644 index 000000000..12325d1d9 --- /dev/null +++ b/mito-ai/mito_ai/streamlit_conversion/validate_vizro_app.py @@ -0,0 +1,159 @@ +# Copyright (c) Saga Inc. +# Distributed under the terms of the GNU Affero General Public License v3.0 License. + +import os +import sys +import tempfile +import traceback +import ast +import subprocess +from typing import List, Optional, Dict, Any +from mito_ai.path_utils import AbsoluteNotebookPath, get_absolute_notebook_dir_path + + +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 + + +def get_import_and_build_errors(app_code: str, app_path: AbsoluteNotebookPath) -> Optional[List[Dict[str, Any]]]: + """ + Validate Vizro app by attempting to import and build it. + + This creates a temporary file with the app code (modified to not run the server), + then executes it in a subprocess to catch import and build errors. + """ + directory = get_absolute_notebook_dir_path(app_path) + + # Modify the code to only build the dashboard without running the server + # Replace .run() with a simple validation that the dashboard builds successfully + validation_code = app_code + + # Remove or comment out the .run() call so we just validate the build + # We need to handle various patterns like: + # - Vizro().build(dashboard).run() + # - Vizro().build(dashboard).run(port=8050) + # - app = Vizro().build(dashboard) ... app.run() + import re + + # Pattern 1: Remove .run(...) from chained calls + validation_code = re.sub(r'\.run\([^)]*\)\s*$', '', validation_code, flags=re.MULTILINE) + + # Pattern 2: Remove standalone app.run() or similar variable.run() calls + validation_code = re.sub(r'^[a-zA-Z_][a-zA-Z0-9_]*\.run\([^)]*\)\s*$', '', validation_code, flags=re.MULTILINE) + + # Add validation print at the end to confirm success + validation_code += "\nprint('VIZRO_VALIDATION_SUCCESS')\n" + + # Create temporary file and run in subprocess + with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as f: + f.write(validation_code) + temp_path = f.name + + try: + # Run the validation in a subprocess + result = subprocess.run( + [sys.executable, temp_path], + cwd=directory, + capture_output=True, + text=True, + timeout=60 # 60 second timeout for validation + ) + + # Check if validation was successful + if result.returncode != 0 or 'VIZRO_VALIDATION_SUCCESS' not in result.stdout: + errors = [] + + # Parse stderr for error information + stderr = result.stderr.strip() + if stderr: + errors.append({ + 'type': 'runtime', + 'details': stderr, + 'message': extract_error_message(stderr) + }) + + # Also include stdout if it contains error info + stdout = result.stdout.strip() + if stdout and 'VIZRO_VALIDATION_SUCCESS' not in stdout: + # Only include if it looks like an error + if 'Error' in stdout or 'Exception' in stdout or 'Traceback' in stdout: + errors.append({ + 'type': 'output', + 'details': stdout, + 'message': extract_error_message(stdout) + }) + + return errors if errors else [{'type': 'unknown', 'details': 'Validation failed without specific error'}] + + return None + + except subprocess.TimeoutExpired: + return [{'type': 'timeout', 'details': 'Vizro app validation timed out after 60 seconds'}] + except Exception as e: + return [{'type': 'validation', 'details': str(e)}] + finally: + # Clean up the temporary file + try: + os.unlink(temp_path) + except OSError: + pass + + +def extract_error_message(error_text: str) -> str: + """Extract a concise error message from a full traceback""" + lines = error_text.strip().split('\n') + + # Look for common error patterns + for line in reversed(lines): + line = line.strip() + # Look for exception lines + if any(err in line for err in ['Error:', 'Exception:', 'ValidationError']): + return line + # Look for lines that start with error type + if line.startswith(('ValueError', 'TypeError', 'KeyError', 'AttributeError', + 'ImportError', 'ModuleNotFoundError', 'NameError', + 'ValidationError', 'pydantic')): + return line + + # If no specific error found, return last non-empty line + for line in reversed(lines): + if line.strip(): + return line.strip()[:200] # Truncate to 200 chars + + return "Unknown error" + + +def check_for_errors(app_code: str, app_path: AbsoluteNotebookPath) -> List[Dict[str, Any]]: + """Complete validation pipeline for Vizro apps""" + errors: List[Dict[str, Any]] = [] + + try: + # Step 1: Check syntax + syntax_error = get_syntax_error(app_code) + if syntax_error: + errors.append({'type': 'syntax', 'details': syntax_error}) + # Don't continue with runtime check if syntax is broken + return errors + + # Step 2: Check imports and dashboard build + runtime_errors = get_import_and_build_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 + + +def validate_vizro_app(app_code: str, notebook_path: AbsoluteNotebookPath) -> List[str]: + """Convenience function to validate Vizro code""" + errors = check_for_errors(app_code, notebook_path) + stringified_errors = [str(error) for error in errors] + return stringified_errors From d567a5d1c17ef3da9aa0c3427143ea7b1230fc82 Mon Sep 17 00:00:00 2001 From: Aaron Diamond-Reivich Date: Tue, 9 Dec 2025 16:59:50 -0500 Subject: [PATCH 4/4] Add example Vizro app and update test notebook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Includes the generated Vizro dashboard app for bike violations analysis and updated notebook with cell outputs from testing. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude --- .../geospatial/bike-violations.ipynb | 93100 +--------------- .../geospatial/mito-app-d74da98a6f2e.py | 343 + 2 files changed, 594 insertions(+), 92849 deletions(-) create mode 100644 mito-ai/example-notebooks/geospatial/mito-app-d74da98a6f2e.py diff --git a/mito-ai/example-notebooks/geospatial/bike-violations.ipynb b/mito-ai/example-notebooks/geospatial/bike-violations.ipynb index 064c44430..88dd0fa91 100644 --- a/mito-ai/example-notebooks/geospatial/bike-violations.ipynb +++ b/mito-ai/example-notebooks/geospatial/bike-violations.ipynb @@ -38,7 +38,41 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, + "id": "2a588e68-d720-4ac8-bbb1-4293e49a22ed", + "metadata": { + "include-cell-in-app": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: folium in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (0.20.0)\n", + "Requirement already satisfied: branca>=0.6.0 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from folium) (0.8.2)\n", + "Requirement already satisfied: jinja2>=2.9 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from folium) (3.1.6)\n", + "Requirement already satisfied: numpy in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from folium) (2.3.5)\n", + "Requirement already satisfied: requests in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from folium) (2.32.5)\n", + "Requirement already satisfied: xyzservices in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from folium) (2025.11.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from jinja2>=2.9->folium) (3.0.3)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from requests->folium) (3.4.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from requests->folium) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from requests->folium) (2.6.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /Users/aarondiamond-reivich/Mito/mito/.conductor/kinshasa/mito-ai/venv/lib/python3.12/site-packages (from requests->folium) (2025.11.12)\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m25.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.3\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install folium" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "id": "58231e1f-1748-415b-8329-7872b165959e", "metadata": { "include-cell-in-app": true @@ -62,7 +96,21 @@ { "data": { "text/html": [ - "
See Full Dataframe in Mito
\n", + "
\n", + "\n", + "
\n", " \n", " \n", " \n", @@ -187,7 +235,8 @@ " \n", " \n", " \n", - "
1
" + "\n", + "" ], "text/plain": [ " Unnamed: 0 EVNT_KEY VIOLATION_DATE VIOLATION_TIME CHG_LAW_CD \\\n", @@ -219,7 +268,7 @@ "4 POINT (-73.9548552168686 40.800030779907516) 1 " ] }, - "execution_count": 1, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -264,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 19, "id": "30f3620c-9c02-4b9c-9aff-1b939e2144ad", "metadata": { "include-cell-in-app": true @@ -297,7 +346,21 @@ { "data": { "text/html": [ - "
See Full Dataframe in Mito
\n", + "
\n", + "\n", + "
\n", " \n", " \n", " \n", @@ -311,7 +374,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -323,7 +386,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -338,7 +401,8 @@ " \n", " \n", " \n", - "
01111D1CBIKEBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT- NYCBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LI...
121111D1CBIKEBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT- NYCBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LI...
3DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE
" + "\n", + "" ], "text/plain": [ " VIOLATION_CODE VEH_CATEGORY \\\n", @@ -356,7 +420,7 @@ "4 DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE " ] }, - "execution_count": 2, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -431,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 20, "id": "7f6d8675-1361-43bf-bcef-a67d1235fbd0", "metadata": { "include-cell-in-app": true @@ -464,7 +528,21 @@ { "data": { "text/html": [ - "
See Full Dataframe in Mito
\n", + "
\n", + "\n", + "
\n", " \n", " \n", " \n", @@ -478,7 +556,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -490,7 +568,7 @@ " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -505,7 +583,8 @@ " \n", " \n", " \n", - "
01111D1CBIKEBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT- NYCBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LI...
121111D1CBIKEBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT- NYCBICYCLE OR SKATEBOARD FAILED TO STOP AT RED LI...
3DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE
" + "\n", + "" ], "text/plain": [ " VIOLATION_CODE VEH_CATEGORY \\\n", @@ -523,7 +602,7 @@ "4 DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE " ] }, - "execution_count": 3, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -553,58 +632,12 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 21, "id": "8fcd5119-7343-41de-a5e0-213d1e6d657c", "metadata": { "include-cell-in-app": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/aarondiamond-reivich/Mito/mito/mito-ai/venv/lib/python3.11/site-packages/kaleido/_sync_server.py:11: UserWarning:\n", - "\n", - "\n", - "\n", - "Warning: You have Plotly version 5.24.1, which is not compatible with this version of Kaleido (1.1.0).\n", - "\n", - "This means that static image generation (e.g. `fig.write_image()`) will not work.\n", - "\n", - "Please upgrade Plotly to version 6.1.1 or greater, or downgrade Kaleido to version 0.2.1.\n", - "\n", - "\n" - ] - }, - { - "data": { - "text/html": [ - " \n", - " " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "application/vnd.plotly.v1+json": { @@ -618,36 +651,16 @@ "color": "steelblue" }, "orientation": "h", - "text": [ - 4779, - 1899, - 1605, - 199, - 170, - 152, - 149, - 92, - 79, - 73, - 33, - 28 - ], + "text": { + "bdata": "AAAAAACrskAAAAAAAKydQAAAAAAAFJlAAAAAAADgaEAAAAAAAEBlQAAAAAAAAGNAAAAAAACgYkAAAAAAAABXQAAAAAAAwFNAAAAAAABAUkAAAAAAAIBAQAAAAAAAADxA", + "dtype": "f8" + }, "textposition": "outside", "type": "bar", - "x": [ - 4779, - 1899, - 1605, - 199, - 170, - 152, - 149, - 92, - 79, - 73, - 33, - 28 - ], + "x": { + "bdata": "qxJrB0UGxwCqAJgAlQBcAE8ASQAhABwA", + "dtype": "i2" + }, "y": [ "BICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT-...", "DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE", @@ -854,57 +867,6 @@ "type": "heatmap" } ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], "histogram": [ { "marker": { @@ -1105,6 +1067,17 @@ "type": "scattergl" } ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], "scattermapbox": [ { "marker": { @@ -1508,34 +1481,7 @@ } } }, - "image/png": "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", - "text/html": [ - "
" - ] + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1612,7 +1558,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "id": "c2984f73-8da2-4de8-b3f4-ab5024d0bac2", "metadata": { "include-cell-in-app": true @@ -1659,7 +1605,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 23, "id": "779d994c-3221-40e3-96c7-38f48678efc8", "metadata": { "include-cell-in-app": true @@ -1989,57 +1935,6 @@ "type": "heatmap" } ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], "histogram": [ { "marker": { @@ -2240,6 +2135,17 @@ "type": "scattergl" } ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], "scattermapbox": [ { "marker": { @@ -2643,34 +2549,7 @@ } } }, - "image/png": "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", - "text/html": [ - "
" - ] + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -2797,7 +2676,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "60f654fc-76aa-4622-a0d7-bf206a63cc47", "metadata": { "include-cell-in-app": true @@ -2896,7 +2775,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "id": "c88c134b-afb3-4654-822b-2def2ec1d84c", "metadata": { "include-cell-in-app": true @@ -3002,7 +2881,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "id": "2eed299d-e5b2-40f4-8615-e989be9edffe", "metadata": { "include-cell-in-app": true @@ -3364,57 +3243,6 @@ "type": "heatmap" } ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], "histogram": [ { "marker": { @@ -3615,6 +3443,17 @@ "type": "scattergl" } ], + "scattermap": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermap" + } + ], "scattermapbox": [ { "marker": { @@ -4018,34 +3857,7 @@ } } }, - "image/png": "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", - "text/html": [ - "
" - ] + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -4117,43 +3929,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "c4b57028-664b-4c63-bcfd-db8956ac274e", "metadata": { "include-cell-in-app": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Coordinate data summary:\n", - "X_COORD_CD range: 930325 to 1061292\n", - "Y_COORD_CD range: 132747 to 268830\n", - "\n", - "Latitude range: 0.0 to 40.904503\n", - "Longitude range: -74.193986 to 0.0\n", - "\n", - "Records with valid lat/lon coordinates: 9,673 out of 13,353\n", - "Records with zero coordinates: 3,680\n", - "\n", - "Sample of valid coordinates:\n", - " VIOLATION_CODE VEH_CATEGORY Latitude Longitude \\\n", - "4 1110AB BIKE 40.800031 -73.954855 \n", - "5 1236B BIKE 40.753677 -73.914465 \n", - "6 1110AB BIKE 40.777874 -73.951743 \n", - "7 1110AB BIKE 40.756133 -73.967605 \n", - "8 403C1B BIKE 40.800711 -73.931970 \n", - "\n", - " VIOLATION_CATEGORY \n", - "4 Traffic Device Violation \n", - "5 Equipment - Bell/Signal \n", - "6 Traffic Device Violation \n", - "7 Traffic Device Violation \n", - "8 Pedestrian Safety Violation \n" - ] - } - ], + "outputs": [], "source": [ "# Check the coordinate data and convert NYC coordinates to lat/lon for mapping\n", "import numpy as np\n", @@ -4183,32 +3964,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "86095b9f-26b8-4dd4-ab5c-80fd9754e033", "metadata": { "include-cell-in-app": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converting coordinates for 3,680 records...\n", - "\n", - "After coordinate conversion:\n", - "Records with valid coordinates: 13,353 out of 13,353\n", - "Conversion success rate: 100.0%\n", - "\n", - "Sample of converted coordinates:\n", - " VIOLATION_CODE VEH_CATEGORY Latitude Longitude VIOLATION_CATEGORY\n", - "0 1111D1C BIKE 40.789228 -73.950170 Red Light Violation\n", - "1 1111D1E EBIKE 40.770309 -73.945251 Red Light Violation\n", - "2 1111D1C BIKE 40.789228 -73.950170 Red Light Violation\n", - "3 1236D BIKE 40.795602 -73.954035 Equipment - Reflectors\n", - "4 1110AB BIKE 40.800031 -73.954855 Traffic Device Violation\n" - ] - } - ], + "outputs": [], "source": [ "# Convert NYC coordinates to latitude/longitude for mapping\n", "# NYC uses the State Plane Coordinate System (SPCS) - New York Long Island Zone\n", @@ -4321,40 +4082,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "89f46055-7256-46b6-8c27-e8aba4d717cf", "metadata": { "include-cell-in-app": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Bike violations data: 13,353 records\n", - "\n", - "Bike violation breakdown:\n", - "VEH_CATEGORY\n", - "BIKE 9405\n", - "EBIKE 3943\n", - "DBIKE 5\n", - "Name: count, dtype: int64\n", - "\n", - "Coordinate data summary:\n", - "Records with valid Latitude/Longitude: 9,673\n", - "Records with valid NYC coordinates: 13,353\n", - "Records needing coordinate conversion: 3,680\n", - "\n", - "Sample coordinate data:\n", - " VIOLATION_CODE VEH_CATEGORY X_COORD_CD Y_COORD_CD Latitude Longitude\n", - "0 1111D1C BIKE 997407 233806 0.000000 0.000000\n", - "1 1111D1E EBIKE 998751 226901 0.000000 0.000000\n", - "2 1111D1C BIKE 997407 233806 0.000000 0.000000\n", - "3 1236D BIKE 996351 236132 0.000000 0.000000\n", - "4 1110AB BIKE 996749 230753 40.800031 -73.954855\n" - ] - } - ], + "outputs": [], "source": [ "# Load and prepare bike violations data for mapping\n", "import folium\n", @@ -4381,24 +4114,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "d30a397d-b43e-4299-942f-af0c744b9ba7", "metadata": { "include-cell-in-app": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Converting coordinates for 3,680 records...\n", - "\n", - "After coordinate conversion:\n", - "Records with valid coordinates: 13,353 out of 13,353\n", - "Conversion success rate: 100.0%\n" - ] - } - ], + "outputs": [], "source": [ "# Convert NYC State Plane coordinates to latitude/longitude for mapping\n", "def nyc_coords_to_latlon(x_coord, y_coord):\n", @@ -4448,92425 +4169,105 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "4eb70ea0-2957-4fe7-b228-7a803af149cc", "metadata": { "include-cell-in-app": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating map with 13,353 bike violations\n", - "Sampling 2,000 violations for map performance\n", - "\n", - "Bike violations map created successfully!\n", - "Map shows 2,000 violations across NYC\n", - "\n", - "Bike type distribution in map:\n", - "VEH_CATEGORY\n", - "BIKE 1432\n", - "EBIKE 568\n", - "Name: count, dtype: int64\n" - ] - }, - { - "data": { - "text/html": [ - "
Make this Notebook Trusted to load map: File -> Trust Notebook
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Create an interactive folium map with bike violations\n", - "import folium\n", - "from folium import plugins\n", - "import random\n", - "\n", - "# Filter to valid coordinates\n", - "valid_violations = bike_violations_for_map[valid_coords_after].copy()\n", - "\n", - "print(f\"Creating map with {len(valid_violations):,} bike violations\")\n", - "\n", - "# Sample data for performance (use first 2000 records)\n", - "if len(valid_violations) > 2000:\n", - " map_violations = valid_violations.sample(n=2000, random_state=42)\n", - " print(f\"Sampling {len(map_violations):,} violations for map performance\")\n", - "else:\n", - " map_violations = valid_violations\n", - "\n", - "# Create the base map centered on NYC\n", - "nyc_center = [40.7128, -74.0060]\n", - "bike_map = folium.Map(\n", - " location=nyc_center,\n", - " zoom_start=11,\n", - " tiles='OpenStreetMap'\n", - ")\n", - "\n", - "# Define colors for different bike types\n", - "color_map = {\n", - " 'BIKE': 'blue',\n", - " 'EBIKE': 'red', \n", - " 'DBIKE': 'green'\n", - "}\n", - "\n", - "# Add markers for each violation\n", - "for idx, row in map_violations.iterrows():\n", - " lat = row['Latitude']\n", - " lon = row['Longitude']\n", - " bike_type = row['VEH_CATEGORY']\n", - " violation_code = row['VIOLATION_CODE']\n", - " violation_date = row['VIOLATION_DATE']\n", - " violation_time = row['VIOLATION_TIME']\n", - " \n", - " # Create popup text\n", - " popup_text = f\"\"\"\n", - " Bike Violation
\n", - " Type: {bike_type}
\n", - " Code: {violation_code}
\n", - " Date: {violation_date}
\n", - " Time: {violation_time}\n", - " \"\"\"\n", - " \n", - " # Add marker with appropriate color\n", - " folium.CircleMarker(\n", - " location=[lat, lon],\n", - " radius=4,\n", - " popup=popup_text,\n", - " color=color_map.get(bike_type, 'gray'),\n", - " fill=True,\n", - " fillColor=color_map.get(bike_type, 'gray'),\n", - " fillOpacity=0.7,\n", - " weight=2\n", - " ).add_to(bike_map)\n", - "\n", - "# Add a legend\n", - "legend_html = '''\n", - "
\n", - "

Bike Types

\n", - "

Regular Bike

\n", - "

E-Bike

\n", - "
\n", - "'''\n", - "bike_map.get_root().html.add_child(folium.Element(legend_html))\n", - "\n", - "print(\"\\nBike violations map created successfully!\")\n", - "print(f\"Map shows {len(map_violations):,} violations across NYC\")\n", - "print(\"\\nBike type distribution in map:\")\n", - "print(map_violations['VEH_CATEGORY'].value_counts())\n", - "\n", - "# Display the map\n", - "bike_map " - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "af05bb28-cae8-44eb-b69b-e20e0ba2dc84", - "metadata": { - "include-cell-in-app": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Improved folium map created with clustering and heatmap!\n" - ] - }, - { - "data": { - "text/html": [ - "
Make this Notebook Trusted to load map: File -> Trust Notebook
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], + "source": [ + "# Create an interactive folium map with bike violations\n", + "import folium\n", + "from folium import plugins\n", + "import random\n", + "\n", + "# Filter to valid coordinates\n", + "valid_violations = bike_violations_for_map[valid_coords_after].copy()\n", + "\n", + "print(f\"Creating map with {len(valid_violations):,} bike violations\")\n", + "\n", + "# Sample data for performance (use first 2000 records)\n", + "if len(valid_violations) > 2000:\n", + " map_violations = valid_violations.sample(n=2000, random_state=42)\n", + " print(f\"Sampling {len(map_violations):,} violations for map performance\")\n", + "else:\n", + " map_violations = valid_violations\n", + "\n", + "# Create the base map centered on NYC\n", + "nyc_center = [40.7128, -74.0060]\n", + "bike_map = folium.Map(\n", + " location=nyc_center,\n", + " zoom_start=11,\n", + " tiles='OpenStreetMap'\n", + ")\n", + "\n", + "# Define colors for different bike types\n", + "color_map = {\n", + " 'BIKE': 'blue',\n", + " 'EBIKE': 'red', \n", + " 'DBIKE': 'green'\n", + "}\n", + "\n", + "# Add markers for each violation\n", + "for idx, row in map_violations.iterrows():\n", + " lat = row['Latitude']\n", + " lon = row['Longitude']\n", + " bike_type = row['VEH_CATEGORY']\n", + " violation_code = row['VIOLATION_CODE']\n", + " violation_date = row['VIOLATION_DATE']\n", + " violation_time = row['VIOLATION_TIME']\n", + " \n", + " # Create popup text\n", + " popup_text = f\"\"\"\n", + " Bike Violation
\n", + " Type: {bike_type}
\n", + " Code: {violation_code}
\n", + " Date: {violation_date}
\n", + " Time: {violation_time}\n", + " \"\"\"\n", + " \n", + " # Add marker with appropriate color\n", + " folium.CircleMarker(\n", + " location=[lat, lon],\n", + " radius=4,\n", + " popup=popup_text,\n", + " color=color_map.get(bike_type, 'gray'),\n", + " fill=True,\n", + " fillColor=color_map.get(bike_type, 'gray'),\n", + " fillOpacity=0.7,\n", + " weight=2\n", + " ).add_to(bike_map)\n", + "\n", + "# Add a legend\n", + "legend_html = '''\n", + "
\n", + "

Bike Types

\n", + "

Regular Bike

\n", + "

E-Bike

\n", + "
\n", + "'''\n", + "bike_map.get_root().html.add_child(folium.Element(legend_html))\n", + "\n", + "print(\"\\nBike violations map created successfully!\")\n", + "print(f\"Map shows {len(map_violations):,} violations across NYC\")\n", + "print(\"\\nBike type distribution in map:\")\n", + "print(map_violations['VEH_CATEGORY'].value_counts())\n", + "\n", + "# Display the map\n", + "bike_map " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "af05bb28-cae8-44eb-b69b-e20e0ba2dc84", + "metadata": { + "include-cell-in-app": true + }, + "outputs": [], "source": [ "# Improved folium map: clustering, heatmap, and better legend\n", "from folium.plugins import MarkerCluster, HeatMap\n", @@ -96970,8 +4371,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.1" - } + "version": "3.12.12" + }, + "mito-notebook-id": "mito-notebook-d74da98a6f2e" }, "nbformat": 4, "nbformat_minor": 5 diff --git a/mito-ai/example-notebooks/geospatial/mito-app-d74da98a6f2e.py b/mito-ai/example-notebooks/geospatial/mito-app-d74da98a6f2e.py new file mode 100644 index 000000000..e5d08f98c --- /dev/null +++ b/mito-ai/example-notebooks/geospatial/mito-app-d74da98a6f2e.py @@ -0,0 +1,343 @@ +import pandas as pd +import plotly.graph_objects as go +from vizro import Vizro +import vizro.models as vm +from vizro.models.types import capture +import folium +from folium.plugins import MarkerCluster, HeatMap + +# Load the CSV file +df = pd.read_csv('Bike_Violations_B_Summons.csv') + +# Filter to only bike-related violations +bike_violations = df[df['VEH_CATEGORY'].str.contains('BIKE', case=False, na=False)] + +# Violation codes lookup table +violation_data_list = [ + {'LAW_TITLE': 'TBTA', 'LAW_CODE': '10208B', 'DESCRIPTION': 'BICYCLE FAILED TO OBEY SIGNS - TBTA', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'TBTA', 'LAW_CODE': '10221CB', 'DESCRIPTION': 'BICYCLE NO FLAT TIRES - TBTA', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'TBTA', 'LAW_CODE': '10231B', 'DESCRIPTION': 'BICYCLE CARELESS/NEGLIGENT OPERATION - TBTA', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'TBTA', 'LAW_CODE': '10233BB', 'DESCRIPTION': 'BICYCLE FAILED TO COMPLY WITH ORDER - TBTA', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1102B', 'DESCRIPTION': 'BICYCLE FAILED TO COMPLY WITH LAWFUL ORDER', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1110AB', 'DESCRIPTION': 'DISOBEYED TRAFFIC DEVICE WHILE OPERATING BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1111A1B', 'DESCRIPTION': 'BICYCLE FAILED TO YIELD RIGHT-OF-WAY-GREEN LIGHT', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1111A2X', 'DESCRIPTION': 'BICYCLE DISOBEYED GREEN ARROW', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1111A2Z', 'DESCRIPTION': 'BICYCLE FAILED TO YIELD GREEN ARROW', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1111D1C', 'DESCRIPTION': 'BICYCLE OR SKATEBOARD FAILED TO STOP AT RED LIGHT- NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1127AB', 'DESCRIPTION': 'DRIVING WRONG DIRECTION ON ONE-WAY STREET - BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1219AB', 'DESCRIPTION': 'BICYCLE THREW/DEPOSITED GLASS/ETC ON HIGHWAY', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1220AB', 'DESCRIPTION': 'BICYCLE THREW/DEPOSITED REFUSE/ETC HIGHWAY', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1229AB', 'DESCRIPTION': 'BICYCLE/PUSHCART/ANIMAL DRAWN VEHICLE ON EXPRESSWAY', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1232A', 'DESCRIPTION': 'IMPROPER OPERATION OF BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1232B', 'DESCRIPTION': 'TOO MANY RIDERS - BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1234A', 'DESCRIPTION': 'FAILURE TO KEEP RIGHT-BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1234B', 'DESCRIPTION': 'MORE THAN TWO ABREAST-BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1234C', 'DESCRIPTION': 'FAILURE TO STOP WHEN ENTERING ROAD/BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1234D', 'DESCRIPTION': 'BICYCLE OR SKATEBOARD FAILED TO STOP', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1235', 'DESCRIPTION': 'CARRYING ARTICLES ON BIKE OR SKATEBOARD', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1236A', 'DESCRIPTION': 'NO/INADEQUATE LIGHTS-BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1236B', 'DESCRIPTION': 'NO BELL OR SIGNAL DEVICE ON BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1236C', 'DESCRIPTION': 'NO/INADEQUATE BRAKES-BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1236D', 'DESCRIPTION': 'NO REFLECTOR WHEEL/BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1236E', 'DESCRIPTION': 'NO/IMPROPER REFLECTOR-BICYCLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '1238', 'DESCRIPTION': 'NO CHILD BICYCLE HELMET', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '123810', 'DESCRIPTION': 'NO REFLECTOR AFTER SUNSET', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '12331', 'DESCRIPTION': 'RIDER/SKATER CLINGING TO MOVING MOTOR VEHICLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '12332', 'DESCRIPTION': 'ATTACHING SELF TO MOVING MOTOR VEHICLE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'VTL', 'LAW_CODE': '37524AB', 'DESCRIPTION': 'OPER BICYCLE WITH MORE 1 EARPHONE', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '403A3IX', 'DESCRIPTION': 'BICYCLE FAILED TO YIELD TO PEDESTRIAN AT RED LIGHT- NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '403A4B', 'DESCRIPTION': 'BICYCLE DISOBEYED COLORED ARROW-NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '403A5B', 'DESCRIPTION': 'BICYCLE DISOBEYED STOP SIGN- NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '403C1B', 'DESCRIPTION': 'BICYCLE FAIL TO YLD RIGHT OF WAY TO PEDESTRIAN WITH WALK SIGNAL', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '407C31', 'DESCRIPTION': 'BIKE/SKATE ON SIDEWALK-NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '412A1B', 'DESCRIPTION': 'BICYCLE FAILED TO COMPLY WITH ORDER- NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'}, + {'LAW_TITLE': 'NYCTRR', 'LAW_CODE': '412P1', 'DESCRIPTION': 'BIKING OFF LANE- NYC', 'CAN_BE_ISSUED_TO_BICYCLIST': 'Y'} +] + +violation_codes_df = pd.DataFrame(violation_data_list) + +# Merge bike violations with violation codes +bike_violations_with_desc = bike_violations.merge( + violation_codes_df, + left_on='VIOLATION_CODE', + right_on='LAW_CODE', + how='left' +) + +# Create violation category mapping +violation_mapping = { + '1111D1C': 'Red Light Violation', + '1111D1E': 'Red Light Violation', + '1236A': 'Equipment - Lights', + '1236AE': 'Equipment - Lights', + '1236C': 'Equipment - Brakes', + '1236CE': 'Equipment - Brakes', + '1236B': 'Equipment - Bell/Signal', + '1236BE': 'Equipment - Bell/Signal', + '1236D': 'Equipment - Reflectors', + '1236DE': 'Equipment - Reflectors', + '1236E': 'Equipment - Reflectors', + '1236EE': 'Equipment - Reflectors', + '1232A': 'Improper Operation', + '1232AE': 'Improper Operation', + '1238': 'Helmet Violation', + '12385C': 'Helmet Violation', + '407C31': 'Sidewalk Violation', + '12425A': 'Sidewalk Violation', + '1110AB': 'Traffic Device Violation', + '403A3IX': 'Pedestrian Safety Violation', + '403C1B': 'Pedestrian Safety Violation', + '12426': 'Pedestrian Safety Violation', + '37524AB': 'Earphone Violation', + '1127AB': 'Wrong Direction', + '412P1': 'Lane Violation', + '1111A1B': 'Right-of-Way Violation', + '1111A2Z': 'Green Arrow Violation' +} + +bike_violations_normalized = bike_violations_with_desc.copy() +bike_violations_normalized['VIOLATION_CATEGORY'] = bike_violations_normalized['VIOLATION_CODE'].map(violation_mapping) +bike_violations_normalized['VIOLATION_CATEGORY'] = bike_violations_normalized['VIOLATION_CATEGORY'].fillna('Other') + +# Separate by bike type +bike_only = bike_violations_normalized[bike_violations_normalized['VEH_CATEGORY'] == 'BIKE'] +ebike_only = bike_violations_normalized[bike_violations_normalized['VEH_CATEGORY'] == 'EBIKE'] + +# Convert NYC coordinates to lat/lon +def nyc_coords_to_latlon(x_coord, y_coord): + if x_coord == 0 or y_coord == 0: + return None, None + lat = 40.4774 + (y_coord - 120000) * 0.00000274 + lon = -74.2591 + (x_coord - 913000) * 0.00000366 + if 40.4 <= lat <= 40.95 and -74.3 <= lon <= -73.7: + return lat, lon + else: + return None, None + +bike_violations_for_map = bike_violations.copy() +valid_latlon = ((bike_violations_for_map['Latitude'] != 0) & (bike_violations_for_map['Longitude'] != 0)) +valid_nyc_coords = ((bike_violations_for_map['X_COORD_CD'] != 0) & (bike_violations_for_map['Y_COORD_CD'] != 0)) + +for idx in bike_violations_for_map[~valid_latlon & valid_nyc_coords].index: + x_coord = bike_violations_for_map.loc[idx, 'X_COORD_CD'] + y_coord = bike_violations_for_map.loc[idx, 'Y_COORD_CD'] + lat, lon = nyc_coords_to_latlon(x_coord, y_coord) + if lat is not None and lon is not None: + bike_violations_for_map.loc[idx, 'Latitude'] = lat + bike_violations_for_map.loc[idx, 'Longitude'] = lon + +valid_coords_after = ((bike_violations_for_map['Latitude'] != 0) & + (bike_violations_for_map['Longitude'] != 0) & + (bike_violations_for_map['Latitude'].between(40.4, 40.95)) & + (bike_violations_for_map['Longitude'].between(-74.3, -73.7))) + +valid_violations = bike_violations_for_map[valid_coords_after].copy() +if len(valid_violations) > 2000: + map_violations = valid_violations.sample(n=2000, random_state=42) +else: + map_violations = valid_violations + +# Define @capture functions for visualizations +@capture("graph") +def top_violations_chart(data_frame): + top_violations = data_frame[data_frame['DESCRIPTION'].notna()]['DESCRIPTION'].value_counts().head(12) + plot_data = pd.DataFrame({ + 'Violation': top_violations.index, + 'Count': top_violations.values + }) + plot_data['Violation_Short'] = plot_data['Violation'].apply( + lambda x: x[:50] + '...' if len(x) > 50 else x + ) + + fig = go.Figure(go.Bar( + x=plot_data['Count'], + y=plot_data['Violation_Short'], + orientation='h', + text=plot_data['Count'], + textposition='outside', + hovertemplate='%{y}
Count: %{x:,}
', + marker=dict(color='steelblue') + )) + + fig.update_layout( + title='Top 12 Most Common Bicycle Violations in NYC (2025 YTD)', + xaxis_title='Number of Violations', + yaxis_title='', + height=600, + width=900, + yaxis={'categoryorder': 'total ascending'}, + font=dict(size=12), + margin=dict(l=300, r=50, t=80, b=50) + ) + return fig + +@capture("graph") +def bike_type_comparison_chart(data_frame): + bike_data = data_frame[data_frame['VEH_CATEGORY'] == 'BIKE'] + ebike_data = data_frame[data_frame['VEH_CATEGORY'] == 'EBIKE'] + + bike_category_counts = bike_data['VIOLATION_CATEGORY'].value_counts() + ebike_category_counts = ebike_data['VIOLATION_CATEGORY'].value_counts() + + all_categories = list(set(bike_category_counts.index) | set(ebike_category_counts.index)) + all_categories = sorted(all_categories) + + bike_category_data = [bike_category_counts.get(cat, 0) for cat in all_categories] + ebike_category_data = [ebike_category_counts.get(cat, 0) for cat in all_categories] + + fig = go.Figure() + + fig.add_trace(go.Bar( + name='Regular BIKE', + x=all_categories, + y=bike_category_data, + marker_color='steelblue', + text=bike_category_data, + textposition='outside', + hovertemplate='%{x}
Regular BIKE: %{y:,}
' + )) + + fig.add_trace(go.Bar( + name='EBIKE', + x=all_categories, + y=ebike_category_data, + marker_color='orange', + text=ebike_category_data, + textposition='outside', + hovertemplate='%{x}
EBIKE: %{y:,}
' + )) + + fig.update_layout( + title='Bicycle Violations by Category: Regular BIKE vs EBIKE Comparison (2025 YTD)', + xaxis_title='Violation Category', + yaxis_title='Number of Violations', + barmode='group', + height=600, + width=1200, + font=dict(size=12), + legend=dict(x=0.7, y=0.95), + xaxis=dict(tickangle=45) + ) + return fig + +@capture("graph") +def violation_map_chart(data_frame): + map_data = data_frame + + fig = go.Figure(go.Scattermapbox( + lat=map_data['Latitude'], + lon=map_data['Longitude'], + mode='markers', + marker=dict( + size=8, + color=map_data['VEH_CATEGORY'].map({'BIKE': 'blue', 'EBIKE': 'red', 'DBIKE': 'green'}), + opacity=0.6 + ), + text=map_data.apply(lambda row: f"Type: {row['VEH_CATEGORY']}
Code: {row['VIOLATION_CODE']}
Date: {row['VIOLATION_DATE']}
Time: {row['VIOLATION_TIME']}", axis=1), + hovertemplate='Bike Violation
%{text}' + )) + + fig.update_layout( + title='NYC Bicycle Violations Map (2025 YTD)', + mapbox=dict( + style='open-street-map', + center=dict(lat=40.7128, lon=-74.0060), + zoom=10 + ), + height=600, + width=1200, + margin=dict(l=0, r=0, t=40, b=0) + ) + + return fig + +@capture("table") +def violations_summary_table(data_frame): + from dash import dash_table + summary_df = data_frame[['VIOLATION_CODE', 'VEH_CATEGORY', 'DESCRIPTION', 'VIOLATION_DATE']].head(100) + return dash_table.DataTable( + data=summary_df.to_dict('records'), + columns=[{"name": i, "id": i} for i in summary_df.columns], + page_size=20, + style_table={'overflowX': 'auto'}, + style_cell={'textAlign': 'left', 'padding': '10px'}, + style_header={'backgroundColor': 'lightgrey', 'fontWeight': 'bold'} + ) + +# Create dashboard pages +page = vm.Page( + title="NYC Bicycle Violations Analysis", + components=[ + vm.Card(text=""" +# NYC Bicycle Violations Analysis + +This dashboard analyzes bicycle violation data from NYC's Moving Violation B Summons dataset for 2025 year-to-date. The analysis includes: + +1. **Data Loading & Filtering** - Loading the full violation dataset and filtering for bicycle-related violations +2. **Violation Code Mapping** - Creating a lookup table for violation descriptions and categorizing violations +3. **Exploratory Analysis** - Analyzing the most common violations and comparing patterns between regular bikes and e-bikes +4. **Geographic Visualization** - Creating an interactive map showing violation locations across NYC + +## Key Findings +- **15k total bicycle violations** recorded in 2025 YTD +- **E-bikes** show different violation patterns compared to regular bikes +- **Geographic distribution** shows violations concentrated in Manhattan and other high-traffic areas + +--- + """), + vm.Graph(figure=top_violations_chart(bike_violations_with_desc)), + vm.Graph(figure=bike_type_comparison_chart(bike_violations_normalized)), + vm.Card(text=""" +## Geographic Visualization + +The map below shows the distribution of bicycle violations across NYC. The visualization includes: +- **Marker Clustering** - Violations are grouped for better performance +- **Heatmap Layer** - Shows density of violations across the city +- **Color Coding** - Blue for regular bikes, red for e-bikes + +The map is interactive - you can zoom, pan, and click on markers for details. + """), + vm.Graph(figure=violation_map_chart(map_violations)), + vm.Card(text=""" +## Summary & Conclusions + +This analysis of NYC bicycle violations for 2025 YTD reveals several key insights: + +### Key Findings + +1. **Volume**: 15,000 total bicycle violations recorded, representing a significant enforcement focus on bicycle safety + +2. **Most Common Violations**: + - Equipment violations are also significant (lights, brakes, bells, reflectors) + - Pedestrian safety violations indicate ongoing conflicts between cyclists and pedestrians + +3. **Bike Type Differences**: + - Regular bikes (BIKE) account for the majority of violations + - E-bikes (EBIKE) show similar violation patterns but with some differences in equipment violations + - Different violation codes are used for e-bikes vs regular bikes for the same violation types + +4. **Geographic Distribution**: + - Violations are distributed across all five boroughs + - High concentration in Manhattan and other high-traffic areas + - 100% coordinate conversion success rate enables comprehensive spatial analysis + +### Implications for Policy & Enforcement + +- **Equipment Safety**: Significant equipment violations indicate need for better bike maintenance education and possibly equipment assistance programs +- **E-bike Regulation**: Different violation patterns for e-bikes may require specialized enforcement approaches +- **Geographic Targeting**: The map visualization can help identify hotspots for focused enforcement efforts + +### Data Quality Notes + +- Successfully mapped 15,000 violations with complete coordinate data +- Comprehensive violation code lookup table created for future analysis +- Normalized violation categories enable consistent analysis across bike types + """), + vm.Table(figure=violations_summary_table(bike_violations_with_desc)) + ], + controls=[ + vm.Filter(column="VEH_CATEGORY"), + ]) + +dashboard = vm.Dashboard(pages=[page]) +Vizro().build(dashboard).run(port=56463)