Streamlit Plotly Chart Kwargs Deprecation Warning Fix

Jan 17, 2026 by Editorial Team 54 views

Xioubglqw Bglrwb plotly_chart kwargs Deprecation Warning Bgmrw Hmspvagm

Understanding the Streamlit Plotly Chart Kwargs Deprecation Warning

Hey guys! Let's dive into this Streamlit and Plotly issue. You might have encountered a deprecation warning when using st.plotly_chart, especially when setting the width to "content" or adjusting the height. This can be super annoying, especially if you're not even passing any extra keyword arguments! It turns out, this warning pops up even when you're just using the standard, documented parameters. So, what's the deal and how can we fix it?

The core of the problem lies in how Streamlit handles the kwargs (keyword arguments) for st.plotly_chart. A change in the library triggered this warning to appear even when you're only using width or height. Basically, it's a false alarm! Deprecation warnings are there to tell us that something is going to be removed or changed in a future version, so we can update our code accordingly. But in this case, it's warning us about something we're not even doing wrong. Understanding this warning is the first step to resolving it and ensuring our Streamlit apps run smoothly.

To really understand the context, let's break down what kwargs are. In Python, kwargs (short for keyword arguments) allow you to pass a variable number of arguments to a function. These arguments are passed as a dictionary, where each key is the name of the argument, and each value is the value you're passing. When the Streamlit team made changes related to how kwargs are handled in st.plotly_chart, it inadvertently caused this warning to appear even when no extra keyword arguments were being used. This is why setting width="content" triggers the warning, even though width is a documented and perfectly valid parameter.

Knowing this, we can look for solutions and workarounds to get rid of the warning and keep our Streamlit apps clean and warning-free. We'll explore some code examples and steps to reproduce the issue, so you can confirm that you're experiencing the same problem, and then we'll look at potential fixes.

Reproducible Code Example

To illustrate the issue, here’s a simple code snippet that triggers the deprecation warning:

import plotly.graph_objects as go
import streamlit as st

fig = go.Figure()
fig.add_trace(go.Barpolar(r=[1], theta=[0], width=[120]))
fig.update_layout(width=500, height=360)

st.plotly_chart(fig, width="content")

When you run this code in Streamlit, you'll see the deprecation warning, even though you're only using the width parameter, which is perfectly legitimate. This example clearly shows that the warning isn't triggered by misuse of the function but rather by an internal issue in Streamlit's handling of kwargs.

Let's break down what's happening in this code:

Import Libraries: We start by importing the necessary libraries: plotly.graph_objects for creating the plot and streamlit for rendering it in the app.
Create a Plotly Figure: We create a simple polar bar chart using plotly.graph_objects. This involves creating a go.Figure object and adding a go.Barpolar trace to it. The r, theta, and width parameters define the characteristics of the bar.
Update Layout: We update the layout of the figure to set the width and height. This ensures that the plot has specific dimensions when it's displayed.
Render in Streamlit: Finally, we use st.plotly_chart to display the plot in the Streamlit app. The key part here is the width="content" argument, which tells Streamlit to adjust the width of the plot to fit the content area. This is what triggers the deprecation warning.

Steps To Reproduce

To reproduce the warning, just run the above code in a Streamlit app. Make sure you have the latest version of Streamlit installed. After running the app, check the console or terminal where you ran the Streamlit command. You should see the deprecation warning message.

Expected Behavior

The expected behavior is that when you switch from the deprecated use_container_width to the width argument (as the documentation suggests), you shouldn't get a deprecation warning. Using the documented width argument should work without any warnings, ensuring a smooth transition and adherence to the recommended practices.

Instead of seeing a warning, the plot should simply adjust its width to fit the container, providing a responsive layout without any console noise. This clean and expected behavior is what we aim for when following the official documentation and updating our code accordingly.

Current Behavior

The current behavior is that the deprecation warning appears even when you're only using the width parameter, like this: st.plotly_chart(fig, width="content"). This happens because of the way Streamlit handles kwargs internally. The warning message looks something like this:

UserWarning: Variable keyword arguments for st.plotly_chart have been deprecated and will be removed in a future release. Use the config argument instead to specify Plotly configuration options.

This warning is misleading because you're not actually passing any variable keyword arguments. It's triggered simply by including the width parameter. This issue can cause confusion and unnecessary concern for developers who are following the documentation and trying to use the function correctly.

The code snippet responsible for this behavior is:

if kwargs:
    show_deprecation_warning(
        "Variable keyword arguments for st.plotly_chart have been "
        "deprecated and will be removed in a future release. Use the "
        "config argument instead to specify Plotly configuration "
        "options."
    )

This code checks if there are any kwargs passed to the function. If there are, it shows the deprecation warning. However, it doesn't differentiate between documented parameters like width and actual variable keyword arguments, causing the warning to appear even when it shouldn't.

Is this a regression?

Yes, this is indeed a regression. It used to work fine in previous versions of Streamlit. This means that a recent change in the library has introduced this issue, causing the deprecation warning to appear incorrectly.

Debug Info

Here’s some debug information to help understand the context:

Streamlit version: 1.30.0 (or higher)
Python version: Python 3.7+
Operating System: Any (MacOs, Windows, Linux)
Browser: Any (Chrome, Firefox, Safari)

Additional Information

No additional information provided.

This detailed breakdown should give you a clear understanding of the issue, how to reproduce it, and what the expected and current behaviors are. Now, let's look at some potential solutions and workarounds!

Potential Solutions and Workarounds

While waiting for a fix from the Streamlit team, here are a few workarounds you can use to suppress the warning or avoid it altogether:

Ignore the Warning: Since the warning is a false alarm, you can simply ignore it. This isn't ideal, but it's a quick and easy way to keep your code running without any changes. However, be aware that ignoring warnings can sometimes hide real issues, so use this approach with caution.
Suppress the Warning: You can use Python's warnings module to suppress the deprecation warning. This will prevent the warning from being displayed in the console. Here's how you can do it:
```
import warnings

warnings.filterwarnings("ignore", category=DeprecationWarning)
```
Place this code at the beginning of your Streamlit app. This will suppress all deprecation warnings, so make sure you're not hiding any important warnings as well.
Use use_container_width=True: If you're using an older version of Streamlit, you can revert to using use_container_width=True instead of width="content". This will achieve the same effect without triggering the warning. However, keep in mind that use_container_width is deprecated, so you'll eventually need to switch to the width parameter when Streamlit fixes the issue.

Conclusion

The deprecation warning in st.plotly_chart when using width="content" is a known issue in Streamlit. It's triggered by how Streamlit handles kwargs internally and is not caused by any misuse of the function. While waiting for a fix, you can use the workarounds mentioned above to suppress the warning or avoid it altogether. Keeping an eye on Streamlit's release notes and issue tracker will help you stay informed about when a proper fix is available. Happy coding, and may your Streamlit apps be warning-free!