acecalisto3/PhiCo-D-Instruck
Text2Text Generation
•
Updated
•
8
id
stringlengths 14
15
| text
stringlengths 273
1.89k
| source
stringclasses 1
value |
|---|---|---|
e4409cd96e13-0 | search
Search
⌘K
dark_mode
light_mode
menu
Home/
Streamlit library/
Get started/
Main concepts
Main concepts
Working with Streamlit is simple. First you sprinkle a few Streamlit commands into a normal Python script, then you run it with streamlit run:
streamlit run your_script.py [-- script args]
Copy
As soon as you run the script as shown above, a local Streamlit server will spin up and your app will open in a new tab in your default web browser. The app is your canvas, where you'll draw charts, text, widgets, tables, and more.
What gets drawn in the app is up to you. For example st.text writes raw text to your app, and st.line_chart draws — you guessed it — a line chart. Refer to our API documentation to see all commands that are available to you.
push_pin
Note
When passing your script some custom arguments, they must be passed after two dashes. Otherwise the arguments get interpreted as arguments to Streamlit itself.
Another way of running Streamlit is to run it as a Python module. This can be useful when configuring an IDE like PyCharm to work with Streamlit:
# Running
python -m streamlit run your_script.py
# is equivalent to:
streamlit run your_script.py
Copy
star
Tip
You can also pass a URL to streamlit run! This is great when combined with GitHub Gists. For example:
streamlit run https://raw.githubusercontent.com/streamlit/demo-uber-nyc-pickups/master/streamlit_app.py
Copy
Development flow | streamlit-docs.txt |
e4409cd96e13-1 | Every time you want to update your app, save the source file. When you do that, Streamlit detects if there is a change and asks you whether you want to rerun your app. Choose "Always rerun" at the top-right of your screen to automatically update your app every time you change its source code.
This allows you to work in a fast interactive loop: you type some code, save it, try it out live, then type some more code, save it, try it out, and so on until you're happy with the results. This tight loop between coding and viewing results live is one of the ways Streamlit makes your life easier.
star
Tip
While developing a Streamlit app, it's recommended to lay out your editor and browser windows side by side, so the code and the app can be seen at the same time. Give it a try!
As of Streamlit version 1.10.0 and higher, Streamlit apps cannot be run from the root directory of Linux distributions. If you try to run a Streamlit app from the root directory, Streamlit will throw a FileNotFoundError: [Errno 2] No such file or directory error. For more information, see GitHub issue #5239.
If you are using Streamlit version 1.10.0 or higher, your main script should live in a directory other than the root directory. When using Docker, you can use the WORKDIR command to specify the directory where your main script lives. For an example of how to do this, read Create a Dockerfile.
Data flow
Streamlit's architecture allows you to write apps the same way you write plain Python scripts. To unlock this, Streamlit apps have a unique data flow: any time something must be updated on the screen, Streamlit reruns your entire Python script from top to bottom.
This can happen in two situations:
Whenever you modify your app's source code. | streamlit-docs.txt |
e4409cd96e13-2 | This can happen in two situations:
Whenever you modify your app's source code.
Whenever a user interacts with widgets in the app. For example, when dragging a slider, entering text in an input box, or clicking a button.
Whenever a callback is passed to a widget via the on_change (or on_click) parameter, the callback will always run before the rest of your script. For details on the Callbacks API, please refer to our Session State API Reference Guide.
And to make all of this fast and seamless, Streamlit does some heavy lifting for you behind the scenes. A big player in this story is the @st.cache_data decorator, which allows developers to skip certain costly computations when their apps rerun. We'll cover caching later in this page.
Display and style data
There are a few ways to display data (tables, arrays, data frames) in Streamlit apps. Below, you will be introduced to magic and st.write(), which can be used to write anything from text to tables. After that, let's take a look at methods designed specifically for visualizing data.
Use magic
You can also write to your app without calling any Streamlit methods. Streamlit supports "magic commands," which means you don't have to use st.write() at all! To see this in action try this snippet:
"""
# My first app
Here's our first attempt at using data to create a table:
"""
import streamlit as st
import pandas as pd
df = pd.DataFrame({
'first column': [1, 2, 3, 4],
'second column': [10, 20, 30, 40]
})
df
Copy
Any time that Streamlit sees a variable or a literal value on its own line, it automatically writes that to your app using st.write(). For more information, refer to the documentation on magic commands.
Write a data frame | streamlit-docs.txt |
e4409cd96e13-3 | Write a data frame
Along with magic commands, st.write() is Streamlit's "Swiss Army knife". You can pass almost anything to st.write(): text, data, Matplotlib figures, Altair charts, and more. Don't worry, Streamlit will figure it out and render things the right way.
import streamlit as st
import pandas as pd
st.write("Here's our first attempt at using data to create a table:")
st.write(pd.DataFrame({
'first column': [1, 2, 3, 4],
'second column': [10, 20, 30, 40]
}))
Copy
There are other data specific functions like st.dataframe() and st.table() that you can also use for displaying data. Let's understand when to use these features and how to add colors and styling to your data frames.
You might be asking yourself, "why wouldn't I always use st.write()?" There are a few reasons:
Magic and st.write() inspect the type of data that you've passed in, and then decide how to best render it in the app. Sometimes you want to draw it another way. For example, instead of drawing a dataframe as an interactive table, you may want to draw it as a static table by using st.table(df).
The second reason is that other methods return an object that can be used and modified, either by adding data to it or replacing it.
Finally, if you use a more specific Streamlit method you can pass additional arguments to customize its behavior.
For example, let's create a data frame and change its formatting with a Pandas Styler object. In this example, you'll use Numpy to generate a random sample, and the st.dataframe() method to draw an interactive table.
push_pin
Note | streamlit-docs.txt |
e4409cd96e13-4 | push_pin
Note
This example uses Numpy to generate a random sample, but you can use Pandas DataFrames, Numpy arrays, or plain Python arrays.
import streamlit as st
import numpy as np
dataframe = np.random.randn(10, 20)
st.dataframe(dataframe)
Copy
Let's expand on the first example using the Pandas Styler object to highlight some elements in the interactive table.
import streamlit as st
import numpy as np
import pandas as pd
dataframe = pd.DataFrame(
np.random.randn(10, 20),
columns=('col %d' % i for i in range(20)))
st.dataframe(dataframe.style.highlight_max(axis=0))
Copy
Streamlit also has a method for static table generation: st.table().
import streamlit as st
import numpy as np
import pandas as pd
dataframe = pd.DataFrame(
np.random.randn(10, 20),
columns=('col %d' % i for i in range(20)))
st.table(dataframe)
Copy
Draw charts and maps
Streamlit supports several popular data charting libraries like Matplotlib, Altair, deck.gl, and more. In this section, you'll add a bar chart, line chart, and a map to your app.
Draw a line chart
You can easily add a line chart to your app with st.line_chart(). We'll generate a random sample using Numpy and then chart it.
import streamlit as st
import numpy as np
import pandas as pd
chart_data = pd.DataFrame(
np.random.randn(20, 3),
columns=['a', 'b', 'c'])
st.line_chart(chart_data)
Copy
Plot a map
With st.map() you can display data points on a map. Let's use Numpy to generate some sample data and plot it on a map of San Francisco. | streamlit-docs.txt |
e4409cd96e13-5 | import streamlit as st
import numpy as np
import pandas as pd
map_data = pd.DataFrame(
np.random.randn(1000, 2) / [50, 50] + [37.76, -122.4],
columns=['lat', 'lon'])
st.map(map_data)
Copy
Widgets
When you've got the data or model into the state that you want to explore, you can add in widgets like st.slider(), st.button() or st.selectbox(). It's really straightforward — treat widgets as variables:
import streamlit as st
x = st.slider('x') # 👈 this is a widget
st.write(x, 'squared is', x * x)
Copy
On first run, the app above should output the text "0 squared is 0". Then every time a user interacts with a widget, Streamlit simply reruns your script from top to bottom, assigning the current state of the widget to your variable in the process.
For example, if the user moves the slider to position 10, Streamlit will rerun the code above and set x to 10 accordingly. So now you should see the text "10 squared is 100".
Widgets can also be accessed by key, if you choose to specify a string to use as the unique key for the widget:
import streamlit as st
st.text_input("Your name", key="name")
# You can access the value at any point with:
st.session_state.name
Copy
Every widget with a key is automatically added to Session State. For more information about Session State, its association with widget state, and its limitations, see Session State API Reference Guide.
Use checkboxes to show/hide data | streamlit-docs.txt |
e4409cd96e13-6 | Use checkboxes to show/hide data
One use case for checkboxes is to hide or show a specific chart or section in an app. st.checkbox() takes a single argument, which is the widget label. In this sample, the checkbox is used to toggle a conditional statement.
import streamlit as st
import numpy as np
import pandas as pd
if st.checkbox('Show dataframe'):
chart_data = pd.DataFrame(
np.random.randn(20, 3),
columns=['a', 'b', 'c'])
chart_data
Copy
Use a selectbox for options
Use st.selectbox to choose from a series. You can write in the options you want, or pass through an array or data frame column.
Let's use the df data frame we created earlier.
import streamlit as st
import pandas as pd
df = pd.DataFrame({
'first column': [1, 2, 3, 4],
'second column': [10, 20, 30, 40]
})
option = st.selectbox(
'Which number do you like best?',
df['first column'])
'You selected: ', option
Copy
Layout
Streamlit makes it easy to organize your widgets in a left panel sidebar with st.sidebar. Each element that's passed to st.sidebar is pinned to the left, allowing users to focus on the content in your app while still having access to UI controls.
For example, if you want to add a selectbox and a slider to a sidebar, use st.sidebar.slider and st.sidebar.selectbox instead of st.slider and st.selectbox:
import streamlit as st
# Add a selectbox to the sidebar:
add_selectbox = st.sidebar.selectbox(
'How would you like to be contacted?',
('Email', 'Home phone', 'Mobile phone')
) | streamlit-docs.txt |
e4409cd96e13-7 | # Add a slider to the sidebar:
add_slider = st.sidebar.slider(
'Select a range of values',
0.0, 100.0, (25.0, 75.0)
)
Copy
Beyond the sidebar, Streamlit offers several other ways to control the layout of your app. st.columns lets you place widgets side-by-side, and st.expander lets you conserve space by hiding away large content.
import streamlit as st
left_column, right_column = st.columns(2)
# You can use a column just like st.sidebar:
left_column.button('Press me!')
# Or even better, call Streamlit functions inside a "with" block:
with right_column:
chosen = st.radio(
'Sorting hat',
("Gryffindor", "Ravenclaw", "Hufflepuff", "Slytherin"))
st.write(f"You are in {chosen} house!")
Copy
push_pin
Note
st.echo and st.spinner are not currently supported inside the sidebar or layout options. Rest assured, though, we're currently working on adding support for those too!
Show progress
When adding long running computations to an app, you can use st.progress() to display status in real time.
First, let's import time. We're going to use the time.sleep() method to simulate a long running computation:
import time
Copy
Now, let's create a progress bar:
import streamlit as st
import time
'Starting a long computation...'
# Add a placeholder
latest_iteration = st.empty()
bar = st.progress(0)
for i in range(100):
# Update the progress bar with each iteration.
latest_iteration.text(f'Iteration {i+1}')
bar.progress(i + 1)
time.sleep(0.1)
'...and now we\'re done!'
Copy
Themes | streamlit-docs.txt |
e4409cd96e13-8 | '...and now we\'re done!'
Copy
Themes
Streamlit supports Light and Dark themes out of the box. Streamlit will first check if the user viewing an app has a Light or Dark mode preference set by their operating system and browser. If so, then that preference will be used. Otherwise, the Light theme is applied by default.
You can also change the active theme from "☰" → "Settings".
Want to add your own theme to an app? The "Settings" menu has a theme editor accessible by clicking on "Edit active theme". You can use this editor to try out different colors and see your app update live.
When you're happy with your work, themes can be saved by setting config options in the [theme] config section. After you've defined a theme for your app, it will appear as "Custom Theme" in the theme selector and will be applied by default instead of the included Light and Dark themes.
More information about the options available when defining a theme can be found in the theme option documentation.
push_pin
Note
The theme editor menu is available only in local development. If you've deployed your app using Streamlit Community Cloud, the "Edit active theme" button will no longer be displayed in the "Settings" menu.
star
Tip
Another way to experiment with different theme colors is to turn on the "Run on save" option, edit your config.toml file, and watch as your app reruns with the new theme colors applied.
Caching
The Streamlit cache allows your app to stay performant even when loading data from the web, manipulating large datasets, or performing expensive computations.
The basic idea behind caching is to store the results of expensive function calls and return the cached result when the same inputs occur again rather than calling the function on subsequent runs. | streamlit-docs.txt |
e4409cd96e13-9 | To cache a function in Streamlit, you need to decorate it with one of two decorators (st.cache_data and st.cache_resource):
@st.cache_data
def long_running_function(param1, param2):
return …
Copy
In this example, decorating long_running_function with @st.cache_data tells Streamlit that whenever the function is called, it checks two things:
The values of the input parameters (in this case, param1 and param2).
The code inside the function.
If this is the first time Streamlit sees these parameter values and function code, it runs the function and stores the return value in a cache. The next time the function is called with the same parameters and code (e.g., when a user interacts with the app), Streamlit will skip executing the function altogether and return the cached value instead. During development, the cache updates automatically as the function code changes, ensuring that the latest changes are reflected in the cache.
As mentioned, there are two caching decorators:
st.cache_data is the recommended way to cache computations that return data: loading a DataFrame from CSV, transforming a NumPy array, querying an API, or any other function that returns a serializable data object (str, int, float, DataFrame, array, list, …). It creates a new copy of the data at each function call, making it safe against mutations and race conditions. The behavior of st.cache_data is what you want in most cases – so if you're unsure, start with st.cache_data and see if it works!
st.cache_resource is the recommended way to cache global resources like ML models or database connections – unserializable objects that you don’t want to load multiple times. Using it, you can share these resources across all reruns and sessions of an app without copying or duplication. Note that any mutations to the cached return value directly mutate the object in the cache (more details below). | streamlit-docs.txt |
e4409cd96e13-10 | Streamlit's two caching decorators and their use cases.
For more information about the Streamlit caching decorators, their configuration parameters, and their limitations, see Caching.
Pages
As apps grow large, it becomes useful to organize them into multiple pages. This makes the app easier to manage as a developer and easier to navigate as a user. Streamlit provides a frictionless way to create multipage apps.
We designed this feature so that building a multipage app is as easy as building a single-page app! Just add more pages to an existing app as follows:
In the folder containing your main script, create a new pages folder. Let’s say your main script is named main_page.py.
Add new .py files in the pages folder to add more pages to your app.
Run streamlit run main_page.py as usual.
That’s it! The main_page.py script will now correspond to the main page of your app. And you’ll see the other scripts from the pages folder in the sidebar page selector. For example:
main_page.py
import streamlit as st
st.markdown("# Main page 🎈")
st.sidebar.markdown("# Main page 🎈")
Copy
pages/page_2.py
import streamlit as st
st.markdown("# Page 2 ❄️")
st.sidebar.markdown("# Page 2 ❄️")
Copy
pages/page_3.py
import streamlit as st
st.markdown("# Page 3 🎉")
st.sidebar.markdown("# Page 3 🎉")
Copy
Now run streamlit run main_page.py and view your shiny new multipage app!
Our documentation on Multipage apps teaches you how to add pages to your app, including how to define pages, structure and run multipage apps, and navigate between pages. Once you understand the basics, create your first multipage app!
App model | streamlit-docs.txt |
e4409cd96e13-11 | App model
Now that you know a little more about all the individual pieces, let's close the loop and review how it works together:
Streamlit apps are Python scripts that run from top to bottom
Every time a user opens a browser tab pointing to your app, the script is re-executed
As the script executes, Streamlit draws its output live in a browser
Scripts use the Streamlit cache to avoid recomputing expensive functions, so updates happen very fast
Every time a user interacts with a widget, your script is re-executed and the output value of that widget is set to the new value during that run.
Streamlit apps can contain multiple pages, which are defined in separate .py files in a pages folder.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Installation
Next:
Create an app
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Main concepts - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Get started/
Create an app
Create an app
If you've made it this far, chances are you've installed Streamlit and run through the basics in our Main concepts guide. If not, now is a good time to take a look. | streamlit-docs.txt |
e4409cd96e13-12 | The easiest way to learn how to use Streamlit is to try things out yourself. As you read through this guide, test each method. As long as your app is running, every time you add a new element to your script and save, Streamlit's UI will ask if you'd like to rerun the app and view the changes. This allows you to work in a fast interactive loop: you write some code, save it, review the output, write some more, and so on, until you're happy with the results. The goal is to use Streamlit to create an interactive app for your data or model and along the way to use Streamlit to review, debug, perfect, and share your code.
In this guide, you're going to use Streamlit's core features to create an interactive app; exploring a public Uber dataset for pickups and drop-offs in New York City. When you're finished, you'll know how to fetch and cache data, draw charts, plot information on a map, and use interactive widgets, like a slider, to filter results.
star
Tip
If you'd like to skip ahead and see everything at once, the complete script is available below.
Create your first app
Streamlit is more than just a way to make data apps, it’s also a community of creators that share their apps and ideas and help each other make their work better. Please come join us on the community forum. We love to hear your questions, ideas, and help you work through your bugs — stop by today!
The first step is to create a new Python script. Let's call it uber_pickups.py.
Open uber_pickups.py in your favorite IDE or text editor, then add these lines:
import streamlit as st
import pandas as pd
import numpy as np
Copy
Every good app has a title, so let's add one:
st.title('Uber pickups in NYC')
Copy | streamlit-docs.txt |
e4409cd96e13-13 | st.title('Uber pickups in NYC')
Copy
Now it's time to run Streamlit from the command line:
streamlit run uber_pickups.py
Copy
Running a Streamlit app is no different than any other Python script. Whenever you need to view the app, you can use this command.
star
Tip
Did you know you can also pass a URL to streamlit run? This is great when combined with GitHub Gists. For example:
streamlit run https://raw.githubusercontent.com/streamlit/demo-uber-nyc-pickups/master/streamlit_app.py
Copy
As usual, the app should automatically open in a new tab in your browser.
Fetch some data
Now that you have an app, the next thing you'll need to do is fetch the Uber dataset for pickups and drop-offs in New York City.
Let's start by writing a function to load the data. Add this code to your script:
DATE_COLUMN = 'date/time'
DATA_URL = ('https://s3-us-west-2.amazonaws.com/'
'streamlit-demo-data/uber-raw-data-sep14.csv.gz')
def load_data(nrows):
data = pd.read_csv(DATA_URL, nrows=nrows)
lowercase = lambda x: str(x).lower()
data.rename(lowercase, axis='columns', inplace=True)
data[DATE_COLUMN] = pd.to_datetime(data[DATE_COLUMN])
return data
Copy
You'll notice that load_data is a plain old function that downloads some data, puts it in a Pandas dataframe, and converts the date column from text to datetime. The function accepts a single parameter (nrows), which specifies the number of rows that you want to load into the dataframe.
Now let's test the function and review the output. Below your function, add these lines: | streamlit-docs.txt |
e4409cd96e13-14 | Now let's test the function and review the output. Below your function, add these lines:
# Create a text element and let the reader know the data is loading.
data_load_state = st.text('Loading data...')
# Load 10,000 rows of data into the dataframe.
data = load_data(10000)
# Notify the reader that the data was successfully loaded.
data_load_state.text('Loading data...done!')
Copy
You'll see a few buttons in the upper-right corner of your app asking if you'd like to rerun the app. Choose Always rerun, and you'll see your changes automatically each time you save.
Ok, that's underwhelming...
It turns out that it takes a long time to download data, and load 10,000 lines into a dataframe. Converting the date column into datetime isn’t a quick job either. You don’t want to reload the data each time the app is updated – luckily Streamlit allows you to cache the data.
Effortless caching
Try adding @st.cache_data before the load_data declaration:
@st.cache_data
def load_data(nrows):
Copy
Then save the script, and Streamlit will automatically rerun your app. Since this is the first time you’re running the script with @st.cache_data, you won't see anything change. Let’s tweak your file a little bit more so that you can see the power of caching.
Replace the line data_load_state.text('Loading data...done!') with this:
data_load_state.text("Done! (using st.cache_data)")
Copy
Now save. See how the line you added appeared immediately? If you take a step back for a second, this is actually quite amazing. Something magical is happening behind the scenes, and it only takes one line of code to activate it.
How's it work?
Let's take a few minutes to discuss how @st.cache_data actually works. | streamlit-docs.txt |
e4409cd96e13-15 | Let's take a few minutes to discuss how @st.cache_data actually works.
When you mark a function with Streamlit’s cache annotation, it tells Streamlit that whenever the function is called that it should check two things:
The input parameters you used for the function call.
The code inside the function.
If this is the first time Streamlit has seen both these items, with these exact values, and in this exact combination, it runs the function and stores the result in a local cache. The next time the function is called, if the two values haven't changed, then Streamlit knows it can skip executing the function altogether. Instead, it reads the output from the local cache and passes it on to the caller -- like magic.
"But, wait a second," you’re saying to yourself, "this sounds too good to be true. What are the limitations of all this awesomesauce?"
Well, there are a few:
Streamlit will only check for changes within the current working directory. If you upgrade a Python library, Streamlit's cache will only notice this if that library is installed inside your working directory.
If your function is not deterministic (that is, its output depends on random numbers), or if it pulls data from an external time-varying source (for example, a live stock market ticker service) the cached value will be none-the-wiser.
Lastly, you should avoid mutating the output of a function cached with st.cache_data since cached values are stored by reference.
While these limitations are important to keep in mind, they tend not to be an issue a surprising amount of the time. Those times, this cache is really transformational.
star
Tip
Whenever you have a long-running computation in your code, consider refactoring it so you can use @st.cache_data, if possible. Please read Caching for more details. | streamlit-docs.txt |
e4409cd96e13-16 | Now that you know how caching with Streamlit works, let’s get back to the Uber pickup data.
Inspect the raw data
It's always a good idea to take a look at the raw data you're working with before you start working with it. Let's add a subheader and a printout of the raw data to the app:
st.subheader('Raw data')
st.write(data)
Copy
In the Main concepts guide you learned that st.write will render almost anything you pass to it. In this case, you're passing in a dataframe and it's rendering as an interactive table.
st.write tries to do the right thing based on the data type of the input. If it isn't doing what you expect you can use a specialized command like st.dataframe instead. For a full list, see API reference.
Draw a histogram
Now that you've had a chance to take a look at the dataset and observe what's available, let's take things a step further and draw a histogram to see what Uber's busiest hours are in New York City.
To start, let's add a subheader just below the raw data section:
st.subheader('Number of pickups by hour')
Copy
Use NumPy to generate a histogram that breaks down pickup times binned by hour:
hist_values = np.histogram(
data[DATE_COLUMN].dt.hour, bins=24, range=(0,24))[0]
Copy
Now, let's use Streamlit's st.bar_chart() method to draw this histogram.
st.bar_chart(hist_values)
Copy
Save your script. This histogram should show up in your app right away. After a quick review, it looks like the busiest time is 17:00 (5 P.M.). | streamlit-docs.txt |
e4409cd96e13-17 | To draw this diagram we used Streamlit's native bar_chart() method, but it's important to know that Streamlit supports more complex charting libraries like Altair, Bokeh, Plotly, Matplotlib and more. For a full list, see supported charting libraries.
Plot data on a map
Using a histogram with Uber's dataset helped us determine what the busiest times are for pickups, but what if we wanted to figure out where pickups were concentrated throughout the city. While you could use a bar chart to show this data, it wouldn't be easy to interpret unless you were intimately familiar with latitudinal and longitudinal coordinates in the city. To show pickup concentration, let's use Streamlit st.map() function to overlay the data on a map of New York City.
Add a subheader for the section:
st.subheader('Map of all pickups')
Copy
Use the st.map() function to plot the data:
st.map(data)
Copy
Save your script. The map is fully interactive. Give it a try by panning or zooming in a bit.
After drawing your histogram, you determined that the busiest hour for Uber pickups was 17:00. Let's redraw the map to show the concentration of pickups at 17:00.
Locate the following code snippet:
st.subheader('Map of all pickups')
st.map(data)
Copy
Replace it with:
hour_to_filter = 17
filtered_data = data[data[DATE_COLUMN].dt.hour == hour_to_filter]
st.subheader(f'Map of all pickups at {hour_to_filter}:00')
st.map(filtered_data)
Copy
You should see the data update instantly.
To draw this map we used the st.map function that's built into Streamlit, but if you'd like to visualize complex map data, we encourage you to take a look at the st.pydeck_chart.
Filter results with a slider | streamlit-docs.txt |
e4409cd96e13-18 | Filter results with a slider
In the last section, when you drew the map, the time used to filter results was hardcoded into the script, but what if we wanted to let a reader dynamically filter the data in real time? Using Streamlit's widgets you can. Let's add a slider to the app with the st.slider() method.
Locate hour_to_filter and replace it with this code snippet:
hour_to_filter = st.slider('hour', 0, 23, 17) # min: 0h, max: 23h, default: 17h
Copy
Use the slider and watch the map update in real time.
Use a button to toggle data
Sliders are just one way to dynamically change the composition of your app. Let's use the st.checkbox function to add a checkbox to your app. We'll use this checkbox to show/hide the raw data table at the top of your app.
Locate these lines:
st.subheader('Raw data')
st.write(data)
Copy
Replace these lines with the following code:
if st.checkbox('Show raw data'):
st.subheader('Raw data')
st.write(data)
Copy
We're sure you've got your own ideas. When you're done with this tutorial, check out all the widgets that Streamlit exposes in our API Reference.
Let's put it all together
That's it, you've made it to the end. Here's the complete script for our interactive app.
star
Tip
If you've skipped ahead, after you've created your script, the command to run Streamlit is streamlit run [app name].
import streamlit as st
import pandas as pd
import numpy as np
st.title('Uber pickups in NYC') | streamlit-docs.txt |
e4409cd96e13-19 | st.title('Uber pickups in NYC')
DATE_COLUMN = 'date/time'
DATA_URL = ('https://s3-us-west-2.amazonaws.com/'
'streamlit-demo-data/uber-raw-data-sep14.csv.gz')
@st.cache_data
def load_data(nrows):
data = pd.read_csv(DATA_URL, nrows=nrows)
lowercase = lambda x: str(x).lower()
data.rename(lowercase, axis='columns', inplace=True)
data[DATE_COLUMN] = pd.to_datetime(data[DATE_COLUMN])
return data
data_load_state = st.text('Loading data...')
data = load_data(10000)
data_load_state.text("Done! (using st.cache_data)")
if st.checkbox('Show raw data'):
st.subheader('Raw data')
st.write(data)
st.subheader('Number of pickups by hour')
hist_values = np.histogram(data[DATE_COLUMN].dt.hour, bins=24, range=(0,24))[0]
st.bar_chart(hist_values)
# Some number in the range 0-23
hour_to_filter = st.slider('hour', 0, 23, 17)
filtered_data = data[data[DATE_COLUMN].dt.hour == hour_to_filter]
st.subheader('Map of all pickups at %s:00' % hour_to_filter)
st.map(filtered_data)
Copy
Share your app
After you’ve built a Streamlit app, it's time to share it! To show it off to the world you can use Streamlit Community Cloud to deploy, manage, and share your app for free.
It works in 3 simple steps:
Put your app in a public GitHub repo (and make sure it has a requirements.txt!)
Sign into share.streamlit.io
Click 'Deploy an app' and then paste in your GitHub URL | streamlit-docs.txt |
e4409cd96e13-20 | That's it! 🎈 You now have a publicly deployed app that you can share with the world. Click to learn more about how to use Streamlit Community Cloud.
Get help
That's it for getting started, now you can go and build your own apps! If you run into difficulties here are a few things you can do.
Check out our community forum and post a question
Quick help from command line with streamlit help
Go through our Knowledge Base for tips, step-by-step tutorials, and articles that answer your questions about creating and deploying Streamlit apps.
Read more documentation! Check out:
Advanced features for things like caching, theming, and adding statefulness to apps.
API reference for examples of every Streamlit command.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Main concepts
Next:
Multipage apps
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Create an app - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Knowledge base/
Tutorials/
Connect to data sources/
Google Cloud Storage
Connect Streamlit to Google Cloud Storage
Introduction
This guide explains how to securely access files on Google Cloud Storage from Streamlit Community Cloud. It uses the google-cloud-storage library and Streamlit's secrets management.
Create a Google Cloud Storage bucket and add a file
push_pin
Note
If you already have a bucket that you want to use, feel free to skip to the next step.
First, sign up for Google Cloud Platform or log in. Go to the Google Cloud Storage console and create a new bucket.
Navigate to the upload section of your new bucket: | streamlit-docs.txt |
e4409cd96e13-21 | Navigate to the upload section of your new bucket:
And upload the following CSV file, which contains some example data:
myfile.csv
Enable the Google Cloud Storage API
The Google Cloud Storage API is enabled by default when you create a project through the Google Cloud Console or CLI. Feel free to skip to the next step.
If you do need to enable the API for programmatic access in your project, head over to the APIs & Services dashboard (select or create a project if asked). Search for the Cloud Storage API and enable it. The screenshot below has a blue "Manage" button and indicates the "API is enabled" which means no further action needs to be taken. This is very likely what you have since the API is enabled by default. However, if that is not what you see and you have an "Enable" button, you'll need to enable the API:
Create a service account and key file
To use the Google Cloud Storage API from Streamlit Community Cloud, you need a Google Cloud Platform service account (a special type for programmatic data access). Go to the Service Accounts page and create an account with Viewer permission.
push_pin
Note
If the button CREATE SERVICE ACCOUNT is gray, you don't have the correct permissions. Ask the admin of your Google Cloud project for help.
After clicking DONE, you should be back on the service accounts overview. Create a JSON key file for the new account and download it:
Add the key to your local app secrets
Your local Streamlit app will read secrets from a file .streamlit/secrets.toml in your app's root directory. Create this file if it doesn't exist yet and add the access key to it as shown below:
# .streamlit/secrets.toml | streamlit-docs.txt |
e4409cd96e13-22 | # .streamlit/secrets.toml
[gcp_service_account]
type = "service_account"
project_id = "xxx"
private_key_id = "xxx"
private_key = "xxx"
client_email = "xxx"
client_id = "xxx"
auth_uri = "https://accounts.google.com/o/oauth2/auth"
token_uri = "https://oauth2.googleapis.com/token"
auth_provider_x509_cert_url = "https://www.googleapis.com/oauth2/v1/certs"
client_x509_cert_url = "xxx"
Copy
priority_high
Important
Add this file to .gitignore and don't commit it to your GitHub repo!
Copy your app secrets to the cloud
As the secrets.toml file above is not committed to GitHub, you need to pass its content to your deployed app (on Streamlit Community Cloud) separately. Go to the app dashboard and in the app's dropdown menu, click on Edit Secrets. Copy the content of secrets.toml into the text area. More information is available at Secrets Management.
Add google-cloud-storage to your requirements file
Add the google-cloud-storage package to your requirements.txt file, preferably pinning its version (replace x.x.x with the version you want installed):
# requirements.txt
google-cloud-storage==x.x.x
Copy
Write your Streamlit app
Copy the code below to your Streamlit app and run it. Make sure to adapt the name of your bucket and file. Note that Streamlit automatically turns the access keys from your secrets file into environment variables.
# streamlit_app.py
import streamlit as st
from google.oauth2 import service_account
from google.cloud import storage
# Create API client.
credentials = service_account.Credentials.from_service_account_info(
st.secrets["gcp_service_account"]
)
client = storage.Client(credentials=credentials) | streamlit-docs.txt |
e4409cd96e13-23 | # Retrieve file contents.
# Uses st.cache_data to only rerun when the query changes or after 10 min.
@st.cache_data(ttl=600)
def read_file(bucket_name, file_path):
bucket = client.bucket(bucket_name)
content = bucket.blob(file_path).download_as_string().decode("utf-8")
return content
bucket_name = "streamlit-bucket"
file_path = "myfile.csv"
content = read_file(bucket_name, file_path)
# Print results.
for line in content.strip().split("\n"):
name, pet = line.split(",")
st.write(f"{name} has a :{pet}:")
Copy
See st.cache_data above? Without it, Streamlit would run the query every time the app reruns (e.g. on a widget interaction). With st.cache_data, it only runs when the query changes or after 10 minutes (that's what ttl is for). Watch out: If your database updates more frequently, you should adapt ttl or remove caching so viewers always see the latest data. Learn more in Caching.
If everything worked out (and you used the example file given above), your app should look like this:
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Firestore
Next:
Microsoft SQL Server
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Connect Streamlit to Google Cloud Storage - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Cheat sheet
Cheat Sheet
This is a summary of the docs, as of Streamlit v1.20.0. | streamlit-docs.txt |
e4409cd96e13-24 | This is a summary of the docs, as of Streamlit v1.20.0.
Install & Import
streamlit run first_app.py
# Import convention
>>> import streamlit as st
Command line
streamlit --help
streamlit run your_script.py
streamlit hello
streamlit config show
streamlit cache clear
streamlit docs
streamlit --version
Pre-release features
pip uninstall streamlit
pip install streamlit-nightly --upgrade
Learn more about experimental features
Magic commands
# Magic commands implicitly
# call st.write().
'_This_ is some **Markdown***'
my_variable
'dataframe:', my_data_frame
Display text
st.text('Fixed width text')
st.markdown('_Markdown_') # see *
st.latex(r''' e^{i\pi} + 1 = 0 ''')
st.write('Most objects') # df, err, func, keras!
st.write(['st', 'is <', 3]) # see *
st.title('My title')
st.header('My header')
st.subheader('My sub')
st.code('for i in range(8): foo()')
* optional kwarg unsafe_allow_html = True
Display data
st.dataframe(my_dataframe)
st.table(data.iloc[0:10])
st.json({'foo':'bar','fu':'ba'})
st.metric('My metric', 42, 2)
Display media
st.image('./header.png')
st.audio(data)
st.video(data)
Add widgets to sidebar
# Just add it after st.sidebar:
>>> a = st.sidebar.radio('Select one:', [1, 2]) | streamlit-docs.txt |
e4409cd96e13-25 | # Or use "with" notation:
>>> with st.sidebar:
>>> st.radio('Select one:', [1, 2])
Columns
# Two equal columns:
>>> col1, col2 = st.columns(2)
>>> col1.write("This is column 1")
>>> col2.write("This is column 2")
# Three different columns:
>>> col1, col2, col3 = st.columns([3, 1, 1])
# col1 is larger.
# You can also use "with" notation:
>>> with col1:
>>> st.radio('Select one:', [1, 2])
Tabs
# Insert containers separated into tabs:
>>> tab1, tab2 = st.tabs(["Tab 1", "Tab2"])
>>> tab1.write("this is tab 1")
>>> tab2.write("this is tab 2")
# You can also use "with" notation:
>>> with tab1:
>>> st.radio('Select one:', [1, 2])
Control flow
# Stop execution immediately:
st.stop()
# Rerun script immediately:
st.experimental_rerun() | streamlit-docs.txt |
e4409cd96e13-26 | # Group multiple widgets:
>>> with st.form(key='my_form'):
>>> username = st.text_input('Username')
>>> password = st.text_input('Password')
>>> st.form_submit_button('Login')
Display interactive widgets
st.button('Click me')
st.experimental_data_editor('Edit data', data)
st.checkbox('I agree')
st.radio('Pick one', ['cats', 'dogs'])
st.selectbox('Pick one', ['cats', 'dogs'])
st.multiselect('Buy', ['milk', 'apples', 'potatoes'])
st.slider('Pick a number', 0, 100)
st.select_slider('Pick a size', ['S', 'M', 'L'])
st.text_input('First name')
st.number_input('Pick a number', 0, 10)
st.text_area('Text to translate')
st.date_input('Your birthday')
st.time_input('Meeting time')
st.file_uploader('Upload a CSV')
st.download_button('Download file', data)
st.camera_input("Take a picture")
st.color_picker('Pick a color')
# Use widgets' returned values in variables:
>>> for i in range(int(st.number_input('Num:'))):
>>> foo()
>>> if st.sidebar.selectbox('I:',['f']) == 'f':
>>> b()
>>> my_slider_val = st.slider('Quinn Mallory', 1, 88)
>>> st.write(slider_val)
# Disable widgets to remove interactivity:
>>> st.slider('Pick a number', 0, 100, disabled=True)
Mutate data
# Add rows to a dataframe after
# showing it.
>>> element = st.dataframe(df1)
>>> element.add_rows(df2) | streamlit-docs.txt |
e4409cd96e13-27 | # Add rows to a chart after
# showing it.
>>> element = st.line_chart(df1)
>>> element.add_rows(df2)
Display code
>>> with st.echo():
>>> st.write('Code will be executed and printed')
Placeholders, help, and options
# Replace any single element.
>>> element = st.empty()
>>> element.line_chart(...)
>>> element.text_input(...) # Replaces previous.
# Insert out of order.
>>> elements = st.container()
>>> elements.line_chart(...)
>>> st.write("Hello")
>>> elements.text_input(...) # Appears above "Hello". | streamlit-docs.txt |
e4409cd96e13-28 | st.help(pandas.DataFrame)
st.get_option(key)
st.set_option(key, value)
st.set_page_config(layout='wide')
st.experimental_show(objects)
st.experimental_get_query_params()
st.experimental_set_query_params(**params)
Optimize performance
Cache data objects
# E.g. Dataframe computation, storing downloaded data, etc.
>>> @st.cache_data
... def foo(bar):
... # Do something expensive and return data
... return data
# Executes foo
>>> d1 = foo(ref1)
# Does not execute foo
# Returns cached item by value, d1 == d2
>>> d2 = foo(ref1)
# Different arg, so function foo executes
>>> d3 = foo(ref2)
# Clear all cached entries for this function
>>> foo.clear()
# Clear values from *all* in-memory or on-disk cached functions
>>> st.cache_data.clear()
Cache global resources
# E.g. TensorFlow session, database connection, etc.
>>> @st.cache_resource
... def foo(bar):
... # Create and return a non-data object
... return session
# Executes foo
>>> s1 = foo(ref1)
# Does not execute foo
# Returns cached item by reference, s1 == s2
>>> s2 = foo(ref1)
# Different arg, so function foo executes
>>> s3 = foo(ref2)
# Clear all cached entries for this function
>>> foo.clear()
# Clear all global resources from cache
>>> st.cache_resource.clear()
Deprecated caching
>>> @st.cache
... def foo(bar):
... # Do something expensive in here...
... return data
>>> # Executes foo
>>> d1 = foo(ref1)
>>> # Does not execute foo
>>> # Returns cached item by reference, d1 == d2 | streamlit-docs.txt |
e4409cd96e13-29 | >>> # Does not execute foo
>>> # Returns cached item by reference, d1 == d2
>>> d2 = foo(ref1)
>>> # Different arg, so function foo executes
>>> d3 = foo(ref2)
Display progress and status
>>> with st.spinner(text='In progress'):
>>> time.sleep(5)
>>> st.success('Done') | streamlit-docs.txt |
e4409cd96e13-30 | st.progress(progress_variable_1_to_100)
st.balloons()
st.snow()
st.error('Error message')
st.warning('Warning message')
st.info('Info message')
st.success('Success message')
st.exception(e)
Personalize apps for users
# Show different content based on the user's email address.
>>> if st.user.email == 'jane@email.com':
>>> display_jane_content()
>>> elif st.user.email == 'adam@foocorp.io':
>>> display_adam_content()
>>> else:
>>> st.write("Please contact us to get access!")
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Changelog
Next:
Streamlit Community Cloud
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Cheat sheet - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Advanced features/
Add statefulness to apps
Add statefulness to apps
What is State?
We define access to a Streamlit app in a browser tab as a session. For each browser tab that connects to the Streamlit server, a new session is created. Streamlit reruns your script from top to bottom every time you interact with your app. Each reruns takes place in a blank slate: no variables are shared between runs.
Session State is a way to share variables between reruns, for each user session. In addition to the ability to store and persist state, Streamlit also exposes the ability to manipulate state using Callbacks. Session state also persists across apps inside a multipage app. | streamlit-docs.txt |
e4409cd96e13-31 | In this guide, we will illustrate the usage of Session State and Callbacks as we build a stateful Counter app.
For details on the Session State and Callbacks API, please refer to our Session State API Reference Guide.
Also, check out this Session State basics tutorial video by Streamlit Developer Advocate Dr. Marisa Smith to get started:
Build a Counter
Let's call our script counter.py. It initializes a count variable and has a button to increment the value stored in the count variable:
import streamlit as st
st.title('Counter Example')
count = 0
increment = st.button('Increment')
if increment:
count += 1
st.write('Count = ', count)
Copy
No matter how many times we press the Increment button in the above app, the count remains at 1. Let's understand why:
Each time we press the Increment button, Streamlit reruns counter.py from top to bottom, and with every run, count gets initialized to 0 .
Pressing Increment subsequently adds 1 to 0, thus count=1 no matter how many times we press Increment.
As we'll see later, we can avoid this issue by storing count as a Session State variable. By doing so, we're indicating to Streamlit that it should maintain the value stored inside a Session State variable across app reruns.
Let's learn more about the API to use Session State.
Initialization
The Session State API follows a field-based API, which is very similar to Python dictionaries:
import streamlit as st
# Check if 'key' already exists in session_state
# If not, then initialize it
if 'key' not in st.session_state:
st.session_state['key'] = 'value'
# Session State also supports the attribute based syntax
if 'key' not in st.session_state:
st.session_state.key = 'value'
Copy
Reads and updates | streamlit-docs.txt |
e4409cd96e13-32 | Read the value of an item in Session State by passing the item to st.write :
import streamlit as st
if 'key' not in st.session_state:
st.session_state['key'] = 'value'
# Reads
st.write(st.session_state.key)
# Outputs: value
Copy
Update an item in Session State by assigning it a value:
import streamlit as st
if 'key' not in st.session_state:
st.session_state['key'] = 'value'
# Updates
st.session_state.key = 'value2' # Attribute API
st.session_state['key'] = 'value2' # Dictionary like API
Copy
Streamlit throws an exception if an uninitialized variable is accessed:
import streamlit as st
st.write(st.session_state['value'])
# Throws an exception!
Copy
Let's now take a look at a few examples that illustrate how to add Session State to our Counter app.
Example 1: Add Session State
Now that we've got a hang of the Session State API, let's update our Counter app to use Session State:
import streamlit as st
st.title('Counter Example')
if 'count' not in st.session_state:
st.session_state.count = 0
increment = st.button('Increment')
if increment:
st.session_state.count += 1
st.write('Count = ', st.session_state.count)
Copy
As you can see in the above example, pressing the Increment button updates the count each time.
Example 2: Session State and Callbacks
Now that we've built a basic Counter app using Session State, let's move on to something a little more complex. The next example uses Callbacks with Session State. | streamlit-docs.txt |
e4409cd96e13-33 | Callbacks: A callback is a Python function which gets called when an input widget changes. Callbacks can be used with widgets using the parameters on_change (or on_click), args, and kwargs. The full Callbacks API can be found in our Session State API Reference Guide.
import streamlit as st
st.title('Counter Example using Callbacks')
if 'count' not in st.session_state:
st.session_state.count = 0
def increment_counter():
st.session_state.count += 1
st.button('Increment', on_click=increment_counter)
st.write('Count = ', st.session_state.count)
Copy
Now, pressing the Increment button updates the count each time by calling the increment_counter() function.
Example 3: Use args and kwargs in Callbacks
Callbacks also support passing arguments using the args parameter in a widget:
import streamlit as st
st.title('Counter Example using Callbacks with args')
if 'count' not in st.session_state:
st.session_state.count = 0
increment_value = st.number_input('Enter a value', value=0, step=1)
def increment_counter(increment_value):
st.session_state.count += increment_value
increment = st.button('Increment', on_click=increment_counter,
args=(increment_value, ))
st.write('Count = ', st.session_state.count)
Copy
Additionally, we can also use the kwargs parameter in a widget to pass named arguments to the callback function as shown below:
import streamlit as st
st.title('Counter Example using Callbacks with kwargs')
if 'count' not in st.session_state:
st.session_state.count = 0
def increment_counter(increment_value=0):
st.session_state.count += increment_value
def decrement_counter(decrement_value=0):
st.session_state.count -= decrement_value
st.button('Increment', on_click=increment_counter,
kwargs=dict(increment_value=5)) | streamlit-docs.txt |
e4409cd96e13-34 | st.button('Increment', on_click=increment_counter,
kwargs=dict(increment_value=5))
st.button('Decrement', on_click=decrement_counter,
kwargs=dict(decrement_value=1))
st.write('Count = ', st.session_state.count)
Copy
Example 4: Forms and Callbacks
Say we now want to not only increment the count, but also store when it was last updated. We illustrate doing this using Callbacks and st.form:
import streamlit as st
import datetime
st.title('Counter Example')
if 'count' not in st.session_state:
st.session_state.count = 0
st.session_state.last_updated = datetime.time(0,0)
def update_counter():
st.session_state.count += st.session_state.increment_value
st.session_state.last_updated = st.session_state.update_time
with st.form(key='my_form'):
st.time_input(label='Enter the time', value=datetime.datetime.now().time(), key='update_time')
st.number_input('Enter a value', value=0, step=1, key='increment_value')
submit = st.form_submit_button(label='Update', on_click=update_counter)
st.write('Current Count = ', st.session_state.count)
st.write('Last Updated = ', st.session_state.last_updated)
Copy
Advanced concepts
Session State and Widget State association
Session State provides the functionality to store variables across reruns. Widget state (i.e. the value of a widget) is also stored in a session.
For simplicity, we have unified this information in one place. i.e. the Session State. This convenience feature makes it super easy to read or write to the widget's state anywhere in the app's code. Session State variables mirror the widget value using the key argument. | streamlit-docs.txt |
e4409cd96e13-35 | We illustrate this with the following example. Let's say we have an app with a slider to represent temperature in Celsius. We can set and get the value of the temperature widget by using the Session State API, as follows:
import streamlit as st
if "celsius" not in st.session_state:
# set the initial default value of the slider widget
st.session_state.celsius = 50.0
st.slider(
"Temperature in Celsius",
min_value=-100.0,
max_value=100.0,
key="celsius"
)
# This will get the value of the slider widget
st.write(st.session_state.celsius)
Copy
There is a limitation to setting widget values using the Session State API.
priority_high
Important
Streamlit does not allow setting widget values via the Session State API for st.button and st.file_uploader.
The following example will raise a StreamlitAPIException on trying to set the state of st.button via the Session State API:
import streamlit as st
if 'my_button' not in st.session_state:
st.session_state.my_button = True
# Streamlit will raise an Exception on trying to set the state of button
st.button('Submit', key='my_button')
Copy
Caveats and limitations
Here are some limitations to keep in mind when using Session State:
Session State exists for as long as the tab is open and connected to the Streamlit server. As soon as you close the tab, everything stored in Session State is lost.
Session State is not persisted. If the Streamlit server crashes, then everything stored in Session State gets wiped
For caveats and limitations with the Session State API, please see the API limitations.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions? | streamlit-docs.txt |
e4409cd96e13-36 | Our forums are full of helpful information and Streamlit experts.
Previous:
Experimental cache primitives
Next:
Dataframes
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Add statefulness to apps - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Advanced features/
Dataframes
Dataframes
Dataframes are a great way to display and edit data in a tabular format. Working with Pandas DataFrames and other tabular data structures is key to data science workflows. If developers and data scientists want to display this data in Streamlit, they have multiple options: st.dataframe and st.experimental_data_editor. If you want to solely display data in a table-like UI, st.dataframe is the way to go. If you want to interactively edit data, use st.experimental_data_editor. We explore the use cases and advantages of each option in the following sections.
Display dataframes with st.dataframe
Streamlit can display dataframes in a table-like UI via st.dataframe :
import streamlit as st
import pandas as pd
df = pd.DataFrame(
[
{"command": "st.selectbox", "rating": 4, "is_widget": True},
{"command": "st.balloons", "rating": 5, "is_widget": False},
{"command": "st.time_input", "rating": 3, "is_widget": True},
]
)
st.dataframe(df, use_container_width=True)
Copy
(view standalone Streamlit app)
Additional UI features
st.dataframe also provides some additional functionality by using glide-data-grid under the hood: | streamlit-docs.txt |
e4409cd96e13-37 | st.dataframe also provides some additional functionality by using glide-data-grid under the hood:
Column sorting: sort columns by clicking on their headers.
Column resizing: resize columns by dragging and dropping column header borders.
Table resizing: resize tables by dragging and dropping the bottom right corner.
Search: search through data by clicking a table, using hotkeys (⌘ Cmd + F or Ctrl + F) to bring up the search bar, and using the search bar to filter data.
Copy to clipboard: select one or multiple cells, copy them to the clipboard and paste them into your favorite spreadsheet software.
Try out all the addition UI features using the embedded app from the prior section.
In addition to Pandas DataFrames, st.dataframe also supports other common Python types, e.g., list, dict, or numpy array. It also supports Snowpark and PySpark DataFrames, which allow you to lazily evaluate and pull data from databases. This can be useful for working with large datasets.
Edit data with st.experimental_data_editor
Streamlit supports editable dataframes via the st.experimental_data_editor command. Check out its API in st.experimental_data_editor. It shows the dataframe in a table, similar to st.dataframe. But in contrast to st.dataframe, this table isn't static! The user can click on cells and edit them. The edited data is then returned on the Python side. Here's an example:
df = pd.DataFrame(
[
{"command": "st.selectbox", "rating": 4, "is_widget": True},
{"command": "st.balloons", "rating": 5, "is_widget": False},
{"command": "st.time_input", "rating": 3, "is_widget": True},
]
)
df = load_data()
edited_df = st.experimental_data_editor(df) # 👈 An editable dataframe | streamlit-docs.txt |
e4409cd96e13-38 | df = load_data()
edited_df = st.experimental_data_editor(df) # 👈 An editable dataframe
favorite_command = edited_df.loc[edited_df["rating"].idxmax()]["command"]
st.markdown(f"Your favorite command is **{favorite_command}** 🎈")
Copy
View interactive app
expand_more
Try it out by double-clicking on any cell. You'll notice you can edit all cell values. Try editing the values in the rating column and observe how the text output at the bottom changes:
st.experimental_data_editor also supports a few additional things:
Copy and paste support from and to Excel and Google Sheets.
Add and delete rows. You can do this by setting num_rows= "dynamic" when calling st.experimental_data_editor. This will allow users to add and delete rows as needed.
Access edited data.
Bulk edits (similar to Excel, just drag a handle to edit neighboring cells).
Automatic input validation, e.g. no way to enter letters into a number cell.
Edit common data structures such as lists, dicts, NumPy ndarray, etc.
Copy and paste support
The data editor supports pasting in tabular data from Google Sheets, Excel, Notion, and many other similar tools. You can also copy-paste data between st.experimental_data_editor instances. This can be a huge time saver for users who need to work with data across multiple platforms. To try it out:
Copy data from this Google Sheets document to clipboard
Select any cell in the name column of the table below and paste it in (via ctrl/cmd + v).
View interactive app
expand_more
push_pin
Note
Every cell of the pasted data will be evaluated individually and inserted into the cells if the data is compatible with the column type. E.g., pasting in non-numerical text data into a number column will be ignored. | streamlit-docs.txt |
e4409cd96e13-39 | Did you notice that although the initial dataframe had just five rows, pasting all those rows from the spreadsheet added additional rows to the dataframe? 👀 Let's find out how that works in the next section.
Add and delete rows
With st.experimental_data_editor, viewers can add or delete rows via the table UI. This mode can be activated by setting the num_rows parameter to "dynamic". E.g.
edited_df = st.experimental_data_editor(df, num_rows=”dynamic”)
Copy
To add new rows, scroll to the bottom-most row and click on the “+” sign in any cell.
To delete rows, select one or more rows and press the delete key on your keyboard.
View interactive app
expand_more
Access edited data
Sometimes, it is more convenient to know which cells have been changed rather than getting the entire edited dataframe back. Streamlit makes this easy through the use of session state. If a key parameter is set, Streamlit will store any changes made to the dataframe in the session state.
This snippet shows how you can access changed data using session state:
st.experimental_data_editor(df, key="data_editor") # 👈 Set a key
st.write("Here's the session state:")
st.write(st.session_state["data_editor"]) # 👈 Access the edited data
Copy
In this code snippet, the key parameter is set to "data_editor". Any changes made to the data in the st.experimental_data_editor instance will be tracked by Streamlit and stored in session state under the key "data_editor".
After the data editor is created, the contents of the "data_editor" key in session state are printed to the screen using st.write(st.session_state["data_editor"]). This allows you to see the changes made to the original dataframe without having to return the entire dataframe from the data editor. | streamlit-docs.txt |
e4409cd96e13-40 | This can be useful when working with large dataframes and you only need to know which cells have changed, rather than the entire edited dataframe.
View interactive app
expand_more
Use all we've learned so far and apply them to the above embedded app. Try editing cells, adding new rows, and deleting rows.
Notice how edits to the table are reflected in session state: when you make any edits, a rerun is triggered which sends the edits to the backend via st.experimental_data_editor's keyed widget state. Its widget state is a JSON object containing three properties: edited_cells, added_rows, and deleted rows:.
edited_cells maps a cell position to the edited value: column:row → value .
added_rows is a list of newly added rows to the table. Each row is a dictionary where the keys are the column indices and the values are the corresponding cell values.
deleted_rows is a list of row indices that have been deleted from the table.
Bulk edits
The data editor includes a feature that allows for bulk editing of cells. Similar to Excel, you can drag a handle across a selection of cells to edit their values in bulk. You can even apply commonly used keyboard shortcuts in spreadsheet software. This is useful when you need to make the same change across multiple cells, rather than editing each cell individually:
Automatic input validation
The data editor includes automatic input validation to help prevent errors when editing cells. For example, if you have a column that contains numerical data, the input field will automatically restrict the user to only entering numerical data. This helps to prevent errors that could occur if the user were to accidentally enter a non-numerical value.
Edit common data structures | streamlit-docs.txt |
e4409cd96e13-41 | Edit common data structures
Editing doesn't just work for Pandas DataFrames! You can also edit lists, tuples, sets, dictionaries, NumPy arrays, or Snowpark & PySpark DataFrames. Most data types will be returned in their original format. But some types (e.g. Snowpark and PySpark) are converted to Pandas DataFrames. To learn about all the supported types, read the st.experimental_data_editor API.
E.g. you can easily let the user add items to a list:
edited_list = st.experimental_data_editor(["red", "green", "blue"], num_rows= "dynamic")
st.write("Here are all the colors you entered:")
st.write(edited_list)
Copy
Or numpy arrays:
import numpy as np
st.experimental_data_editor(np.array([
["st.text_area", "widget", 4.92],
["st.markdown", "element", 47.22]
]))
Copy
Or lists of records:
st.experimental_data_editor([
{"name": "st.text_area", "type": "widget"},
{"name": "st.markdown", "type": "element"},
])
Copy
Or dictionaries and many more types!
st.experimental_data_editor({
"st.text_area": "widget",
"st.markdown": "element"
})
Copy
Configuring columns
You will be able configure the display and editing behavior of columns via st.dataframe and st.experimental_data_editor in to-be-announced future releases. We are developing an API to let you add images, charts, and clickable URLs in dataframe columns. Additionally, you will be able to make individual columns editable, set columns as categorical and specify which options they can take, hide the index of the dataframe, and much more.
priority_high
Important
We will release the ability to configure columns in a future version of Streamlit. Keep at an eye out for updates on this page and the Streamlit roadmap. | streamlit-docs.txt |
e4409cd96e13-42 | While the ability to configure columns has yet to be released, there are techniques you can use with Pandas today to render columns as checkboxes, selectboxes, and change the type of columns.
Boolean columns (checkboxes)
To render columns as checkboxes and clickable checkboxes in st.dataframe and st.experimental_data_editor, respectively, set the type of the Pandas column as bool.
Here’s an example of creating a Pandas DataFrame with column A containing boolean values. When we display it using st.dataframe, the boolean values are rendered as checkboxes, where True and False values are checked and unchecked, respectively.
import pandas as pd
# create a dataframe with a boolean column
df = pd.DataFrame({"A": [True, False, True, False]})
# show the dataframe with checkboxes
st.dataframe(df)
Copy
Notice you cannot change their values from the frontend. To let users check and uncheck values, we display the dataframe with st.experimental_data_editor instead:
import pandas as pd
# create a dataframe with a boolean column
df = pd.DataFrame({"A": [True, False, True, False]})
# show the data editor with checkboxes
st.experimental_data_editor(df)
Copy
Categorical columns (selectboxes)
To render columns as selectboxes with st.experimental_data_editor, set the type of the Pandas column as category:
import pandas as pd
df = pd.DataFrame(
{"command": ["st.selectbox", "st.slider", "st.balloons", "st.time_input"]}
)
df["command"] = df["command"].astype("category")
edited_df = st.experimental_data_editor(df)
Copy | streamlit-docs.txt |
e4409cd96e13-43 | edited_df = st.experimental_data_editor(df)
Copy
In some cases, you may want users to select categories that aren’t in the original Pandas DataFrame. Let’s say we use df from above. Currently, the command column can take on four unique values. What should we do if we want users to see additional options such as st.button and st.radio?
To add additional categories to the selection, use pandas.Series.cat.add_categories:
import pandas as pd
df = pd.DataFrame(
{"command": ["st.selectbox", "st.slider", "st.balloons", "st.time_input"]}
)
df["command"] = (
df["command"].astype("category").cat.add_categories(["st.button", "st.radio"])
)
edited_df = st.experimental_data_editor(df)
Copy
Change column type
To change the type of a column, you can change the type of the underlying Pandas DataFrame column. E.g., say you have a column with only integers but want users to be able to add numbers with decimals. To do so, simply change the Pandas DataFrame column type to float, like so:
import pandas as pd
import streamlit as st
# create a dataframe with an integer column
df = pd.DataFrame({"A": [1, 2, 3, 4]})
# unable to add float values to the column
edited_df = st.experimental_data_editor(df)
# cast the column to float
df["A"] = df["A"].astype("float")
# able to add float values to the column
edited_df = st.experimental_data_editor(df)
Copy
In the first data editor instance, you cannot add decimal values to any entries. But after casting column A to type float, we’re able to edit the values as floating point numbers:
Handling large datasets | streamlit-docs.txt |
e4409cd96e13-44 | Handling large datasets
st.dataframe and st.experimental_data_editor have been designed to theoretically handle tables with millions of rows thanks to their highly performant implementation using the glide-data-grid library and HTML canvas. However, the maximum amount of data that an app can realistically handle will depend on several other factors, including:
The maximum size of WebSocket messages: Streamlit's WebSocket messages are configurable via the server.maxMessageSize config option, which limits the amount of data that can be transferred via the WebSocket connection at once.
The server memory: The amount of data that your app can handle will also depend on the amount of memory available on your server. If the server's memory is exceeded, the app may become slow or unresponsive.
The user's browser memory: Since all the data needs to be transferred to the user's browser for rendering, the amount of memory available on the user's device can also affect the app's performance. If the browser's memory is exceeded, it may crash or become unresponsive.
In addition to these factors, a slow network connection can also significantly slow down apps that handle large datasets.
When handling large datasets with more than 150,000 rows, Streamlit applies additional optimizations and disables column sorting. This can help to reduce the amount of data that needs to be processed at once and improve the app's performance.
Limitations
While Streamlit's data editing capabilities offer a lot of functionality, there are some limitations to be aware of: | streamlit-docs.txt |
e4409cd96e13-45 | The editing functionalities are not yet optimized for mobile devices.
Editing is enabled only for a limited set of types (e.g. string, numbers, boolean). We are actively working on supporting more types soon, such as date, time, and datetime.
Editing of Pandas DataFrames only supports the following index types: RangeIndex, (string) Index, Float64Index, Int64Index, and UInt64Index.
The column type is inferred from the underlying data and cannot be configured yet.
Some actions like deleting rows or searching data can only be triggered via keyboard hotkeys.
We are working to fix the above limitations in future releases, so keep an eye out for updates.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Add statefulness to apps
Next:
Widget semantics
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Dataframes - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-46 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Status elements/
st.progress
st.progress
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a progress bar.
Function signature
[source]
st.progress(value, text=None)
Parameters
value (int or float)
0 <= value <= 100 for int
0.0 <= value <= 1.0 for float
text (str or None)
A message to display above the progress bar. The text can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, Inline Code, Emojis, and Links.
This also supports: | streamlit-docs.txt |
e4409cd96e13-47 | This also supports:
Emoji shortcodes, such as :+1: and :sunglasses:. For a list of all supported codes, see https://share.streamlit.io/streamlit/emoji-shortcodes.
LaTeX expressions, by wrapping them in "$" or "$$" (the "$$" must be on their own lines). Supported LaTeX functions are listed at https://katex.org/docs/supported.html.
Colored text, using the syntax :color[text to be colored], where color needs to be replaced with any of the following supported colors: blue, green, orange, red, violet.
Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
Example
Here is an example of a progress bar increasing over time:
import streamlit as st
import time
progress_text = "Operation in progress. Please wait."
my_bar = st.progress(0, text=progress_text)
for percent_complete in range(100):
time.sleep(0.1)
my_bar.progress(percent_complete + 1, text=progress_text)
Copy
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Status elements
Next:
st.spinner
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.progress - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-48 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Write and magic/
st.write
st.write
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Write arguments to the app.
This is the Swiss Army knife of Streamlit commands: it does different things depending on what you throw at it. Unlike other Streamlit commands, write() has some unique properties:
You can pass in multiple arguments, all of which will be written.
Its behavior depends on the input types as follows.
It returns None, so its "slot" in the App cannot be reused.
Function signature
[source]
st.write(*args, unsafe_allow_html=False, **kwargs)
Parameters
*args (any)
One or many objects to print to the App.
Arguments are handled as follows: | streamlit-docs.txt |
e4409cd96e13-49 | One or many objects to print to the App.
Arguments are handled as follows:
write(string) : Prints the formatted Markdown string, with
support for LaTeX expression, emoji shortcodes, and colored text. See docs for st.markdown for more.
write(data_frame) : Displays the DataFrame as a table.
write(error) : Prints an exception specially.
write(func) : Displays information about a function.
write(module) : Displays information about the module.
write(dict) : Displays dict in an interactive widget.
write(mpl_fig) : Displays a Matplotlib figure.
write(altair) : Displays an Altair chart.
write(keras) : Displays a Keras model.
write(graphviz) : Displays a Graphviz graph.
write(plotly_fig) : Displays a Plotly figure.
write(bokeh_fig) : Displays a Bokeh figure.
write(sympy_expr) : Prints SymPy expression using LaTeX.
write(htmlable) : Prints _repr_html_() for the object if available.
write(obj) : Prints str(obj) if otherwise unknown.
unsafe_allow_html (bool)
This is a keyword-only argument that defaults to False.
By default, any HTML tags found in strings will be escaped and therefore treated as pure text. This behavior may be turned off by setting this argument to True.
That said, we strongly advise against it. It is hard to write secure HTML, so by using this argument you may be compromising your users' security. For more information, see:
https://github.com/streamlit/streamlit/issues/152
Example
Its basic use case is to draw Markdown-formatted text, whenever the input is a string:
import streamlit as st
st.write('Hello, *World!* :sunglasses:')
Copy
(view standalone Streamlit app)
As mentioned earlier, st.write() also accepts other data formats, such as numbers, data frames, styled data frames, and assorted objects: | streamlit-docs.txt |
e4409cd96e13-50 | import streamlit as st
import pandas as pd
st.write(1234)
st.write(pd.DataFrame({
'first column': [1, 2, 3, 4],
'second column': [10, 20, 30, 40],
}))
Copy
(view standalone Streamlit app)
Finally, you can pass in multiple arguments to do things like:
import streamlit as st
st.write('1 + 1 = ', 2)
st.write('Below is a DataFrame:', data_frame, 'Above is a dataframe.')
Copy
(view standalone Streamlit app)
Oh, one more thing: st.write accepts chart objects too! For example:
import streamlit as st
import pandas as pd
import numpy as np
import altair as alt
df = pd.DataFrame(
np.random.randn(200, 3),
columns=['a', 'b', 'c'])
c = alt.Chart(df).mark_circle().encode(
x='a', y='b', size='c', color='c', tooltip=['a', 'b', 'c'])
st.write(c)
Copy
(view standalone Streamlit app)
Featured video
Learn what the st.write and magic commands are and how to use them.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Write and magic
Next:
magic
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.write - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Write and magic/
magic
Magic | streamlit-docs.txt |
e4409cd96e13-51 | Knowledge base
Home/
Streamlit library/
API reference/
Write and magic/
magic
Magic
Magic commands are a feature in Streamlit that allows you to write almost anything (markdown, data, charts) without having to type an explicit command at all. Just put the thing you want to show on its own line of code, and it will appear in your app. Here's an example:
# Draw a title and some text to the app:
'''
# This is the document title
This is some _markdown_.
'''
import pandas as pd
df = pd.DataFrame({'col1': [1,2,3]})
df # 👈 Draw the dataframe
x = 10
'x', x # 👈 Draw the string 'x' and then the value of x
# Also works with most supported chart types
import matplotlib.pyplot as plt
import numpy as np
arr = np.random.normal(1, 1, size=100)
fig, ax = plt.subplots()
ax.hist(arr, bins=20)
fig # 👈 Draw a Matplotlib chart
Copy
How Magic works
Any time Streamlit sees either a variable or literal value on its own line, it automatically writes that to your app using st.write (which you'll learn about later).
Also, magic is smart enough to ignore docstrings. That is, it ignores the strings at the top of files and functions.
If you prefer to call Streamlit commands more explicitly, you can always turn magic off in your ~/.streamlit/config.toml with the following setting:
[runner]
magicEnabled = false
Copy
priority_high
Important
Right now, Magic only works in the main Python app file, not in imported files. See GitHub issue #288 for a discussion of the issues.
Featured video
Learn what the st.write and magic commands are and how to use them.
Was this page helpful? | streamlit-docs.txt |
e4409cd96e13-52 | Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.write
Next:
Text elements
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Magic - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Text elements/
st.markdown
st.markdown
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display string formatted as Markdown.
Function signature
[source]
st.markdown(body, unsafe_allow_html=False)
Parameters
body (str)
The string to display as Github-flavored Markdown. Syntax information can be found at: https://github.github.com/gfm.
This also supports: | streamlit-docs.txt |
e4409cd96e13-53 | This also supports:
Emoji shortcodes, such as :+1: and :sunglasses:. For a list of all supported codes, see https://share.streamlit.io/streamlit/emoji-shortcodes.
LaTeX expressions, by wrapping them in "$" or "$$" (the "$$" must be on their own lines). Supported LaTeX functions are listed at https://katex.org/docs/supported.html.
Colored text, using the syntax :color[text to be colored], where color needs to be replaced with any of the following supported colors: blue, green, orange, red, violet.
unsafe_allow_html (bool)
By default, any HTML tags found in the body will be escaped and therefore treated as pure text. This behavior may be turned off by setting this argument to True.
That said, we strongly advise against it. It is hard to write secure HTML, so by using this argument you may be compromising your users' security. For more information, see:
https://github.com/streamlit/streamlit/issues/152
Examples
import streamlit as st
st.markdown('Streamlit is **_really_ cool**.')
st.markdown(”This text is :red[colored red], and this is **:blue[colored]** and bold.”)
st.markdown(":green[$\sqrt{x^2+y^2}=1$] is a Pythagorean identity. :pencil:")
Copy
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Text elements
Next:
st.title
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.markdown - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school | streamlit-docs.txt |
e4409cd96e13-54 | dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Text elements/
st.code
st.code
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a code block with optional syntax highlighting.
(This is a convenience wrapper around st.markdown())
Function signature
[source]
st.code(body, language="python")
Parameters
body (str)
The string to display as code.
language (str or None)
The language that the code is written in, for syntax highlighting. If None, the code will be unstyled. Defaults to "python".
For a list of available language values, see:
https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_PRISM.MD
Example
import streamlit as st
code = '''def hello():
print("Hello, Streamlit!")'''
st.code(code, language='python')
Copy | streamlit-docs.txt |
e4409cd96e13-55 | Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.caption
Next:
st.text
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.code - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.button
st.button
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a button widget.
Function signature
[source]
st.button(label, key=None, help=None, on_click=None, args=None, kwargs=None, *, type="secondary", disabled=False, use_container_width=False)
Parameters
label (str) | streamlit-docs.txt |
e4409cd96e13-56 | Parameters
label (str)
A short label explaining to the user what this button is for. The label can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, and Emojis.
Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
key (str or int)
An optional string or integer to use as the unique key for the widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
help (str)
An optional tooltip that gets displayed when the button is hovered over.
on_click (callable)
An optional callback invoked when this button is clicked.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
type ("secondary" or "primary")
An optional string that specifies the button type. Can be "primary" for a button with additional emphasis or "secondary" for a normal button. This argument can only be supplied by keyword. Defaults to "secondary".
disabled (bool)
An optional boolean, which disables the button if set to True. The default is False. This argument can only be supplied by keyword.
use_container_width (bool)
An optional boolean, which makes the button stretch its width to match the parent container.
Returns
(bool)
True if the button was clicked on the last run of the app, False otherwise.
Example
import streamlit as st
if st.button('Say hello'):
st.write('Why hello there')
else:
st.write('Goodbye')
Copy
(view standalone Streamlit app)
Featured videos
Check out our video on how to use one of Streamlit's core functions, the button! | streamlit-docs.txt |
e4409cd96e13-57 | Check out our video on how to use one of Streamlit's core functions, the button!
In the video below, we'll take it a step further and learn how to combine a button, checkbox and radio button!
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Input widgets
Next:
st.experimental_data_editor
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.button - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.experimental_data_editor
priority_high
Important
This is an experimental feature. Experimental features and their APIs may change or be removed at any time. To learn more, click here.
star
Tip
This page only contains information on the st.experimental_data_editor API. For a deeper dive into working with DataFrames and the data editor's capabilities, read Dataframes. | streamlit-docs.txt |
e4409cd96e13-58 | st.experimental_data_editor
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a data editor widget.
Display a data editor widget that allows you to edit DataFrames and many other data structures in a table-like UI.
Function signature
[source]
st.experimental_data_editor(data, *, width=None, height=None, use_container_width=False, num_rows="fixed", disabled=False, key=None, on_change=None, args=None, kwargs=None)
Parameters
data (pandas.DataFrame, pandas.Styler, pandas.Index, pyarrow.Table, numpy.ndarray, pyspark.sql.DataFrame, snowflake.snowpark.DataFrame, list, set, tuple, dict, or None)
The data to edit in the data editor.
width (int or None)
Desired width of the data editor expressed in pixels. If None, the width will be automatically determined.
height (int or None)
Desired height of the data editor expressed in pixels. If None, the height will be automatically determined. | streamlit-docs.txt |
e4409cd96e13-59 | use_container_width (bool)
If True, set the data editor width to the width of the parent container. This takes precedence over the width argument. Defaults to False.
num_rows ("fixed" or "dynamic")
Specifies if the user can add and delete rows in the data editor. If "fixed", the user cannot add or delete rows. If "dynamic", the user can add and delete rows in the data editor, but column sorting is disabled. Defaults to "fixed".
disabled (bool)
An optional boolean which, if True, disables the data editor and prevents any edits. Defaults to False. This argument can only be supplied by keyword.
key (str)
An optional string to use as the unique key for this widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
on_change (callable)
An optional callback invoked when this data_editor's value changes.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
Returns
(pd.DataFrame, pd.Styler, pyarrow.Table, np.ndarray, list, set, tuple, or dict.)
The edited data. The edited data is returned in its original data type if it corresponds to any of the supported return types. All other data types are returned as a pd.DataFrame.
Examples
import streamlit as st
import pandas as pd
df = pd.DataFrame(
[
{"command": "st.selectbox", "rating": 4, "is_widget": True},
{"command": "st.balloons", "rating": 5, "is_widget": False},
{"command": "st.time_input", "rating": 3, "is_widget": True},
]
)
edited_df = st.experimental_data_editor(df) | streamlit-docs.txt |
e4409cd96e13-60 | favorite_command = edited_df.loc[edited_df["rating"].idxmax()]["command"]
st.markdown(f"Your favorite command is **{favorite_command}** 🎈")
Copy
(view standalone Streamlit app)
You can also allow the user to add and delete rows by setting num_rows to "dynamic":
import streamlit as st
import pandas as pd
df = pd.DataFrame(
[
{"command": "st.selectbox", "rating": 4, "is_widget": True},
{"command": "st.balloons", "rating": 5, "is_widget": False},
{"command": "st.time_input", "rating": 3, "is_widget": True},
]
)
edited_df = st.experimental_data_editor(df, num_rows="dynamic")
favorite_command = edited_df.loc[edited_df["rating"].idxmax()]["command"]
st.markdown(f"Your favorite command is **{favorite_command}** 🎈")
Copy
(view standalone Streamlit app)
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.button
Next:
st.download_button
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.experimental_data_editor - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-61 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.download_button
st.download_button
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a download button widget.
This is useful when you would like to provide a way for your users to download a file directly from your app.
Note that the data to be downloaded is stored in-memory while the user is connected, so it's a good idea to keep file sizes under a couple hundred megabytes to conserve memory.
Function signature
[source]
st.download_button(label, data, file_name=None, mime=None, key=None, help=None, on_click=None, args=None, kwargs=None, *, disabled=False, use_container_width=False)
Parameters
label (str)
A short label explaining to the user what this button is for. The label can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, and Emojis. | streamlit-docs.txt |
e4409cd96e13-62 | Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
data (str or bytes or file)
The contents of the file to be downloaded. See example below for caching techniques to avoid recomputing this data unnecessarily.
file_name (str)
An optional string to use as the name of the file to be downloaded, such as 'my_file.csv'. If not specified, the name will be automatically generated.
mime (str or None)
The MIME type of the data. If None, defaults to "text/plain" (if data is of type str or is a textual file) or "application/octet-stream" (if data is of type bytes or is a binary file).
key (str or int)
An optional string or integer to use as the unique key for the widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
help (str)
An optional tooltip that gets displayed when the button is hovered over.
on_click (callable)
An optional callback invoked when this button is clicked.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
disabled (bool)
An optional boolean, which disables the download button if set to True. The default is False. This argument can only be supplied by keyword.
use_container_width (bool)
An optional boolean, which makes the button stretch its width to match the parent container.
Returns
(bool)
True if the button was clicked on the last run of the app, False otherwise.
Examples
Download a large DataFrame as a CSV:
import streamlit as st | streamlit-docs.txt |
e4409cd96e13-63 | Examples
Download a large DataFrame as a CSV:
import streamlit as st
@st.cache
def convert_df(df):
# IMPORTANT: Cache the conversion to prevent computation on every rerun
return df.to_csv().encode('utf-8')
csv = convert_df(my_large_df)
st.download_button(
label="Download data as CSV",
data=csv,
file_name='large_df.csv',
mime='text/csv',
)
Copy
Download a string as a file:
import streamlit as st
text_contents = '''This is some text'''
st.download_button('Download some text', text_contents)
Copy
Download a binary file:
import streamlit as st
binary_contents = b'example content'
# Defaults to 'application/octet-stream'
st.download_button('Download binary file', binary_contents)
Copy
Download an image:
import streamlit as st
with open("flower.png", "rb") as file:
btn = st.download_button(
label="Download image",
data=file,
file_name="flower.png",
mime="image/png"
)
Copy
(view standalone Streamlit app)
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.experimental_data_editor
Next:
st.checkbox
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.download_button - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-64 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.text_input
st.text_input
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a single-line text input widget.
Function signature
[source]
st.text_input(label, value="", max_chars=None, key=None, type="default", help=None, autocomplete=None, on_change=None, args=None, kwargs=None, *, placeholder=None, disabled=False, label_visibility="visible")
Parameters
label (str)
A short label explaining to the user what this input is for. The label can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, Inline Code, Emojis, and Links.
This also supports: | streamlit-docs.txt |
e4409cd96e13-65 | This also supports:
Emoji shortcodes, such as :+1: and :sunglasses:. For a list of all supported codes, see https://share.streamlit.io/streamlit/emoji-shortcodes.
LaTeX expressions, by wrapping them in "$" or "$$" (the "$$" must be on their own lines). Supported LaTeX functions are listed at https://katex.org/docs/supported.html.
Colored text, using the syntax :color[text to be colored], where color needs to be replaced with any of the following supported colors: blue, green, orange, red, violet.
Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
For accessibility reasons, you should never set an empty label (label="") but hide it with label_visibility if needed. In the future, we may disallow empty labels by raising an exception.
value (object)
The text value of this widget when it first renders. This will be cast to str internally.
max_chars (int or None)
Max number of characters allowed in text input.
key (str or int)
An optional string or integer to use as the unique key for the widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
type (str)
The type of the text input. This can be either "default" (for a regular text input), or "password" (for a text input that masks the user's typed value). Defaults to "default".
help (str)
An optional tooltip that gets displayed next to the input.
autocomplete (str) | streamlit-docs.txt |
e4409cd96e13-66 | An optional tooltip that gets displayed next to the input.
autocomplete (str)
An optional value that will be passed to the <input> element's autocomplete property. If unspecified, this value will be set to "new-password" for "password" inputs, and the empty string for "default" inputs. For more details, see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete
on_change (callable)
An optional callback invoked when this text_input's value changes.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
placeholder (str or None)
An optional string displayed when the text input is empty. If None, no text is displayed. This argument can only be supplied by keyword.
disabled (bool)
An optional boolean, which disables the text input if set to True. The default is False. This argument can only be supplied by keyword.
label_visibility ("visible" or "hidden" or "collapsed")
The visibility of the label. If "hidden", the label doesn't show but there is still empty space for it above the widget (equivalent to label=""). If "collapsed", both the label and the space are removed. Default is "visible". This argument can only be supplied by keyword.
Returns
(str)
The current value of the text input widget.
Example
import streamlit as st
title = st.text_input('Movie title', 'Life of Brian')
st.write('The current movie title is', title)
Copy
(view standalone Streamlit app) | streamlit-docs.txt |
e4409cd96e13-67 | Text input widgets can customize how to hide their labels with the label_visibility parameter. If "hidden", the label doesn’t show but there is still empty space for it above the widget (equivalent to label=""). If "collapsed", both the label and the space are removed. Default is "visible". Text input widgets can also be disabled with the disabled parameter, and can display an optional placeholder text when the text input is empty using the placeholder parameter:
import streamlit as st
# Store the initial value of widgets in session state
if "visibility" not in st.session_state:
st.session_state.visibility = "visible"
st.session_state.disabled = False
col1, col2 = st.columns(2)
with col1:
st.checkbox("Disable text input widget", key="disabled")
st.radio(
"Set text input label visibility 👉",
key="visibility",
options=["visible", "hidden", "collapsed"],
)
st.text_input(
"Placeholder for the other text input widget",
"This is a placeholder",
key="placeholder",
)
with col2:
text_input = st.text_input(
"Enter some text 👇",
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
placeholder=st.session_state.placeholder,
)
if text_input:
st.write("You entered: ", text_input)
Copy
(view standalone Streamlit app)
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.select_slider
Next:
st.number_input
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.text_input - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library | streamlit-docs.txt |
e4409cd96e13-68 | Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.file_uploader
st.file_uploader
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a file uploader widget.
By default, uploaded files are limited to 200MB. You can configure this using the server.maxUploadSize config option. For more info on how to set config options, see https://docs.streamlit.io/library/advanced-features/configuration#set-configuration-options
Function signature
[source]
st.file_uploader(label, type=None, accept_multiple_files=False, key=None, help=None, on_change=None, args=None, kwargs=None, *, disabled=False, label_visibility="visible")
Parameters
label (str) | streamlit-docs.txt |
e4409cd96e13-69 | Parameters
label (str)
A short label explaining to the user what this file uploader is for. The label can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, Inline Code, Emojis, and Links.
This also supports:
Emoji shortcodes, such as :+1: and :sunglasses:. For a list of all supported codes, see https://share.streamlit.io/streamlit/emoji-shortcodes.
LaTeX expressions, by wrapping them in "$" or "$$" (the "$$" must be on their own lines). Supported LaTeX functions are listed at https://katex.org/docs/supported.html.
Colored text, using the syntax :color[text to be colored], where color needs to be replaced with any of the following supported colors: blue, green, orange, red, violet.
Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
For accessibility reasons, you should never set an empty label (label="") but hide it with label_visibility if needed. In the future, we may disallow empty labels by raising an exception.
type (str or list of str or None)
Array of allowed extensions. ['png', 'jpg'] The default is None, which means all extensions are allowed.
accept_multiple_files (bool)
If True, allows the user to upload multiple files at the same time, in which case the return value will be a list of files. Default: False
key (str or int)
An optional string or integer to use as the unique key for the widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
help (str)
A tooltip that gets displayed next to the file uploader.
on_change (callable) | streamlit-docs.txt |
e4409cd96e13-70 | A tooltip that gets displayed next to the file uploader.
on_change (callable)
An optional callback invoked when this file_uploader's value changes.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
disabled (bool)
An optional boolean, which disables the file uploader if set to True. The default is False. This argument can only be supplied by keyword.
label_visibility ("visible" or "hidden" or "collapsed")
The visibility of the label. If "hidden", the label doesn't show but there is still empty space for it above the widget (equivalent to label=""). If "collapsed", both the label and the space are removed. Default is "visible". This argument can only be supplied by keyword.
Returns
(None or UploadedFile or list of UploadedFile)
If accept_multiple_files is False, returns either None or an UploadedFile object.
If accept_multiple_files is True, returns a list with the uploaded files as UploadedFile objects. If no files were uploaded, returns an empty list.
The UploadedFile class is a subclass of BytesIO, and therefore it is "file-like". This means you can pass them anywhere where a file is expected.
Examples
Insert a file uploader that accepts a single file at a time:
import streamlit as st
import pandas as pd
from io import StringIO
uploaded_file = st.file_uploader("Choose a file")
if uploaded_file is not None:
# To read file as bytes:
bytes_data = uploaded_file.getvalue()
st.write(bytes_data)
# To convert to a string based IO:
stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
st.write(stringio)
# To read file as string:
string_data = stringio.read()
st.write(string_data) | streamlit-docs.txt |
e4409cd96e13-71 | # Can be used wherever a "file-like" object is accepted:
dataframe = pd.read_csv(uploaded_file)
st.write(dataframe)
Copy
Insert a file uploader that accepts multiple files at a time:
import streamlit as st
uploaded_files = st.file_uploader("Choose a CSV file", accept_multiple_files=True)
for uploaded_file in uploaded_files:
bytes_data = uploaded_file.read()
st.write("filename:", uploaded_file.name)
st.write(bytes_data)
Copy
(view standalone Streamlit app)
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.time_input
Next:
st.camera_input
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.file_uploader - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-72 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
API reference/
Input widgets/
st.selectbox
st.selectbox
Streamlit Version
v1.20.0
v1.19.0
v1.18.0
v1.17.0
v1.16.0
v1.15.0
v1.14.0
v1.13.0
v1.12.0
v1.11.0
v1.10.0
v1.9.0
v1.8.0
v1.7.0
v1.6.0
v1.5.0
v1.4.0
v1.3.0
v1.2.0
v1.1.0
v1.0.0
v0.89.0
v0.88.0
v0.87.0
v0.86.0
v0.85.0
v0.84.0
v0.83.0
Display a select widget.
Function signature
[source]
st.selectbox(label, options, index=0, format_func=special_internal_function, key=None, help=None, on_change=None, args=None, kwargs=None, *, disabled=False, label_visibility="visible")
Parameters
label (str)
A short label explaining to the user what this select widget is for. The label can optionally contain Markdown and supports the following elements: Bold, Italics, Strikethroughs, Inline Code, Emojis, and Links.
This also supports: | streamlit-docs.txt |
e4409cd96e13-73 | This also supports:
Emoji shortcodes, such as :+1: and :sunglasses:. For a list of all supported codes, see https://share.streamlit.io/streamlit/emoji-shortcodes.
LaTeX expressions, by wrapping them in "$" or "$$" (the "$$" must be on their own lines). Supported LaTeX functions are listed at https://katex.org/docs/supported.html.
Colored text, using the syntax :color[text to be colored], where color needs to be replaced with any of the following supported colors: blue, green, orange, red, violet.
Unsupported elements are not displayed. Display unsupported elements as literal characters by backslash-escaping them. E.g. 1\. Not an ordered list.
For accessibility reasons, you should never set an empty label (label="") but hide it with label_visibility if needed. In the future, we may disallow empty labels by raising an exception.
options (Sequence, numpy.ndarray, pandas.Series, pandas.DataFrame, or pandas.Index)
Labels for the select options. This will be cast to str internally by default. For pandas.DataFrame, the first column is selected.
index (int)
The index of the preselected option on first render.
format_func (function)
Function to modify the display of the labels. It receives the option as an argument and its output will be cast to str.
key (str or int)
An optional string or integer to use as the unique key for the widget. If this is omitted, a key will be generated for the widget based on its content. Multiple widgets of the same type may not share the same key.
help (str)
An optional tooltip that gets displayed next to the selectbox.
on_change (callable)
An optional callback invoked when this selectbox's value changes.
args (tuple)
An optional tuple of args to pass to the callback.
kwargs (dict) | streamlit-docs.txt |
e4409cd96e13-74 | An optional tuple of args to pass to the callback.
kwargs (dict)
An optional dict of kwargs to pass to the callback.
disabled (bool)
An optional boolean, which disables the selectbox if set to True. The default is False. This argument can only be supplied by keyword.
label_visibility ("visible" or "hidden" or "collapsed")
The visibility of the label. If "hidden", the label doesn't show but there is still empty space for it above the widget (equivalent to label=""). If "collapsed", both the label and the space are removed. Default is "visible". This argument can only be supplied by keyword.
Returns
(any)
The selected option
Example
import streamlit as st
option = st.selectbox(
'How would you like to be contacted?',
('Email', 'Home phone', 'Mobile phone'))
st.write('You selected:', option)
Copy
(view standalone Streamlit app)
Select widgets can customize how to hide their labels with the label_visibility parameter. If "hidden", the label doesn’t show but there is still empty space for it above the widget (equivalent to label=""). If "collapsed", both the label and the space are removed. Default is "visible". Select widgets can also be disabled with the disabled parameter:
import streamlit as st
# Store the initial value of widgets in session state
if "visibility" not in st.session_state:
st.session_state.visibility = "visible"
st.session_state.disabled = False
col1, col2 = st.columns(2)
with col1:
st.checkbox("Disable selectbox widget", key="disabled")
st.radio(
"Set selectbox label visibility 👉",
key="visibility",
options=["visible", "hidden", "collapsed"],
) | streamlit-docs.txt |
e4409cd96e13-75 | with col2:
option = st.selectbox(
"How would you like to be contacted?",
("Email", "Home phone", "Mobile phone"),
label_visibility=st.session_state.visibility,
disabled=st.session_state.disabled,
)
Copy
(view standalone Streamlit app)
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
st.radio
Next:
st.multiselect
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
st.selectbox - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Advanced features/
Configuration
Configuration
Streamlit provides four different ways to set configuration options. This list is in reverse order of precedence, i.e. command line flags take precedence over environment variables when the same configuration option is provided multiple times.
push_pin
Note
If changes to .streamlit/config.toml are made while the app is running, the server needs to be restarted for changes to be reflected in the app.
In a global config file at ~/.streamlit/config.toml for macOS/Linux or %userprofile%/.streamlit/config.toml for Windows:
[server]
port = 80
Copy
In a per-project config file at $CWD/.streamlit/config.toml, where $CWD is the folder you're running Streamlit from.
Through STREAMLIT_* environment variables, such as:
export STREAMLIT_SERVER_PORT=80
export STREAMLIT_SERVER_COOKIE_SECRET=dontforgottochangeme
Copy
As flags on the command line when running streamlit run: | streamlit-docs.txt |
e4409cd96e13-76 | As flags on the command line when running streamlit run:
streamlit run your_script.py --server.port 80
Copy
star
Tip
To set configuration options on Streamlit Community Cloud, read Optionally, add a configuration file in the Streamlit Community Cloud docs.
Telemetry
As mentioned during the installation process, Streamlit collects usage statistics. You can find out more by reading our Privacy Notice, but the high-level summary is that although we collect telemetry data we cannot see and do not store information contained in Streamlit apps.
If you'd like to opt out of usage statistics, add the following to your config file:
[browser]
gatherUsageStats = false
Copy
Theming
You can change the base colors of your app using the [theme] section of the configuration system. To learn more, see Theming.
View all configuration options
As described in Command-line options, you can view all available configuration option using:
streamlit config show
Copy
The command above will print something like this:
# Streamlit version: 1.20.0
[global]
# By default, Streamlit checks if the Python watchdog module is available and, if not, prints a warning asking for you to install it. The watchdog module is not required, but highly recommended. It improves Streamlit's ability to detect changes to files in your filesystem.
# If you'd like to turn off this warning, set this to True.
# Default: false
disableWatchdogWarning = false
# If True, will show a warning when you run a Streamlit-enabled script via "python my_script.py".
# Default: true
showWarningOnDirectExecution = true | streamlit-docs.txt |
e4409cd96e13-77 | # DataFrame serialization.
# Acceptable values: - 'legacy': Serialize DataFrames using Streamlit's custom format. Slow but battle-tested. - 'arrow': Serialize DataFrames using Apache Arrow. Much faster and versatile.
# Default: "arrow"
dataFrameSerialization = "arrow"
[logger]
# Level of logging: 'error', 'warning', 'info', or 'debug'.
# Default: 'info'
level = "info"
# String format for logging messages. If logger.datetimeFormat is set, logger messages will default to `%(asctime)s.%(msecs)03d %(message)s`. See [Python's documentation](https://docs.python.org/2.6/library/logging.html#formatter-objects) for available attributes.
# Default: "%(asctime)s %(message)s"
messageFormat = "%(asctime)s %(message)s"
[client]
# Whether to enable st.cache.
# Default: true
caching = true
# If false, makes your Streamlit script not draw to a Streamlit app.
# Default: true
displayEnabled = true
# Controls whether uncaught app exceptions are displayed in the browser. By default, this is set to True and Streamlit displays app exceptions and associated tracebacks in the browser.
# If set to False, an exception will result in a generic message being shown in the browser, and exceptions and tracebacks will be printed to the console only.
# Default: true
showErrorDetails = true
[runner]
# Allows you to type a variable or string by itself in a single line of Python code to write it to the app.
# Default: true
magicEnabled = true
# Install a Python tracer to allow you to stop or pause your script at any point and introspect it. As a side-effect, this slows down your script's execution.
# Default: false
installTracer = false | streamlit-docs.txt |
e4409cd96e13-78 | # Sets the MPLBACKEND environment variable to Agg inside Streamlit to prevent Python crashing.
# Default: true
fixMatplotlib = true
# Run the Python Garbage Collector after each script execution. This can help avoid excess memory use in Streamlit apps, but could introduce delay in rerunning the app script for high-memory-use applications.
# Default: true
postScriptGC = true
# Handle script rerun requests immediately, rather than waiting for script execution to reach a yield point. This makes Streamlit much more responsive to user interaction, but it can lead to race conditions in apps that mutate session_state data outside of explicit session_state assignment statements.
# Default: true
fastReruns = true
[server]
# List of folders that should not be watched for changes. This impacts both "Run on Save" and @st.cache.
# Relative paths will be taken as relative to the current working directory.
# Example: ['/home/user1/env', 'relative/path/to/folder']
# Default: []
folderWatchBlacklist = []
# Change the type of file watcher used by Streamlit, or turn it off completely.
# Allowed values: * "auto" : Streamlit will attempt to use the watchdog module, and falls back to polling if watchdog is not available. * "watchdog" : Force Streamlit to use the watchdog module. * "poll" : Force Streamlit to always use polling. * "none" : Streamlit will not watch files.
# Default: "auto"
fileWatcherType = "auto"
# Symmetric key used to produce signed cookies. If deploying on multiple replicas, this should be set to the same value across all replicas to ensure they all share the same secret.
# Default: randomly generated secret key.
cookieSecret = | streamlit-docs.txt |
e4409cd96e13-79 | # If false, will attempt to open a browser window on start.
# Default: false unless (1) we are on a Linux box where DISPLAY is unset, or (2) we are running in the Streamlit Atom plugin.
headless = false
# Automatically rerun script when the file is modified on disk.
# Default: false
runOnSave = false
# The address where the server will listen for client and browser connections. Use this if you want to bind the server to a specific address. If set, the server will only be accessible from this address, and not from any aliases (like localhost).
# Default: (unset)
# address =
# The port where the server will listen for browser connections.
# Default: 8501
port = 8501
# The base path for the URL where Streamlit should be served from.
# Default: ""
baseUrlPath = ""
# Enables support for Cross-Origin Request Sharing (CORS) protection, for added security.
# Due to conflicts between CORS and XSRF, if `server.enableXsrfProtection` is on and `server.enableCORS` is off at the same time, we will prioritize `server.enableXsrfProtection`.
# Default: true
enableCORS = true
# Enables support for Cross-Site Request Forgery (XSRF) protection, for added security.
# Due to conflicts between CORS and XSRF, if `server.enableXsrfProtection` is on and `server.enableCORS` is off at the same time, we will prioritize `server.enableXsrfProtection`.
# Default: true
enableXsrfProtection = true
# Max size, in megabytes, for files uploaded with the file_uploader.
# Default: 200
maxUploadSize = 200 | streamlit-docs.txt |
e4409cd96e13-80 | # Max size, in megabytes, of messages that can be sent via the WebSocket connection.
# Default: 200
maxMessageSize = 200
# Enables support for websocket compression.
# Default: false
enableWebsocketCompression = false
# Enable serving files from a `static` directory in the running app's directory.
# Default: false
enableStaticServing = false
# Server certificate file for connecting via HTTPS. Must be set at the same time as "server.sslKeyFile".
# ['DO NOT USE THIS OPTION IN A PRODUCTION ENVIRONMENT. It has not gone through security audits or performance tests. For the production environment, we recommend performing SSL termination by the load balancer or the reverse proxy.']
# sslCertFile =
# Cryptographic key file for connecting via HTTPS. Must be set at the same time as "server.sslCertFile".
# ['DO NOT USE THIS OPTION IN A PRODUCTION ENVIRONMENT. It has not gone through security audits or performance tests. For the production environment, we recommend performing SSL termination by the load balancer or the reverse proxy.']
# sslKeyFile =
[browser]
# Internet address where users should point their browsers in order to connect to the app. Can be IP address or DNS name and path.
# This is used to: - Set the correct URL for CORS and XSRF protection purposes. - Show the URL on the terminal - Open the browser
# Default: 'localhost'
serverAddress = "localhost"
# Whether to send usage statistics to Streamlit.
# Default: true
gatherUsageStats = true
# Port where users should point their browsers in order to connect to the app.
# This is used to: - Set the correct URL for CORS and XSRF protection purposes. - Show the URL on the terminal - Open the browser
# Default: whatever value is set in server.port.
serverPort = 8501
[mapbox] | streamlit-docs.txt |
e4409cd96e13-81 | [mapbox]
# Configure Streamlit to use a custom Mapbox token for elements like st.pydeck_chart and st.map. To get a token for yourself, create an account at https://mapbox.com. It's free (for moderate usage levels)!
# Default: ""
token = ""
[deprecation]
# Set to false to disable the deprecation warning for the file uploader encoding.
# Default: true
showfileUploaderEncoding = true
# Set to false to disable the deprecation warning for using the global pyplot instance.
# Default: true
showPyplotGlobalUse = true
[theme]
# The preset Streamlit theme that your custom theme inherits from. One of "light" or "dark".
# base =
# Primary accent color for interactive elements.
# primaryColor =
# Background color for the main content area.
# backgroundColor =
# Background color used for the sidebar and most interactive widgets.
# secondaryBackgroundColor =
# Color used for almost all text.
# textColor =
# Font family for all text in the app, except code blocks. One of "sans serif", "serif", or "monospace".
# font =
Copy
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Command-line options
Next:
Theming
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Configuration - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Advanced features/
Theming
Theming | streamlit-docs.txt |
e4409cd96e13-82 | school
Knowledge base
Home/
Streamlit library/
Advanced features/
Theming
Theming
In this guide, we provide examples of how Streamlit page elements are affected by the various theme config options. For a more high-level overview of Streamlit themes, see the Themes section of the main concepts documentation.
Streamlit themes are defined using regular config options: a theme can be set via command line flag when starting your app using streamlit run or by defining it in the [theme] section of a .streamlit/config.toml file. For more information on setting config options, please refer to the Streamlit configuration documentation.
The following config options show the default Streamlit Light theme recreated in the [theme] section of a .streamlit/config.toml file.
[theme]
primaryColor="#F63366"
backgroundColor="#FFFFFF"
secondaryBackgroundColor="#F0F2F6"
textColor="#262730"
font="sans serif"
Copy
Let's go through each of these options, providing screenshots to demonstrate what parts of a Streamlit app they affect where needed.
primaryColor
primaryColor defines the accent color most often used throughout a Streamlit app. A few examples of Streamlit widgets that use primaryColor include st.checkbox, st.slider, and st.text_input (when focused).
star
Tip
Any CSS color can be used as the value for primaryColor and the other color options below. This means that theme colors can be specified in hex or with browser-supported color names like "green", "yellow", and "chartreuse". They can even be defined in the RGB and HSL formats!
backgroundColor
Defines the background color used in the main content area of your app.
secondaryBackgroundColor
This color is used where a second background color is needed for added contrast. Most notably, it is the sidebar's background color. It is also used as the background color for most interactive widgets.
textColor | streamlit-docs.txt |
e4409cd96e13-83 | textColor
This option controls the text color for most of your Streamlit app.
font
Selects the font used in your Streamlit app. Valid values are "sans serif", "serif", and "monospace". This option defaults to "sans serif" if unset or invalid.
Note that code blocks are always rendered using the monospace font regardless of the font selected here.
base
An easy way to define custom themes that make small changes to one of the preset Streamlit themes is to use the base option. Using base, the Streamlit Light theme can be recreated as a custom theme by writing the following:
[theme]
base="light"
Copy
The base option allows you to specify a preset Streamlit theme that your custom theme inherits from. Any theme config options not defined in your theme settings have their values set to those of the base theme. Valid values for base are "light" and "dark".
For example, the following theme config defines a custom theme nearly identical to the Streamlit Dark theme, but with a new primaryColor.
[theme]
base="dark"
primaryColor="purple"
Copy
If base itself is omitted, it defaults to "light", so you can define a custom theme that changes the font of the Streamlit Light theme to serif with the following config
[theme]
font="serif"
Copy
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Configuration
Next:
Caching
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Theming - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-84 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit library/
Advanced features/
Widget semantics
Advanced notes on widget behavior
Widgets are magical and often work how you want. But they can have surprising behavior in some situations. Here is a high-level, abstract description of widget behavior, including some common edge-cases:
If you call a widget function before the widget state exists, the widget state defaults to a value. This value depends on the widget and its arguments.
A widget function call returns the current widget state value. The return value is a simple Python type, and the exact type depends on the widget and its arguments.
Widget states depend on a particular session (browser connection). The actions of one user do not affect the widgets of any other user.
A widget's identity depends on the arguments passed to the widget function. If those change, the call will create a new widget (with a default value, per 1).
If you don't call a widget function in a script run, we neither store the widget state nor render the widget. If you call a widget function with the same arguments later, Streamlit treats it as a new widget.
4 and 5 are the most likely to be surprising and may pose a problem for some application designs. When you want to persist widget state for recreating a widget, use Session State to work around 5.
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Dataframes
Next:
Pre-release features
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Widget semantics - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base | streamlit-docs.txt |
e4409cd96e13-85 | Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit Community Cloud/
Get started/
Deploy an app/
App dependencies
App dependencies
The main reason that apps fail to build properly is because Streamlit Community Cloud can't find your dependencies! So make sure you:
Add a requirements file for Python dependencies.
(optional) Add a packages.txt file to manage any external dependencies (i.e Linux dependencies outside Python environment).
push_pin
Note
Python requirements files should be placed either in the root of your repository or in the same directory as your Streamlit app.
Add Python dependencies
Streamlit looks at your requirements file's filename to determine which Python dependency manager to use in the order below. Streamlit will stop and install the first requirements file found.
Filename Dependency Manager Documentation
Pipfile pipenv docs
environment.yml conda docs
requirements.txt pip docs
pyproject.toml poetry docs
push_pin
Note
Only include packages in your requirements file that are not distributed with a standard Python installation. If any of the modules from base Python are included in the requirements file, you will get an error when you try to deploy. Additionally, we recommend that you use the latest version of Streamlit to ensure full Streamlit Community Cloud functionality.
priority_high
Warning
You should only use one requirements file for your app. If you include more than one (e.g. requirements.txt and Pipfile). Streamlit will first look in the directory of your Streamlit app; however, if no requirements file is found, Streamlit will then look at the root of the repo.
apt-get dependencies
If packages.txt exists in the root directory of your repository we automatically detect it, parse it, and install the listed packages as described below. You can read more about apt-get in their docs. | streamlit-docs.txt |
e4409cd96e13-86 | Add apt-get dependencies to packages.txt, one package name per line. For example:
freeglut3-dev
libgtk2.0-dev
Copy
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Deploy an app
Next:
Connect to data sources
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
App dependencies - Streamlit Docssearch
Search
⌘K
dark_mode
light_mode
description
Streamlit library
cloud
Streamlit Community Cloud
school
Knowledge base
Home/
Streamlit Community Cloud/
Get started/
Deploy an app/
Connect to data sources/
Secrets management
Secrets management
Introduction
It's generally considered bad practice to store unencrypted secrets in a git repository. If your application needs access to sensitive credentials the recommended solution is to store those credentials in a file that is not committed to the repository and to pass them as environment variables.
Secrets Management allows you to store secrets securely and access them in your Streamlit app as environment variables.
How to use Secrets Management
Deploy an app and set up secrets
Go to http://share.streamlit.io/ and click "New app" to deploy a new app with secrets.
Click "Advanced settings..."
You will see a modal appear with an input box for your secrets.
Provide your secrets in the "Secrets" field using TOML format. For example:
# Everything in this section will be available as an environment variable
db_username = "Jane"
db_password = "12345qwerty" | streamlit-docs.txt |
e4409cd96e13-87 | # You can also add other sections if you like.
# The contents of sections as shown below will not become environment variables,
# but they'll be easily accessible from within Streamlit anyway as we show
# later in this doc.
[my_cool_secrets]
things_i_like = ["Streamlit", "Python"]
Copy
Use secrets in your app
Access your secrets as environment variables or by querying the st.secrets dict. For example, if you enter the secrets from the section above, the code below shows you how you can access them within your Streamlit app.
import streamlit as st
# Everything is accessible via the st.secrets dict:
st.write("DB username:", st.secrets["db_username"])
st.write("DB password:", st.secrets["db_password"])
st.write("My cool secrets:", st.secrets["my_cool_secrets"]["things_i_like"])
# And the root-level secrets are also accessible as environment variables:
import os
st.write(
"Has environment variables been set:",
os.environ["db_username"] == st.secrets["db_username"],
)
Copy
star
Tip
You can access st.secrets via attribute notation (e.g. st.secrets.key), in addition to key notation (e.g. st.secrets["key"])—like st.session_state.
You can even use TOML sections to compactly pass multiple secrets as a single attribute.
Consider the following secrets:
[db_credentials]
username = "my_username"
password = "my_password"
Copy
Rather than passing each secret as attributes in a function, you can more compactly pass the section to achieve the same result. See the notional code below which uses the secrets above:
# Verbose version
my_db.connect(username=st.secrets.db_credentials.username, password=st.secrets.db_credentials.password) | streamlit-docs.txt |
e4409cd96e13-88 | # Far more compact version!
my_db.connect(**st.secrets.db_credentials)
Copy
Edit your app's secrets
Go to https://share.streamlit.io/
Open the menu for your app, and click "Settings".
You will see a modal appear. Click on the "Secrets" section and edit your secrets.
After you edit your secrets, click "Save". It might take a minute for the update to be propagated to your app, but the new values will be reflected when the app re-runs.
Develop locally with secrets
When developing your app locally, add a file called secrets.toml in a folder called .streamlit at the root of your app repo, and copy/paste your secrets into that file.
priority_high
Important
Be sure to add this file to your .gitignore so you don't commit your secrets!
Was this page helpful?
thumb_up
Yes
thumb_down
No
edit
Suggest edits
forum
Still have questions?
Our forums are full of helpful information and Streamlit experts.
Previous:
Connect to data sources
Next:
Share your app
Home
Contact Us
Community
Copyright © 2023, Streamlit Inc.
Secrets management - Streamlit Docs | streamlit-docs.txt |
No dataset card yet
New: Create and edit this dataset card directly on the website!
Contribute a Dataset Card- Downloads last month
- 7
Size of downloaded dataset files:
144 kB
Size of the auto-converted Parquet files:
70.4 kB
Number of rows:
89
Models trained or fine-tuned on jacobgoldenart/streamlit-docs