RuntimeError: There is no current event loop in thread error with Streamlit and Asyncio
  • 23-May-2023
Lightrun Team
Author Lightrun Team
RuntimeError: There is no current event loop in thread error with Streamlit and Asyncio

RuntimeError: There is no current event loop in thread error with Streamlit and Asyncio

Lightrun Team
Lightrun Team

Explanation of the problem

When running pyppeteer, a dependency that relies on asyncio, to load data from a rendered web page, an error occurs in the context of using Jupyter, which depends on tornado. The error message states “RuntimeError: This event loop is already running.” The issue stems from the fact that tornado was reworked with asyncio, and the Jupyter developers didn’t provide a practical solution. To overcome this problem, the library nest_asyncio was introduced. However, even with nest_asyncio included, a different error is encountered: “RuntimeError: There is no current event loop in thread ‘ScriptRunner.scriptThread’.”

with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for RuntimeError: There is no current event loop in thread error with Streamlit and Asyncio

In summary, the provided solutions address the issue related to the event loop in asyncio. The first solution suggests replacing the line loop = asyncio.get_event_loop() with loop = asyncio.new_event_loop() and setting the new event loop using asyncio.set_event_loop(loop). This change ensures that a fresh event loop is used.

The second solution involves creating a coroutine function and executing it within a new event loop. By calling new_event_loop() and set_event_loop(loop), a new event loop is established. The coroutine function can then be run using run(coro), allowing the execution to proceed without encountering errors related to the event loop.

It is recommended to try both solutions and determine which one works best for the specific scenario. Depending on the context and the intricacies of the code, either solution may be suitable for resolving the event loop-related problems in asyncio.


Other popular problems with streamlit

Problem: Streamlit crashes or becomes unresponsive when displaying large datasets or visualizations.

When working with large datasets or complex visualizations in Streamlit, the application may crash or become unresponsive. This can happen due to memory limitations or inefficiencies in rendering and handling large amounts of data.


One possible solution to this problem is to optimize the data processing and visualization pipeline. This can involve using more efficient data structures or algorithms to handle the dataset, reducing unnecessary computations or rendering operations, and implementing pagination or data sampling techniques to display only a subset of the data at a given time. Additionally, utilizing caching mechanisms or precomputing certain visualizations can help improve performance and prevent crashes.

Problem: Streamlit displays stale or outdated content when the underlying data changes.

Streamlit’s default behavior may not automatically update the displayed content when the underlying data changes. This can lead to inconsistencies or stale information being presented to the users, especially in dynamic or real-time applications.


To address this issue, Streamlit provides several mechanisms to handle data updates and ensure the displayed content reflects the latest changes. One approach is to use Streamlit’s caching feature, which allows functions or code blocks to be memoized based on their inputs. By appropriately caching the data retrieval or processing functions, Streamlit can automatically detect when the underlying data changes and update the displayed content accordingly. Another option is to utilize reactive programming techniques, such as using reactive widgets or explicit event handlers, to trigger updates and refresh the displayed content whenever the data changes.

Problem: Streamlit app deployment fails or encounters compatibility issues on certain platforms or environments.

Deploying a Streamlit application can sometimes be challenging due to compatibility issues or limitations on specific platforms or environments. This can include difficulties with containerization, dependency management, or conflicts with underlying libraries or system configurations.


To overcome deployment issues, it is essential to ensure compatibility and provide the necessary environment configurations. Streamlit provides features like Docker support, allowing the app to be containerized and deployed in a controlled environment. Additionally, using virtual environments or package managers, such as Conda or Pipenv, can help manage dependencies and ensure compatibility across different platforms. It is also advisable to thoroughly test the application on the target deployment environment and address any potential conflicts or compatibility issues beforehand.

A brief introduction to Streamlit

Streamlit is a Python library designed to facilitate the rapid development of interactive and data-driven web applications. It enables developers to create intuitive and visually appealing user interfaces directly from their Python scripts, without requiring extensive web development knowledge. Streamlit follows a declarative programming paradigm, where the user specifies the desired elements and visualizations, and Streamlit takes care of rendering them in a web browser.

At its core, Streamlit leverages the concept of reactive programming, allowing developers to create interactive applications that automatically update in response to user inputs or changes in underlying data. This is achieved through the use of Streamlit’s built-in widgets, such as sliders, dropdowns, and checkboxes, which can be attached to Python variables. When a user interacts with these widgets, the corresponding variables are automatically updated, triggering the re-execution of the affected parts of the script and refreshing the displayed content.

Streamlit also provides a wide range of pre-built components and visualizations, including tables, charts, and maps, which can be easily integrated into the application. Additionally, it supports integration with popular Python libraries like Pandas, Matplotlib, and Plotly, allowing developers to seamlessly incorporate advanced data processing and visualization capabilities into their Streamlit apps. Overall, Streamlit simplifies the process of building interactive web applications in Python, enabling developers to focus on their data analysis and application logic rather than the complexities of web development.


Most popular use cases for Streamlit

  1. Streamlit can be used for data exploration and visualization, allowing developers to quickly create interactive dashboards and visualizations from their Python scripts. By leveraging Streamlit’s built-in widgets and visual components, developers can create dynamic and responsive interfaces that enable users to explore and analyze data in real time.
  2. Streamlit can be used for building machine learning and data science applications, providing a convenient way to showcase and share models, experiments, and visualizations. With Streamlit, developers can create user-friendly interfaces that allow users to interact with models, input data, and visualize predictions or results.
  3. Streamlit can be used for rapid prototyping and building web applications with minimal code. It provides a simple and intuitive way to create interactive web interfaces directly from Python scripts, eliminating the need for separate HTML, CSS, and JavaScript files. With Streamlit, developers can iterate quickly and easily update the application’s logic and visual elements. This makes it a powerful tool for building prototypes, demos, and proof-of-concepts.

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.