Mito

https://docs.trymito.io
Admin
Mito is a set of Jupyter extensions that automates repetitive Excel reports and accelerates Python...
Tokens:63,290
Snippets:735
Trust Score:8.8
Update:10 months ago
Show doc for...
Tokens:
Raw
### Example Dockerfile with Mito Installation

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-in-a-docker-container

A minimal Dockerfile example that sets up a Jupyter minimal notebook environment and installs Mito and its dependencies. This uses a base Jupyter image and installs 'mito-ai' and 'mitosheet' via pip.

```dockerfile
# Use the official Jupyter minimal notebook as the base image
FROM quay.io/jupyter/minimal-notebook:latest

# Install Python packages
RUN pip install --no-cache-dir mito-ai mitosheet
```

--------------------------------

### Streamlit Example: Interactive Spreadsheet Analysis

Source: https://docs.trymito.io/mito-for-streamlit/api-reference/runnableanalysis-class

This comprehensive Streamlit example showcases a complete workflow. It initializes a spreadsheet, dynamically generates input fields (text inputs for exports, file uploaders for imports) based on analysis parameters, and provides a button to re-run the analysis with the updated inputs. Ensure a 'datasets' folder exists for file imports.

```python
import streamlit as st
import pandas as pd 
from mitosheet.streamlit.v1 import spreadsheet

# Set the streamlit page to wide so you can see the whole spreadsheet
st.set_page_config(layout="wide")

# Create an empty spreadsheet
analysis = spreadsheet(
    import_folder='datasets',
    return_type='analysis'
)

# Create an object to store the new values for the parameters
updated_metadata = {}

# Loop through the parameters in the analysis to display imports
for idx, param in enumerate(analysis.get_param_metadata()):
    new_param = None

    # For imports that are exports, display a text input
    if param['subtype'] in ['file_name_export_excel', 'file_name_export_csv']:
        new_param = st.text_input(param['name'], value=param['initial_value'], key=idx)
        
    # For imports that are file imports, display a file uploader
    elif param['subtype'] in ['file_name_import_excel', 'file_name_import_csv']:
        new_param = st.file_uploader(param['name'], key=idx)
    
    if new_param is not None:
        updated_metadata[param['name']] = new_param

# Show a button to trigger re-running the analysis with the updated_metadata
run = st.button('Run')
if run:
    result = analysis.run(**updated_metadata)
    st.write(result)
```

--------------------------------

### Example .env file content

Source: https://docs.trymito.io/mito-ai/configuring-ai-provider-keys

An example of the content for a `.env` file used to store environment variables, such as API keys and model names. This file should be placed in the Jupyter config directory.

```dotenv
GEMINI_API_KEY=your-api-key-here
GEMINI_MODEL=gemini-2.0-flash
```

--------------------------------

### Install Mito for Dash using Pip

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-for-dash

Installs the 'mitosheet' and 'dash' packages required for Mito for Dash. This command should be run in a terminal, command prompt, or Anaconda Prompt.

```bash
pip install mitosheet dash
```

--------------------------------

### Install Mito AI and Mitosheet using pip

Source: https://docs.trymito.io/mito-ai/data-copilot

This command installs the Mito AI and Mitosheet packages. Ensure you have a virtual environment set up before running this command. No specific inputs or outputs are defined, but it's a prerequisite for using Mito AI features.

```shell
pip install mito-ai mitosheet
```

--------------------------------

### Create New Mitosheet with Python

Source: https://docs.trymito.io/how-to/creating-a-mitosheet

This code snippet imports the mitosheet library and initializes a new Mitosheet. Ensure the mitosheet library is installed in your environment before running this code. It is the primary method for starting a new data analysis session with Mito.

```python
import mitosheet
mitosheet.sheet()
```

--------------------------------

### Interactive Mito Spreadsheet Example with Dash

Source: https://docs.trymito.io/mito-for-dash/api-reference

This example shows how to use the `@mito_callback` decorator to subscribe to `spreadsheet_result` changes in a Mito spreadsheet within a Dash application. It displays the generated code, selection, and dataframes from the spreadsheet result. Dependencies include `mitosheet`, `dash`, and `pandas`.

```python
from mitosheet.mito_dash.v1 import Spreadsheet, mito_callback, activate_mito
from dash import Dash, html, Input, Output, State
import pandas as pd

app = Dash(__name__)
activate_mito(app)

df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder2007.csv')

app.layout = html.Div([
    html.H1('Simple Mito Example'),
    Spreadsheet(df, id={'type': 'spreadsheet', 'id': 'sheet'}),
    html.Div(id='output')
])

@mito_callback(
    Output('output', 'children'),
    Input({'type': 'spreadsheet', 'id': 'sheet'}, 'spreadsheet_result'),
)
def update_output(spreadsheet_result):
    return html.Div([
        html.H3('Spreadsheet Result'),
        html.Code(f'Code: {spreadsheet_result.code()}', style={'whiteSpace': 'pre-wrap'}),
        html.Div(f'Selection: {spreadsheet_result.selection()}'),
        html.Div(f'Dataframes: {spreadsheet_result.dfs()}')
    ])

if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Install Microsoft SQL Server ODBC Driver on macOS

Source: https://docs.trymito.io/mito-ai/database-connectors/microsoft-sql-server

Installs the Microsoft SQL Server ODBC driver and related tools on macOS using Homebrew. This process includes installing Homebrew itself if it's not already present. Ensure you have administrative privileges for installation.

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
brew tap microsoft/mssql-release https://github.com/Microsoft/homebrew-mssql-release
brew update
HOMEBREW_ACCEPT_EULA=Y brew install msodbcsql18 mssql-tools18
```

--------------------------------

### Import Mito and Dash Libraries

Source: https://docs.trymito.io/mito-for-dash/your-first-dash-app-with-mito

Imports necessary modules from the Dash and Mito libraries for creating interactive web applications. Ensure Mito for Dash is installed before running.

```python
from dash import Dash, callback, Input, Output, html, dcc
from mitosheet.mito_dash.v1 import Spreadsheet, mito_callback, activate_mito
```

--------------------------------

### Create a Dash App Instance

Source: https://docs.trymito.io/mito-for-dash/dash-overview

This Python code snippet shows how to create a basic Dash application instance. It imports the `Dash` class and initializes a new app. This is the foundational step before defining the layout or callbacks. Running this code starts a blank web server.

```python
from dash import Dash
app = Dash(__name__)

# Code elided from above

if __name__ == '__main__':
    app.run(debug=True)
```

--------------------------------

### Initialize Dash App and Activate Mito

Source: https://docs.trymito.io/mito-for-dash/your-first-dash-app-with-mito

Initializes a Dash application instance and activates Mito's spreadsheet functionality. This setup is crucial for Mito to integrate correctly within the Dash application.

```python
app = Dash(__name__)
activate_mito(app)
```

--------------------------------

### Creating an Empty Mito Spreadsheet in Dash

Source: https://docs.trymito.io/mito-for-dash/api-reference

This example illustrates how to initialize an empty Mito spreadsheet component within a Dash application. It requires the `mitosheet` and `dash` libraries. The `activate_mito(app)` function is called to enable Mito's functionality.

```python
from mitosheet.mito_dash.v1 import Spreadsheet, activate_mito
from dash import Dash, html
import pandas as pd

app = Dash(__name__)
activate_mito(app)

app.layout = html.Div([
    html.H1('Empty Mito Spreadsheet'),
    Spreadsheet(id={'type': 'spreadsheet', 'id': 'sheet'})
])

if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Install Mito Extensions in Anaconda Navigator Terminal

Source: https://docs.trymito.io/getting-started/installing-mito/setting-up-a-virtual-environment

This command installs the mitosheet and mito-ai Python packages. It should be run within the terminal of a newly created Anaconda virtual environment after it has been activated.

```bash
python -m pip install mitosheet mito-ai
```

--------------------------------

### Install Mito on The Littlest JupyterHub (TLJH)

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-in-jupyterhub

To install Mito on The Littlest JupyterHub (TLJH), use the provided pip command with sudo privileges. This ensures the packages are installed system-wide for user environments, following TLJH's user environment customization guide.

```shell
sudo -E pip install mito-ai mitosheet
```

--------------------------------

### Install Mito in Container-based JupyterHub Servers

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-in-jupyterhub

For containerized user servers in JupyterHub (like DockerSpawner, KubeSpawner, or Z2JH), add this command to your Dockerfile. It installs the mito-ai and mitosheet packages using pip, with caching disabled for cleaner builds.

```dockerfile
RUN pip install --no-cache-dir mito-ai mitosheet
```

--------------------------------

### Simplest Interactive Dash Application Example

Source: https://docs.trymito.io/mito-for-dash/dash-overview

This Python code demonstrates the simplest interactive Dash application. It initializes a Dash app, defines a layout with a dropdown and a graph, and uses a callback to update the graph based on the dropdown selection. It requires the `dash` and `plotly` libraries.

```python
from dash import Dash, html, dcc, callback, Output, Input
import plotly.express as px
import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')

# (1) The Dash App instance
app = Dash(__name__)

# (2) The app layout
app.layout = html.Div([
    html.H1(children='Title of Dash App', style={'textAlign':'center'})
    dcc.Dropdown(df.country.unique(), 'Canada', id='dropdown-selection'),
    dcc.Graph(id='graph-content')
])

# (3) A callback
@callback(
    Output('graph-content', 'figure'),
    Input('dropdown-selection', 'value')
)
def update_graph(value):
    dff = df[df.country==value]
    return px.line(dff, x='year', y='pop')

if __name__ == '__main__':
    app.run(debug=True)
```

--------------------------------

### Pin Mito Version in Dockerfile

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-in-a-docker-container

Demonstrates the best practice of pinning a specific version of Mito when installing it in a Docker container. This ensures that your container builds are reproducible and avoid unexpected behavior from future package updates. Version pinning is crucial for stability.

```shell
RUN pip install --no-cache-dir mito-ai==0.1.52
```

--------------------------------

### Create and Activate Default Python Virtual Environment

Source: https://docs.trymito.io/getting-started/installing-mito/setting-up-a-virtual-environment

This snippet shows how to create a new Python virtual environment named 'mitoenv' and then activate it on both Windows and Mac operating systems. Activating the environment is crucial before installing any packages to ensure they are isolated.

```bash
python -m venv mitoenv
```

```bash
mitoenv\Scripts\activate.bat
```

```bash
source mitoenv/bin/activate
```

--------------------------------

### Initialize Streamlit App with Mito

Source: https://docs.trymito.io/mito-for-streamlit/create-a-mito-for-streamlit-app

Initializes a Streamlit application and imports necessary libraries for using the Mito spreadsheet. It sets the page layout to wide and defines the application's title. This is the basic setup for any Mito-powered Streamlit app.

```python
import streamlit as st
from mitosheet.streamlit.v1 import spreadsheet

st.set_page_config(layout="wide")
st.title('Tesla Stock Volume Analysis')
```

--------------------------------

### Wrapper for Custom Functions to Ensure Capitalization

Source: https://docs.trymito.io/how-to/interacting-with-your-data/bring-your-own-spreadsheet-functions

This example shows how to create a wrapper function to ensure that custom spreadsheet functions adhere to the requirement of being fully capitalized. This is necessary if your original Python function is not named in uppercase.

```python
def MY_FUNCTION(*args, **kwargs):
    return my_functions(*args, **kwargs)
```

--------------------------------

### Displaying Dataframe for Editing in Mito Spreadsheet

Source: https://docs.trymito.io/mito-for-dash/api-reference

This example demonstrates how to load a Pandas DataFrame into a Mito spreadsheet for editing within a Dash application. It uses the `@mito_callback` decorator to display the edited dataframes. The `Spreadsheet` component is initialized with a DataFrame, and the `spreadsheet_result` prop is used to access the modified data.

```python
from mitosheet.mito_dash.v1 import Spreadsheet, mito_callback, activate_mito
from dash import Dash, html, Input, Output, State
import pandas as pd

app = Dash(__name__)
activate_mito(app)

df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder2007.csv')

app.layout = html.Div([
    html.H1('Simple Dataframe Editing Example'),
    Spreadsheet(df, id={'type': 'spreadsheet', 'id': 'sheet'}),
    html.Div(id='output')
])

@mito_callback(
    Output('output', 'children'),
    Input({'type': 'spreadsheet', 'id': 'sheet'}, 'spreadsheet_result'),
)
def update_output(spreadsheet_result):
    return html.Div([
        html.H3('Edited Dataframes'),
        html.Div(f'Dataframes: {spreadsheet_result.dfs()}')
    ])

if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Set Mito Spreadsheet Theme with Python

Source: https://docs.trymito.io/mito-for-dash/common-design-patterns/set-mito-spreadsheet-theme

This example shows how to customize the visual theme of a Mito spreadsheet in a Dash application. It uses the 'theme' argument to define primary color, background color, secondary background color, and text color. Requires pandas, dash, and mitosheet libraries.

```python
from mitosheet.mito_dash.v1 import Spreadsheet, activate_mito
from dash import Dash, html
import pandas as pd

app = Dash(__name__)
activate_mito(app)

df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder2007.csv')

app.layout = html.Div([
    html.H1('Simple Theme Example'),
    Spreadsheet(
        df, 
        id={'type': 'spreadsheet', 'id': 'sheet'},
        theme={
            'primaryColor': '#f5c107',
            'backgroundColor': '#0f0f0f',
            'secondaryBackgroundColor': '#515251',
            'textColor': '#ffffff'
        }
    ),
])

if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### STARTOFMONTH Function: Get First Day of Month

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

The STARTOFMONTH function returns the first day of the month for a given date. For example, an input of '12-22-1997' will return '12-01-1997'. It takes a date or date series as input.

```Mito Formula
STARTOFMONTH(date_column)
STARTOFMONTH('2012-12-22 09:23:05')
```

--------------------------------

### STARTOFBUSINESSMONTH Function: Get First Business Day of Month

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

The STARTOFBUSINESSMONTH function returns the most recent start of the business month for a given date. It considers weekdays and excludes weekends. Accepts a date or date series.

```Mito Formula
STARTOFBUSINESSMONTH(date_column)
STARTOFBUSINESSMONTH('2012-12-22 09:23:05')
```

--------------------------------

### Python: Dynamically Update Mito Spreadsheet Data with Dash

Source: https://docs.trymito.io/mito-for-dash/common-design-patterns/refresh-sheet-data-periodically

This example demonstrates how to refresh Mito spreadsheet data at a set interval using Dash. It utilizes `dcc.Interval` to trigger updates and a callback function to fetch new data and return it in the correct format for the spreadsheet. Ensure 'dash', 'pandas', and 'mitosheet' are installed.

```python
from dash import Dash, callback, Input, Output, html, dcc
from mitosheet.mito_dash.v1 import Spreadsheet, mito_callback, activate_mito
import pandas as pd

app = Dash(__name__)
activate_mito(app)

app.layout = html.Div([
    html.H1("Data Changer", style={'color': 'white'}),
    dcc.Interval(id='interval1', interval=5 * 1000, n_intervals=0),
    Spreadsheet(id={'type': 'spreadsheet', 'id': 'sheet'})
])

@callback(
    Output({'type': 'spreadsheet', 'id': 'sheet'}, 'data'),
    Input('interval1', 'n_intervals')
)
def update_spreadsheet_data(n_intervals):
    # Get new df data here
    df = pd.DataFrame({'First Data': [1, 2, 3], 'Second Data': [4, 5, 6]})
    return df.to_dict('records')

if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Install Mito in Dockerfile

Source: https://docs.trymito.io/getting-started/installing-mito/installing-mito-in-a-docker-container

Installs the Mito Python package using pip within a Dockerfile. This command is added to your Dockerfile to ensure Mito is available in the container's environment. It utilizes the '--no-cache-dir' flag to reduce image size.

```shell
RUN pip install --no-cache-dir mito
```

--------------------------------

### Complete Dash App Code with Mito Integration

Source: https://docs.trymito.io/mito-for-dash/your-first-dash-app-with-mito

Combines all the necessary components for a functional Dash application with Mito integration. This script initializes the app, sets up the layout with a Mito spreadsheet, and includes a callback to display generated code upon user interaction within the spreadsheet.

```python
from dash import Dash, Input, Output, html
from mitosheet.mito_dash.v1 import Spreadsheet, mito_callback, activate_mito

app = Dash(__name__)
activate_mito(app)

CSV_URL = 'https://raw.githubusercontent.com/plotly/datasets/master/tesla-stock-price.csv'

app.layout = html.Div([
    html.H1("Stock Analysis"),
    Spreadsheet(CSV_URL, id={'type': 'spreadsheet', 'id': 'sheet'}),
    html.Div(id='output')
])

@mito_callback(
    Output('output', 'children'),
    Input({'type': 'spreadsheet', 'id': 'sheet'}, 'spreadsheet_result'),
)
def update_code(spreadsheet_result):
    return html.Div([
        html.Code(spreadsheet_result.code())
    ])
    
if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Setting Gemini API Key and Model (Windows)

Source: https://docs.trymito.io/mito-ai/configuring-ai-provider-keys

Demonstrates how to set environment variables for Gemini API key and model on Windows systems. These variables are read during Mito server extension initialization.

```batch
set GEMINI_API_KEY=your-api-key-here
set GEMINI_MODEL=gemini-2.0-flash
```

--------------------------------

### Run Dash Development Server

Source: https://docs.trymito.io/mito-for-dash/your-first-dash-app-with-mito

Configures and runs the Dash development server. When executed, this script will launch the web application, typically accessible via http://127.0.0.1:8050/. Debug mode is enabled for easier development.

```python
if __name__ == '__main__':
    app.run_server(debug=True)
```

--------------------------------

### Setting Gemini API Key and Model (macOS/Linux)

Source: https://docs.trymito.io/mito-ai/configuring-ai-provider-keys

Demonstrates how to set environment variables for Gemini API key and model on macOS and Linux systems using the `export` command. These variables are crucial for Mito's AI integrations.

```bash
export GEMINI_API_KEY=your-api-key-here
export GEMINI_MODEL=gemini-2.0-flash
```

--------------------------------

### Get String Length with LEN

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

Calculates and returns the total number of characters in a given string or series.

```mitoscript
LEN(A)
LEN('This is 21 characters')
```

--------------------------------

### Activate Python Virtual Environment and Launch JupyterLab (Mac)

Source: https://docs.trymito.io/how-to/creating-a-mitosheet/open-existing-virtual-environments

Activates a Python virtual environment on macOS using the 'source' command and then launches JupyterLab. This prepares the environment for using Mito.

```shell
source mitoenv/bin/activate
jupyter lab
```

--------------------------------

### Extract Mid Substring with MID

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

Extracts a segment of characters from a string, starting at a specified position and for a defined length. Indices are 1-based.

```mitoscript
MID(A, 2, 2)
MID('Some middle characters!', 3, 4)
```

--------------------------------

### Loading Environment Variables from .env file (Python)

Source: https://docs.trymito.io/mito-ai/configuring-ai-provider-keys

Shows how to load environment variables from a `.env` file using Python's `dotenv` library within the `jupyter_server_config.py` file. This method is useful for managing sensitive API keys.

```python
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv('/path/to/your/.env')
```

--------------------------------

### STRIPTIMETOYEARS Function: Adjust Date to Start of Year

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

The STRIPTIMETOYEARS function adjusts a date to the beginning of the year. It accepts a date or a series of dates.

```Mito Formula
STRIPTIMETOYEARS(date_column)
STRIPTIMETOYEARS('2012-12-22 09:23:05')
```

--------------------------------

### Import Python Packages for Mito

Source: https://docs.trymito.io/how-to-1/pass-a-dataframe-into-mito

This snippet imports the necessary Python libraries, `mitosheet` and `pandas`, which are required for using Mito and manipulating DataFrames. Ensure both packages are installed before running this code.

```python
import mitosheet 
import pandas as pd
```

--------------------------------

### Store and Load Analysis Configurations

Source: https://docs.trymito.io/mito-for-streamlit/api-reference/runnableanalysis-class

Utilizes the `to_json` and `from_json` methods for persistent storage and retrieval of the analysis object, simplifying the process of saving and loading analysis states.

```python
import streamlit as st
from mitosheet.streamlit.v1 import spreadsheet

# Set the streamlit page to wide so you can see the whole spreadsheet
st.set_page_config(layout="wide")

# Placeholder for analysis object creation and subsequent to_json/from_json usage
# Example:
# analysis = spreadsheet(return_type='analysis')
# analysis_json = analysis.to_json()
# loaded_analysis = spreadsheet().from_json(analysis_json)
```

--------------------------------

### Get Previous Value with GETPREVIOUSVALUE

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

Retrieves a value from a series based on a specified condition. The function returns a value from the series that meets the condition, and this value is carried forward until the condition is met again.

```mitoscript
GETPREVIOUSVALUE(Max_Balances, Max_Balances > 0)
```

--------------------------------

### YEAR: Get Year from Date

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

The YEAR function extracts the year component from a given date or date series. This is fundamental for time-series analysis, allowing data to be grouped or filtered by year.

```mitoscript
YEAR(date_column)
YEAR('2012-12-22')
```

--------------------------------

### Activate Python Virtual Environment and Launch JupyterLab (Windows)

Source: https://docs.trymito.io/how-to/creating-a-mitosheet/open-existing-virtual-environments

Activates a Python virtual environment on Windows using a batch script and then launches JupyterLab. This is necessary to run Mito within its isolated environment.

```shell
mitoenv\Scripts\activate.bat
jupyter lab
```

--------------------------------

### Create and Activate Conda Virtual Environment

Source: https://docs.trymito.io/getting-started/installing-mito/setting-up-a-virtual-environment

This section demonstrates how to create a new Conda environment named 'mitoenv' with a specific Python version (3.10) and then how to activate it. Using Conda environments is another common method for managing project dependencies.

```bash
conda create -n mitoenv python=3.10
```

```bash
conda activate mitoenv
```

--------------------------------

### STRIPTIMETOMONTHS Function: Adjust Date to Start of Month

Source: https://docs.trymito.io/how-to/interacting-with-your-data/mito-spreadsheet-formulas

The STRIPTIMETOMONTHS function adjusts a date to the beginning of the month, resetting hours, minutes, seconds, and days. It accepts a date or a series of dates.

```Mito Formula
STRIPTIMETOMONTHS(date_column)
STRIPTIMETOMONTHS('2012-12-22 09:23:05')
```

--------------------------------

### Python Code Options Configuration

Source: https://docs.trymito.io/how-to/code-options

This snippet demonstrates how to configure code generation options in Python for Mito. It shows how to set parameters like generating code as a function, its name, whether to call it, its parameters, and whether to import custom Python code.

```python
{
    'as_function': True, 
    'call_function': True, 
    'function_name': 'my_function',
    'function_params': {'file_path': "original_data.csv"},
    'import_custom_python_code': False, 
}
```

--------------------------------

### Configure Gemini API Key and Model

Source: https://docs.trymito.io/misc/release-notes/may-28-just-a-query-away

Set environment variables to utilize Google's Gemini models with Mito AI. Ensure both GEMINI_API_KEY and GEMINI_MODEL are correctly configured for successful integration. This enables leveraging Gemini's capabilities within the Mito AI platform.

```shell
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
export GEMINI_MODEL="gemini-pro"
```

--------------------------------

### Create and Serialize Spreadsheet Analysis to JSON

Source: https://docs.trymito.io/mito-for-streamlit/api-reference/runnableanalysis-class

This snippet shows how to initialize a spreadsheet object with the 'analysis' return type and then convert it into a JSON string. The resulting JSON may contain sensitive information and should be stored securely.

```python
from mitosheet.streamlit.v1 import spreadsheet

# Create the spreadsheet with return type 'analysis'
analysis = spreadsheet(return_type='analysis')

analysis_json = analysis.to_json()

# Store analysis_json somewhere. Note that it should be stored securely, as it
# may contain code that edits private data
```
Tokens:
Raw