Shiny for Python

querychat in Python: Query Your Data with Natural Language | Shiny + LLMs | Veerle van Leemput

Learn how to use QueryChat to add natural language querying to your Python data applications. This tutorial shows you how to let users ask questions about data without building complex filters or dashboards. In this video, data scientist Veerle Eeftink demonstrates how to integrate QueryChat with Shiny for Python to create interactive data exploration tools powered by LLMs (Claude, GPT-4, Gemini). What You'll Learn: - Set up QueryChat in minutes with any data source - Understand how QueryChat translates natural language to SQL - Build custom dashboards with reactive data frames - Configure LLM behavior with greetings, data descriptions, and instructions - Ensure safety and read-only access for production environments Key Features: Works with Claude, GPT-4, Gemini, and other LLMs Transparent SQL generation (no black box) Integrates with Shiny, Streamlit, and other frameworks Uses DuckDB or bring your own SQL database Read-only operations for data safety Enterprise-ready with private LLM support Resources: - QueryChat Documentation: [https://posit-dev.github.io/querychat/py/index.html] - Blog Post: "Where Questions Become Queries" [https://shiny.posit.co/blog/posts/querychat-python-r/] - SheScores Demo App [https://github.com/hypebright/shescores-dashboard/tree/main/Python] #Python #DataScience #LLM #AI #Shiny #QueryChat #NaturalLanguage #SQL #DataVisualization Timestamps 00:00 - Introduction: The dashboard problem 01:28 - What is QueryChat? 02:36 - Demo: Three things you'll learn today 03:00 - Setup: LLM API keys and installation 04:04 - Quick start: First QueryChat app in 5 lines 04:27 - Live demo: Natural language queries 06:10 - How QueryChat works under the hood 07:19 - Four benefits: Reliability, transparency, reproducibility, safety 08:17 - Tool calling explained 08:54 - Schema information and DuckDB integration 09:29 - Building custom interfaces 09:45 - Customizing behavior: Greetings and data descriptions 11:16 - Adding custom instructions to the LLM 11:35 - Building a Shiny dashboard with QueryChat 13:09 - Code walkthrough: Sidebar chat and reactive data frames 14:14 - Complete dashboard demo 14:52 - Safety and security deep dive 16:22 - Resources and links

End-to-End Data Science Workflow with the Posit Team Snowflake Native App

Posit Product Manager, Chetan Thapar, demonstrates how the Posit Team Native App for Snowflake delivers an end-to-end workflow—exploration, iteration, and deployment—in minutes, not weeks. Built directly inside the Snowflake security perimeter, the app gives data teams instant access to governed data, managed infrastructure, and familiar tools like Posit Workbench, Connect, and Shiny for Python. Watch how AI assistants like DataBot and Positron accelerate EDA, streamline coding, and help developers build an interactive, LLM-powered dashboard with ease. With one-click deployment and automatic Snowflake governance applied to every user, this demo shows what modern data science looks like when speed, security, and productivity work together. Learn more about the Posit partnership with Snowflake: https://posit.co/use-cases/snowflake/ Get the Posit Team Native App: https://pos.it/Team-Native-App-Snowflake

AskRADS: An AI Recommendation Agent for Maximizing ROI of Data Science Collaborations (Regis James)

AskRADS: An AI Recommendation Agent for Maximizing the ROI of Data Science Collaborations Speaker(s): Regis A. James Abstract: Blockers to crucial data-driven decisions can often be a challenge. To address this, we established RADS, the Regeneron Analysts and Data Scientists, as a Community of Practice for exchanging strategies on eliminating these obstacles. RADS has grown to nearly 500 members, creating a new challenge: avoiding redundancy and helping non-RADS colleagues find the right experts. To solve this, we developed AskRADS, an AI agent on Posit Connect that provides recommendations based on discussions, experts, and relevant resources. It uses R, Shiny for Python, FastAPI, LangGraph, Neo4j GraphRAG, and MySQL. This talk will cover its architecture, AI search solutions, and optimization techniques. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Semantic Search for the Rest of Us with DuckDB (Marcos Huerta, Carmax) | posit::conf(2025)

Semantic Search for the Rest of Us with DuckDB Speaker(s): Marcos Huerta Abstract: Semantic search matches a search query against documents not just by directly matching words, but by ranking results using semantic meaning - for example searching for “cat” could also turn up documents that have “tiger.” While many enterprise level solutions exist for semantic search, I will show a low memory technique in Python that enables live semantic search for small to medium document collections that need to be deployed in constrained memory/ CPU environments - such as Posit Connect Cloud or a small cloud server. I will show how a web app (such as Shiny for Python) using just a few hundred megabytes of memory can enable live search using the fixed array support in DuckDB, and the open source library LlamaCPP. posit::conf(2025) Subscribe to posit::conf updates: https://posit.co/about/subscription-management/

Daniel Chen - Shiny for Python: Building Production-Ready Dashboards in Python | SciPy 2025

Shiny is a framework for building web applications and data dashboards in Python. In this workshop, you will see how the basic building blocks of shiny can be extended to create your own scalable production-ready python applications. In particular, this workshop covers: - Overview of the basic building blocks of a Shiny for Python application - How to refactor applications into shiny modules - How to write tests for your shiny application - Deploy and share your application At the end of this course you will be able to: - Build a Shiny app in Python - Refactor your reactive logic into Shiny Modules - Identify when to write Shiny modules - Write unit tests and end-to-end tests for your shiny application - Deploy and share your application (for free!)

Create a PydyTuesday Shiny app with Shiny Assistant

Watch Sara Altman quickly prototype a Shiny app for PydyTuesday with Shiny Assistant, an AI-powered tool designed to help you with Shiny. Shiny Assistant can create Shiny apps from scratch, debug or assist with existing apps, and answer general questions about Shiny. Shiny Assistant: https://gallery.shinyapps.io/assistant/ Learn more: * Shiny for Python: https://shiny.posit.co/py/ * The potential for AI-powered Shiny app prototyping with Shiny Assistant: https://posit.co/blog/ai-powered-shiny-app-prototyping/ * TidyTuesday project: https://github.com/rfordatascience/tidytuesday * Posit PydyTuesday GitHub repo: https://github.com/posit-dev/python-tidytuesday * Other videos in this PydyTuesday playlist: https://youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9&si=i09_CuKmjiV86D-9 #pythoncontent

Shiny Assistant - Prototype Shiny for Python Apps with AI

Ryan Johnson walks through how to use Shiny Assistant, an AI-powered tool for Shiny for Python app development. Learn how to quickly create and interact with a Shiny app based on your own description. Shiny Assistant is a powerful tool for rapid prototyping and iteration. You can also ask it questions about how to use Shiny. Shiny Assistant: https://gallery.shinyapps.io/assistant/ Learn more: * Shiny for Python: https://shiny.posit.co/py/ * The potential for AI-powered Shiny app prototyping with Shiny Assistant: https://posit.co/blog/ai-powered-shiny-app-prototyping/ * TidyTuesday project: https://github.com/rfordatascience/tidytuesday * Posit PydyTuesday GitHub repo: https://github.com/posit-dev/python-tidytuesday * Other videos in this PydyTuesday playlist: https://www.youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9 #pythoncontent

Deploy your work to Posit Connect Cloud

*Deploy your data science content with Posit Connect Cloud!* Daniel Chen walks you through deploying a Shiny for Python app to Connect Cloud, sharing your content, and updating it via GitHub. While this video focuses on Shiny for Python, Posit Connect Cloud also supports Quarto, Streamlit, Jupyter, and more! Use Posit Connect Cloud to share your PydyTuesday work with the world. Learn more here: https://github.com/posit-dev/python-tidytuesday. Resources: * Shiny app code: https://github.com/posit-dev/py-shiny-templates/tree/main/dashboard * Posit Connect Cloud: https://connect.posit.cloud/ * Shiny for Python: https://shiny.posit.co/py/ * Other videos in this PydyTuesday playlist: https://www.youtube.com/playlist?list=PL9HYL-VRX0oSDQjicFMLIIdcLv5NuvDp9 #pythoncontent

Wes McKinney & Hadley Wickham (on cross-language collaboration, Positron, career beginnings, & more)

We hosted a special event hosted by Posit PBC with Wes McKinney (Pandas & Apache Arrow) and Hadley Wickham (rstats & tidyverse) to ask questions, share your thoughts, and exchange insights about cross-language collaboration with fellow data community members. Here's a preview into what came up in conversation: 1. Cross-language collaboration between R and Python 2. Positron, a new polyglot data science IDE 3. Open source development, how Wes and Hadley got involved in open source and their experiences in building and maintaining open-source projects such as Pandas and the tidyverse. 4. Documentation for R and Python, especially in the context of teams that use both languages (shoutout to Quarto!) 5. The use of LLMs in data science 6. The emergence of libraries like Polars and DuckDB 7. Challenges of switching between the two languages 8. Package development and maintenance for polyglot teams that have internal packages in both languages 9. The future of data science The chat was on fire for this conversation and we've gathered most of the links shared among the community below: Documentation mentioned: Positron, next-generation data science IDE built by Posit: https://positron.posit.co/ Quarto tabset documentation: https://quarto.org/docs/output-formats/html-basics.html#tabset-groups Packages / Extensions mentioned: Pins: https://pins.rstudio.com/ Vetiver: https://vetiver.posit.co Orbital: https://orbital.tidymodels.org Elmer: https://elmer.tidyverse.org Tabby Extension: https://quarto.thecoatlessprofessor.com/tabby/ Blog posts: AI chat apps with Shiny for Python: https://shiny.posit.co/blog/posts/shiny-python-chatstream/ Using an LLM to enhance a data dashboard written in Shiny: R Sidebot & Python Sidebot Marco Gorelli Data Science Hangout (polars): https://youtu.be/lhAc51QtTHk?feature=shared Emily Riederer's blog post on Polars: https://www.emilyriederer.com/post/py-rgo-polars/ Jeffrey Sumner’s tabset example: https://rpy.ai/posts/visualizations%20with%20r%20and%20python/r_python_visualizations Emily Riederer's blog post on Python and R ergonomics: https://www.emilyriederer.com/post/py-rgo/11 Sam Tyner's blog post on Lessons from "Tidy Data": https://medium.com/@sctyner90/10-lessons-from-tidy-data-on-its-10th-anniversary-dbe2195a82b7 Other: Hadley Wickham's cocktails website: https://cocktails.hadley.nz5 Posit subscription management to find out about new tools, events, etc.: https://posit.co/about/subscription-management/ New to Posit? Posit builds enterprise solutions and open source tools for people who do data science with R and Python. (We are also the company formerly called RStudio) We'd love to have you join us for future community events! Every Thursday from 12-1pm ET we host a Data Science Hangout with the community and invite you to join us! You can add that event to your calendar with this link: https://www.addevent.com/event/Qv9211919

Hadley Wickham

Barret Schloerke - Editable data frames in Py-Shiny: Updating original data in real-time

Integrating editable data frames into Py-Shiny and Shinylive applications streamlines data scientists' workflows by allowing real-time data manipulation directly within interactive web applications. This new feature enables users to edit cells within the data frame output. Using the empowered data frame renderer, we can facilitate immediate analysis and visualization feedback. It simplifies the process of data exploration and hypothesis testing, as changes to the data set can be instantly reflected in the application's outputs without the requirement to update the original data, keeping data scientists “scientists”, not data janitors. Talk by Barret Schloerke Slides: http://schloerke.com/presentation-2024-08-13-posit-shiny-data-frame/ Slides GitHub Repo: https://github.com/schloerke/presentation-2024-08-13-posit-shiny-data-frame Shiny: https://shiny.posit.co/ Shiny for Python: https://shiny.posit.co/py/ Component gallery: https://shiny.posit.co/py/components/ Edit `Data Grid` table cells: https://shiny.posit.co/py/components/outputs/data-grid/

Barret Schloerke

Winston Chang - Building ML and AI apps with Shiny for Python

In the last few months, the best LLMs have taken a big step forward in their ability to help write code. We’ve been building a tool that uses an LLM to help you learn Shiny and build Shiny applications much faster than ever before. If you feel like you don’t have the time to invest in learning Shiny, this might change your mind. You’ll get up and running with Shiny in no time, and you’ll be able to learn from the AI as you go. If you already know Shiny, you’ll be able to dramatically accelerate your development process, and you’ll find yourself trying out new things that wouldn’t have been worth the effort before. Talk by Winston Chang

Winston Chang

Deploy an LLM-powered Shiny for Python app to Connect Cloud in minutes!

Connect Cloud lets you quickly deploy data applications and documents from public GitHub repositories for Python and R projects. This short demo showcases secret variable management on Connect Cloud to help deploy an LLM-powered Shiny for Python application. → Signup for a free Connect Cloud account → https://connect.posit.cloud/ → View the how-to guide → https://docs.posit.co/connect-cloud/how-to/python/llm-shiny-python.html

Creating tests for Shiny for Python apps | Karan Gathani | Posit

With the Shiny for Python v1.0 release, Shiny provides a simple way to create a test file for your Shiny app. The shiny add test command is a helpful CLI tool for Shiny app developers. It simplifies the process of creating test files for their applications. When you run this command, it prompts you to input two pieces of information: the path to your Shiny app file and the desired location for the new test file. Once you provide these details, the command automatically generates a test file at the specified location. This new file includes a pre-made test template, giving you a solid starting point for writing your app's tests. Reference documentation - https://shiny.posit.co/py/docs/unit-testing.html https://shiny.posit.co/py/docs/playwright-testing.html

Karan Gathani

Using controllers to write robust Shiny for Python app tests | Karan Gathani | Posit

With the Shiny for Python v1.0 release, controllers were exposed to provide a structured and consistent way for users to interact with and test UI components in Shiny applications. They offer an abstraction layer that encapsulates the complexity of interacting with specific UI elements, making it easier for developers to write robust tests and automate interactions with their Shiny apps. Reference documentation - https://shiny.posit.co/py/api/testing/ https://shiny.posit.co/py/docs/playwright-testing.html

Karan Gathani

Workflow Demo Live Q&A - July 31st

Please join us for the live Q&A session for the July 31st Workflow Demo - this Q&A room will open up immediately following the demo. How to create editable data tables in Shiny for Python Anonymous questions: https://pos.it/demo-questions Demo: 11 am ET [https://youtu.be/zDJc8sXh2qw?feature=shared] Q&A: ~11:30 am ET

How to create editable data tables in Shiny for Python

You built a beautiful Shiny app…but someone just asked you where the Excel doc is. Well, what if they had the ability to edit a table within the app, as if it were a spreadsheet?! Editable tables are a recently developed feature for Shiny for Python, allowing the table itself to become an input value, so your app can react to—and use—the data your user enters. On Wednesday, July 31st at 11 am, Garrett Grolemund will walk through building a basic app using an editable table and discuss the many potential use cases now enabled. Helpful links: WSJF App - https://github.com/garrettgman/wsjf-app Interest Calculator App - https://github.com/garrettgman/mortgage-app Value Change App - https://github.com/garrettgman/value-changer-app To do a free trial of Posit Connect: https://pos.it/chat-with-us Posit Connect Cloud: https://connect.posit.cloud/ Q&A Session: https://youtube.com/live/-nG5aco-g84?feature=share Ps. We host these workflow demo events the last Wednesday of every month! We'd love to have you join us again! You can add it to your calendar here: https://pos.it/team-demo If you have any questions or suggestions for future sessions, let us know in the comments below :) #python

How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python)

This is part 5 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we dive into advanced styling techniques to enhance the visual appeal and professionalism of your Shiny dashboards. We'll cover: - Adding a logo and custom title - Making use of custom HTML elements - Using CSS to style Shiny components - Customizing Altair charts for a polished look - Advanced Plotly chart modifications - Applying a consistent color theme and layout By the end of this video, you'll have a styled dashboard, ready for a professional presentation. Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Shiny for Python Homepage: https://shiny.posit.co/py/ Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli **Video Timeline:** 0:00 - Video Overview & Setup 1:50 - Modifying HTML and CSS in Shiny 7:44 - Adding a Logo Image 10:26 - Styling Labels and Containers (Aligning our Image w/ the Title — Custom Divs) 20:20 - Customizing Altair Charts (Gridlines, Font, Axis Labels, Etc.) 27:49 - Customizing Plotly Visualizations 37:16 - Customizing Seaborn & Folium Heatmaps 44:15 - Final Touches, Clean Up, Recap and Next Steps If you enjoyed this series, give it a thumbs up and subscribe to the channel to stay updated! All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python)

This is part 4 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we'll explore how to integrate popular Python visualization libraries like Matplotlib, Plotly, Seaborn, and Altair into your Shiny apps. This allows you to leverage your existing visualization skills and seamlessly include them in interactive dashboards. We'll cover: - Integrating Matplotlib and Seaborn for detailed visualizations - Utilizing Altair and Plotly for dynamic charts - Implementing Folium for interactive maps - Customizing data tables with additional filters and selection modes By the end of this video, you'll have a rich and diverse set of visualizations in your Shiny dashboard, setting the stage for the final styling touches in the next video. Shiny for Python Homepage: https://shiny.posit.co/py/ Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli Video Timeline! 0:00 - Video Overview & Recap of Previous Video Dashboards 1:38 - Getting Setup with the Code (cloning branch from GitHub) 3:15 - Adding Matplotlib-based visualizations (render.plot Shiny for Python decorator) 10:15 - Create a Seaborn Heatmap Chart (Sales Volume by Hour of the Day) 14:59 - Creating Interactive Charts with Jupyter Widgets (Plotly, Altair, Bokeh, Pydeck, & More…) | render_widget decorator 20:14 - Implementing Folium for Location-Based Heatmaps (render.ui decorator) 25:32 - Enhancing DataFrames with Filters and Selection Modes (render.data_frame, render.DataGrid, render.DataTable, etc.) 28:49 - Additional Rendering Options, Final Touches and Next Steps Stay tuned for part 5, where we'll focus on styling and finalizing our dashboard. If you enjoyed this video, give it a thumbs up and subscribe to the channel to stay updated! All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

How to make your Python Dashboard look Professional! (Layouts in Shiny)

This is part 3 of our multi-part series on creating professional dashboards with Shiny for Python. In this video, we focus on enhancing the visual appeal and structure of your Shiny dashboards using various layout components. We'll cover: - Implementing layout templates for quick setup - Using cards and sidebars for a clean, organized look - Customizing columns and grids for better data presentation - Adding tab options for multiple views within a dashboard By the end of this video, you'll have a more polished and professional-looking dashboard, setting the stage for advanced visualizations in upcoming videos. Shiny for Python Homepage: https://shiny.posit.co/py/ Access the GitHub repo with all parts of this project: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Video by @KeithGalli Video Timeline! 0:00 - Video Overview & Progress Thus Far 1:28 - Using Shiny Templates to Get Started Fast 3:21 - Using Layout Components to Customize our Apps (Cards, Sidebars, Tabs, etc.) 7:55 - Adding a Sidebar within a Card 12:38 - Adding a Card with Tabs to Display Various Visualizations 17:35 - Structuring Data in Columns / Grids (layout_columns() & layout_column_wrap()) 26:30 - Final Touches & Tips (Filling in Visualizations into our Tab Views) Stay tuned for part 4, where we'll add more advanced visualizations, and part 5, where we'll focus on customizing styles and adding final touches. If you enjoyed this video, give it a thumbs up and subscribe to the channel to stay updated! All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

How to make Interactive Python Dashboards! (Reactivity in Shiny)

This is a quick-start guide to Shiny for Python, part 2 of a multi-part series. Data scientists need to quickly build web applications to create and share interactive visualizations, giving others a way to interact with data and analytics. Shiny helps you do this. In this video, we'll build off of the last tutorial where we learned the basics of building, sharing, and deploying a Shiny app in Python. This video specifically focuses on reactivity in Shiny. You can watch this video as a standalone, but it may be helpful to watch the previous video (https://youtu.be/I2W7i7QyJPI). We'll cover: ⬡ Creating toggle options for dynamic visualizations ⬡ Understanding Shiny's reactivity model ⬡ Implementing various input selectors ⬡ Building reactive components and visualizations ⬡ Using reactive calculations and effects ⬡ Adding and formatting plots with Plotly ⬡ Documentation walkthrough to learn more about reactivity (reactivity.effect, reactivity.event, reactivity.isolate, reactivity.invalidate_later, etc…) Video Resources: Video #1: https://youtu.be/I2W7i7QyJPI?si=nx1dk5ovPc91pvlB Starter Code (from end of video #1): https://github.com/KeithGalli/shiny-python-projects/tree/video1 Final App: https://keithgalli.shinyapps.io/final-app/ Shiny Resources: Shiny for Python Homepage: https://shiny.posit.co/py/ Component Gallery: https://shiny.posit.co/py/components/ Express Documentation: https://shiny.posit.co/py/api/express/ Gordon Shotwell’s “How does Shiny Render Things?”: https://youtu.be/jvV4y2xogf8?si=8uGP8ZfboUj1QM4p Joe Cheng’s “Shiny Programming Practices”: https://youtu.be/B2JzHv4FOTU?si=t4Atii-RSc5ojgom Stay tuned for part 3, where we'll explore how to make your dashboard look more professional (layouts in Shiny). Video by @KeithGalli --- Video Timeline! 0:00 - Intro & Overview 1:01 - Getting Started with Code 2:08 - Adding Shiny Components (Inputs, Outputs, & Display Messages) 3:21 - Creating an Additional Visualization (Sales Over Time by City) 7:55 - What are Reactive.Calcs and How Do We Use Them Properly? (DataFrame Best Practices) 10:27 - Creating an Additional Visualization (Sales Over Time by City) — Continued 14:30 - Filtering City Data with Select Inputs (UI.Input_Selectize) 21:15 - Rendering Shiny Inputs Within Text 22:15 - Quick Formatting Adjustments 22:54 - Understanding the Shiny Reactivity Model (How Does Shiny Render Things?) 24:23 - Adding a Checkbox Input to Change Out Bar Chart Marker Colors 28:00 - Deploying Our Updated App! 29:19 - Advanced Concepts in Shiny Reactivity (Reactive.Effect, Reactive.Event, Reactive.Isolate, Reactive.Invalidate_Later) & Other Resources All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

Joe Cheng

How-to: Dark Mode on Shiny for Python apps✨

How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny)

This is a quick-start guide to Shiny for Python. It's part 1 of a multi-part series. Data scientists need to quickly build web applications to create and share interactive visualizations, giving others a way to interact with data and analytics. Shiny helps you do this. In this video, we'll walk you through the basics of setting up Shiny for Python, creating your first app, and deploying it so others can use it. We'll cover: - Installing Shiny and necessary dependencies - Writing and running your first Shiny app - Basic UI and server structure - Deploying your app online - Helpful Links Shiny for Python Homepage: https://shiny.posit.co/py/ The link to the final app can be found here: https://keithgalli.shinyapps.io/final-app/ Follow along with the code examples provided in this repository: https://github.com/KeithGalli/shiny-python-projects Check out the complete documentation here: https://shiny.posit.co/py/api/express/ Stay tuned for part 2, where we'll dive deeper into advanced features and customization options. --- Video Timeline! 0:00 - Intro to Shiny & Video Overview 1:43 - Getting Started with the Shinylive Playground 2:44 - Building a custom visualization with Shinylive 5:18 - Easily sharing the code/application for a Shinylive app 6:12 - Building a Shiny Express App locally (VSCode) 9:40 - How to run app if you're not using VSCode 10:17 - Further customization of our app (adding title, using CSV data, dynamic input) 17:15 - Deploying our Shiny app to the web 21:20 - Conclusion & what's coming next in the series Video by @KeithGalli All videos in the series: Part 1 - How to Build, Deploy, & Share a Python Application in 20 minutes! (Using Shiny): https://www.youtube.com/watch?v=I2W7i7QyJPI&t=0s Part 2 - How to make Interactive Python Dashboards! (Reactivity in Shiny): https://www.youtube.com/watch?v=SLkA-Z8HTAE&t=0s Part 3 - How to make your Python Dashboard look Professional! (Layouts in Shiny): https://www.youtube.com/watch?v=jemk7DoN4qk&t=0s Part 4 - How to combine Matplotlib, Plotly, Seaborn, & more in a single Python Dashboard! (Shiny for Python): https://youtu.be/xDgO5hB4-VU?si=kk20yhdpsBqkMYcC Part 5 - How to Perfect Your Python Dashboard with Advanced Styling! (HTML/CSS - Shiny for Python): https://youtu.be/uYZUS-eFbqw

Shiny for Python vs Streamlit

Rizz + shiny for python = masterpiece

Introducing Shiny for Python Templates | Carson Sievert | Posit

Last month we introduced the Shiny for Python Components and Layouts galleries, which are a simple, visual overview of what Shiny can do, mixed with cheatsheet-like information. They are for new and seasoned users alike. We’re excited to announce a third section which brings those two things together into opinionated boilerplate code: Shiny Templates. This is just a start… We expect this gallery to grow as time goes on. These will allow you to hit the ground running, whether you need a quick simple app or a quick complicated one . Get started at https://shiny.posit.co/py/templates/ 0:00 Introduction to Shiny for Python Templates 0:38 How to work with a template locally in VS Code 2:24 Preview your app with the Shiny for Python VS Code Extension 2:45 A data_frame is a quick and easy way to see the contents of your data 4:39 See everything in your window with the “fillable=True” page_opts 5:16 Modifying inputs 7:40 Fix the logic in your @render.plot to show your modified inputs 9:00 Add a component to the sidebar 9:05 How to add input_dark_mode to your app 9:54 How to make your plot change to dark mode as well

Carson Sievert

Resources for Python Data Scientists | Shiny for Python is here✨

AI and Shiny for Python: Unlocking New Possibilities - posit::conf

Presented by Winston Chang In the past year, people have come to realize that AI can revolutionize the way we work. This talk focuses on using AI tools with Shiny for Python, demonstrating how AI can accelerate Shiny application development and enhance its capabilities. We'll also explore Shiny's unique ability to interface with AI models, offering possibilities beyond Python web frameworks like Streamlit and Dash. Learn how Shiny and AI together can empower you to do more, and do it faster. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: I can't believe it's not magic: new tools for data science. Session Code: TALK-1153

Winston Chang

Diversify Your Career with Shiny for Python - posit::conf(2023)

Presented by Gordon Shotwell A few years ago my company made a sudden shift from R to Python which was quite bad for my career because I didn't really know Python. The main issue was that I couldn't find a niche that allowed me to use my existing knowledge while learning the new language. Shiny for Python is a great niche for R users because none of the Python web frameworks can do what Shiny can do. Additionally, almost all of your knowledge of the R package is applicable to the Python one. This talk will provide an overview of the Python web application landscape and articulate what Shiny adds to this landscape, and then go through the five things that R users need to know before developing their first Shiny for Python application. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: Data science with Python. Session Code: TALK-1138

Making a (Python) Web App is easy! - posit::conf(2023)

Presented by Marcos Huerta Making Python Web apps using Dash, Streamlit, and Shiny for Python This talk describes how to make distribution-free prediction intervals for regression models via the tidymodels framework. By creating and deploying an interactive web application you can better share your data, code, and ideas easily with a broad audience. I plan to talk about several Python web application frameworks, and how you can use them to turn a class, function, or data set visualization into an interactive web page to share with the world. I plan to discuss building simple web applications with Plotly Dash, Streamlit, and Shiny for Python. Materials: - Comprehensive talk notes here: https://marcoshuerta.com/posts/positconf2023/ - https://www.tidymodels.org/learn/models/conformal-regression/ - https://probably.tidymodels.org/reference/index.html#regression-predictions Corrections: In my live remarks, I said a Dash callback can have only one output: that is not correct, a Dash callback can update multiple outputs. I was trying to say that a Dash output can only be updated by one callback, but even that is no longer true as of Dash 2.9. https://dash.plotly.com/duplicate-callback-outputs"" Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1086

Running R-Shiny without a Server - posit::conf(2023)

Presented by Joe Cheng A year ago, Posit announced ShinyLive, a deployment mode of Shiny that lets you run interactive applications written in Python, without actually running a Python server at runtime. Instead, ShinyLive turns Shiny for Python apps into pure client-side apps, running on a pure client-side Python installation. Now, that same capability has come to Shiny for R, thanks to the webR project. In this talk, I'll show you how you can get started with ShinyLive for R, and why this is more interesting than just cheaper app hosting. I'll talk about some of the different use cases we had in mind for ShinyLive, and help you decide if ShinyLive makes sense for your app. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: I can't believe it's not magic: new tools for data science. Session Code: TALK-1151

Joe Cheng

Shiny for Python Machine Learning Apps with pandas, scikit-learn and TensorFlow - posit::conf(2023)

Presented by Chelsea Parlett-Pelleriti With the introduction of Shiny for Python in 2022, users can now use the power of reactivity with their favorite Python packages. Shiny can be used to build interactive reports, dashboards, and web apps, that make sharing insights and results both simple and dynamic. This includes apps to display and explore popular Machine Learning models built with staple Python packages like pandas, scikit-learn, and TensorFlow. This talk will demonstrate how to build simple Shiny for Python apps that interface with these packages, and discuss some of the benefits of using Shiny for Python to build your web apps. Presented at Posit Conference, between Sept 19-20 2023, Learn more at posit.co/conference. -------------------------- Talk Track: The future is Shiny. Session Code: TALK-1087

Gordon Shotwell & Tracy Teal - Build Simple and Scalable Apps with Shiny | PyData NYC 2023

www.pydata.org https://gshotwell.github.io/shiny-algorithm This talk explores the intuitive algorithm behind Shiny for Python and shows how it allows you to scale your apps from prototype to product. Shiny infers a reactive computation graph from your application and uses this graph to efficiently re-render components. This eliminates the need for data caching, state management, or callback functions which lets you build scalable applications quickly. PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R. PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases. 00:00 Welcome! 00:10 Help us add time stamps or captions to this video! See the description for details. Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps

How to build a model annotation tool with FastAPI, Quarto & Shiny for Python

Gordon Shotwell, Senior Software Engineer at Posit walks through an end-to-end machine learning workflow with Posit Team. This demo will give you a robust pattern for hosting and sharing models on Connect before you deploy them to a customer-facing system. This includes * How and why to use an API layer to serve and authenticate internal models * Why you should wrap your APIs in Python packages * Using Shiny for Python to build a data annotation app * Using Quarto to retrain models on a schedule Agenda: 11am - Quick introduction 11:02am - Demo 11:40am Q&A Session (https://youtube.com/live/zhN8IZUBCAg?feature=share) Timestamps: 1:27 - Quick overview of text classification model used in this example 2:15 - Overview of the people that will need to use the model (modellers, leadership, data team, annotators, other systems) 4:11 - Why APIs before UIs is a good rule 5:57 - What about Python packages? 8:23 - Advantages to using an API here 9:18 - Big picture overview of the workflow 11:17 - FastAPI on Posit Connect (Swagger interface) 15:55 - The way this model will be used (authorization by validating user) 19:00 - Building a delightful user experience by wrapping API in a package 25:07 - Quarto report for leadership team showing model statistics & deploying to Connect 26:34 - Retraining the model by scheduling Quarto doc on Connect 28:37 - Shiny for Python app for Annotators (people checking if model is producing correct results & helping improve the model) 35:28 - Overview / summary of this machine learning workflow Helpful links: Github: https://github.com/gshotwell/connect-e2e-model Anonymous questions: pos.it/demo-questions If you want to book a call with our team to chat more about Posit products: pos.it/chat-with-us Don't want to meet yet, but curious who else on your team is using Posit? pos.it/connect-us Machine learning workflow with R: https://solutions.posit.co/gallery/bike_predict/ In this month’s Workflows with Posit Team session (Wednesday, November 29th at 11am ET) you will learn how to use Posit Connect as an end-to-end Python platform for hosting internal machine learning models. This will give you a robust pattern for hosting and sharing models on Connect before you deploy them to a customer-facing system. This will include: 1. How and why to use an API layer to serve and authenticate internal models 2. Why you should wrap your APIs in Python packages 3. Using Shiny for Python to build a data annotation app 4. Using Quarto to retrain models on a schedule During the event, we’ll be joined by Gordon Shotwell, Senior Software Engineer at Posit who will walk us through this end-to-end machine learning workflow with Posit Team. No registration is required to attend - simply add it to your calendar using this link: pos.it/team-demo Ps. We host these end-to-end workflow demos on the last Wednesday of every month. If you ever have ideas for topics or questions about them, leave a comment below :)

Shiny is available for Python and is super easy to customize the look and feel of your app😍

Learn more about Shiny for Python: https://shiny.posit.co/py/

How does Shiny render things? | Gordon Shotwell

Discussion on the Shiny Python Discord channel from Gordon Shotwell. Gordon talks about how Shiny renders things with reactive programming, how other frameworks work, and how Shiny scales for complex applications. 0:00 - How Shiny renders things - reactivity 2:31 - How do other frameworks work 3:51 - Event driven programming, what's a better way? 6:53 - Runtime tracing 8:25 - Declarative programming 9:20 - Drawing a graph 12:05 - How reactivity scales 13:30 - Reactive calculus 18:45 - Question and answer Shiny for Python: https://shiny.posit.co/py/ Shiny for Python Discord server: https://discord.com/invite/yMGCamUMnS

"Shiny: Data-centric web applications in Python" - Joe Cheng (PyBay 2023)

Joe Cheng https://pybay.com/speakers/#sz-speaker-7e5324de-3afa-4614-a498-562bd5eb9986 Shiny is a web framework that is designed to let you create data dashboards, interactive visualizations, and workflow apps in pure Python or R. Shiny doesn't require knowledge of HTML, CSS, and JavaScript, and lets you create data-centric applications in a fraction of the time and effort of traditional web stacks. Of course, Python already has several popular and high-quality options for creating data-centric web applications. So it's fair to ask what Shiny can offer the Python community. In this talk, I will introduce Shiny for Python and answer that question. I'll start with some basic demos that show how Shiny apps are constructed. Next, I'll explain Transparent Reactive Programming (TRP), which is the animating concept behind Shiny, and the reason it occupies such an interesting place on the ease-vs-power tradeoff frontier. Finally, I'll wrap up with additional demos that feature interesting functionality that is made trivial with TRP. This talk should be interesting to anyone who uses Python to analyze or visualize data, and does not require experience with Shiny or any other web frameworks. PyBay features the most influential speakers presenting the most crucial technologies to help beginners and seasoned developers alike get up-to-date quickly, in a single-track format. Whether you’re interested in web technologies, data, devops, Python internals, or performance, PyBay will help you stay on top of your game AND network with engineers at companies that are hiring! Working remotely and want to meet your teammates to boost team cohesiveness? Leverage the platform we’ve built. There are great talks, yummy food, fresh air, vitamin D... all the elements developers crave for these days. If there are talks that don’t interest your team, take the opportunity to talk to speakers, create your own team activities or book a tee-time at the adjacent miniature golf course! PyBay is the regional Python conference for the San Francisco Bay Area, bringing together Pythonistas from around the Bay Area and beyond. It is a volunteer-run organization dedicated to building a stronger Python community. PyBay offers deep-dive talks and networking opportunities that aim to enrich and empower the Python community. PyBay is part of BAPyA (Bay Area Python Association). BAPyA member organizations are the SF Python, Pyninsula, and BayPIGgies meetups. Produced by NDV: https://youtube.com/channel/UCQ7dFBzZGlBvtU2hCecsBBg?sub_confirmation=1 Sun Oct 8 18:30:00 2023 at Bungalo East

Joe Cheng

Joe Cheng - Shiny: Data-centric web applications in Python | PyData Seattle 2023

www.pydata.org Shiny is a web framework that is designed to let you create data dashboards, interactive visualizations, and workflow apps in pure Python or R. Shiny doesn't require knowledge of HTML, CSS, and JavaScript, and lets you create data-centric applications in a fraction of the time and effort of traditional web stacks. Of course, Python already has several popular and high-quality options for creating data-centric web applications. So it's fair to ask what Shiny can offer the Python community. In this talk, I will introduce Shiny for Python and answer that question. I'll start with some basic demos that show how Shiny apps are constructed. Next, I'll explain Transparent Reactive Programming (TRP), which is the animating concept behind Shiny, and the reason it occupies such an interesting place on the ease-vs-power tradeoff frontier. Finally, I'll wrap up with additional demos that feature interesting functionality that is made trivial with TRP. This talk should be interesting to anyone who uses Python to analyze or visualize data, and does not require experience with Shiny or any other web frameworks. PyData is an educational program of NumFOCUS, a 501(c)3 non-profit organization in the United States. PyData provides a forum for the international community of users and developers of data analysis tools to share ideas and learn from each other. The global PyData network promotes discussion of best practices, new approaches, and emerging technologies for data management, processing, analytics, and visualization. PyData communities approach data science using many languages, including (but not limited to) Python, Julia, and R. PyData conferences aim to be accessible and community-driven, with novice to advanced level presentations. PyData tutorials and talks bring attendees the latest project features along with cutting-edge use cases. 00:00 Welcome! 00:10 Help us add time stamps or captions to this video! See the description for details. Want to help add timestamps to our YouTube videos to help with discoverability? Find out more here: https://github.com/numfocus/YouTubeVideoTimestamps

Joe Cheng

Keynote, Winston Chang: Lessons and opportunities with Shiny for Python

About the keynote: For the past 10 years, the R community has been able to use Shiny to bring interactive data analyses to the web. Last summer, we announced that Shiny would also be available to for Python. In this talk, I’ll discuss what we’ve learned along the way, as well as the opportunities that Shiny for Python opens up. We are at the beginning of an exciting new era for Shiny, and I hope that community of old and new Shiny users make the most of it! Speaker's bio: Winston Chang is a software engineer at Posit, PBC, who has served in various roles on the Shiny team, including team lead. He has contributed to many widely-used packages in the R ecosystem, including Shiny, devtools, and ggplot2, and is the creator of several packages, including shinydashboard, R6, and profvis. Recently he has been busy working on Shiny and Shinylive for Python. Winston has a Ph.D. in psychology from Northwestern University and is the author of the R Graphics Cookbook, published by O’Reilly Media

Shiny Team, Winston Chang

Carson Sievert: Towards the next generation of Shiny UI

About the talk: Shiny, the R package for creating interactive web graphics, recently celebrated its 10th birthday. Since then, Shiny has grown tremendously in many areas (e.g., performance, functionality, extensions, etc); however, a "hello world" Shiny app still looks like it did 10 years ago. This is mostly because Shiny goes to great lengths to ensure backwards compatibility; and as a result, default Shiny UI will likely continue to be based on Bootstrap 3 (a CSS styling framework released in 2010). However, thanks to the new bslib R package, it is now easy to opt-into a modern Bootstrap 5 foundation that "just works" with Shiny, R Markdown, flexdashboard, pkgdown, bookdown, and more. In addition to upgrading Shiny's Bootstrap dependency, bslib also makes it much easier to do custom theming, leverage modern layout techniques, and create custom components (all from R without any CSS/HTML/JS required). At this point, bslib is still maturing, and does not yet provide what we'd consider a "complete UI toolkit", but it should eventually replace and/or improve upon all of Shiny UI. In this talk, I'll highlight bslib features that we're most excited about (e.g., expandable cards, accordions, (sidebar) layouts, input controls, etc.), discuss some best design practices for improving user experience with these tools, and present some real world examples of these tools in action. Speakers' bio: Carson is a software engineer on the Shiny team at Posit. He joined Posit in 2018, and in recent years, has focused primarily on Shiny for Python and improving Shiny UI. The Shiny UI work has manifested in the creation and development of many R packages such as bslib, thematic, htmltools, htmlwidgets, sass, shiny, rmarkdown, flexdashboard, and more. Carson also has a PhD in statistics, is a recipient of the ASA's Chambers Statistical Software Award, has maintained the R package plotly since 2015, authored the book "Interactive data visualization with R, plotly, and shiny", and ran a successful freelance consulting service for numerous years

Carson Sievert, Shiny Team

Why Shiny for Python? - Posit PBC

Learn how Shiny for Python's design philosophy sets it apart from Streamlit, Dash, and traditional web development frameworks. With Shiny for Python out of alpha as of April, many have wondered how it stacks up against other popular alternatives. In this video, Gordon Shotwell -- developer advocate on the Shiny team at Posit -- explores the design philosophy behind Shiny for Python and how it compares to other frameworks for developing data science web applications. If you are a data scientist working mostly in Python, we hope this motivates you to take a serious look at Shiny for Python. Learn more on Posit blog, https://posit.co/blog/why-shiny-for-python/ 00:00 What is Shiny for Python? 03:05 What is Reactivity? 04:19 How does Shiny compare to Streamlit? 05:14 What are the main differences between Streamlit and Shiny for Python? 07:05 Why should I prefer Shiny over Streamlit? 09:09 How does Shiny compare to Dash? 10:22 What is the difference between a stateless and a stateful application? 12:19 Why consider Shiny for Python over Dash? 13:37 Shiny for Python's Design Philosophy

Shiny Team

[79] Create a Python Web App Using Shiny (Gordon Shotwell)

Join our Meetup group for more events! https://www.meetup.com/data-umbrella ## Resources - website for presentation: https://shiny.rstudio.com/py/ - https://shiny.rstudio.com/py/docs/reactive-mutable.html - https://www.shinyapps.io/ - https://huggingface.co/new-space - https://shiny.rstudio.com/py/docs/shinylive.html - https://shiny.rstudio.com/py/api/reactive.poll.html#shiny.reactive.poll ## About the Event Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. If you want to develop a python web application you usually need to choose between simple, limited frameworks like Streamlit and more extensible frameworks like Dash. This can cause a lot of problems if you get started with a simple framework but then discover that you need to refactor your application to accommodate the next user request. Shiny for Python differs from other frameworks because it has tremendous range. You can build a small application in a few minutes with the confidence that the framework can handle much more complex problems. In this workshop we will go through the core limitations of Streamlit, and build a Shiny app which avoids those limitations. ## Timestamps 00:00 Welcome 00:23 Reshama introduces Data Umbrella 03:45 Reshama introduces Gordon Shotwell 04:21 Gordon Shotwell begins 04:29 The motivation to develop Shiny for Python 06:05 The main strength of both the R and Python library 06:56 What Gordon Shotwell will build during his presentation 07:25 Shiny documentation website 08:01 QuickStart for R users showing differences between the R and Python libraries 08:44 All the function reference in Shiny 09:08 Demo starts 09:50 Virtual environment 10:36 How to start shiny app in the terminal 11:15 Install shiny extension in VS Code which makes it easier to preview the web app 11:36 How the output function works on the preview app to execute 12:22 Penguin dataset description for the demo 12:45 Modules/submodules shiny app is built on 13:04 How to add a sidebar layout (sidebar, panel sidebar and panel main) 13:43 How to read in the data and the output functions 14:31 How to define some server logic 14:59 The conventional shiny rule 16:30 Use of slide input 17:50 Where the reactive magic comes in 19:30 Important note on what can really slow down your shiny app 20:14 Importance of Python data copy method when using external dataset 21:01 Important note to avoid dependency inside the render function 21:30 Q&A 29:35 Adding a plot to the output: The UI sides 30:12 Adding a plot to the output: The render sides 32:16 The core principle of reactivity in which you do not want to repeat yourself 33:26 Reactivate calculation concept which allows you to store intermediate values in one place 37:24 Q&A 38:53 Reactive calculations and rendering functions 39:30 Side-effects or user effect. Another class of interactions 41:18 How to tell reactive effect what it should respond to or what events to watch before executing 41:53 How to update the data filter in the side-effect function 42:22 The second important pattern for shiny 43:00 One of the important things to pay attention to once you start learning/using shiny 44:45 Series of Q&A until the end of the video. Some response includes live demo 01:01:03 Gordon Shotwell ends his presentation 01:01:17 Reshama closes the session ## About the Speaker Gordon Shotwell is a Software Engineer at Posit. He's been using Shiny to solve business problems for the past ten years. - LinkedIn: https://www.linkedin.com/in/gshotwell/ ## Key Links - Transcript: https://github.com/data-umbrella/event-transcripts/blob/main/2023/78-gordon-shiny.md - Meetup Event: https://www.meetup.com/data-umbrella/events/292848290/ - Video: https://youtu.be/pXidQWYY14w #python #deployment

Deploying a Shiny for Python application with Posit Connect

Last week’s blog post announced that Shiny for Python is now generally available and Python programmers can feel confident deploying Shiny for Python apps in production. This video will serve as a guide to deploying your applications so that users can interact with your apps and leverage their robust functionality using Posit Team. Follow along blog post: https://posit.co/blog/deploying-a-shiny-for-python-application-with-posit-connect/ 0:25 - Step 1: Load packages (in VS Code on Posit Workbench) Step 2: Create the app (example app here: https://shinylive.io/py/examples/#app-with-plot) 1:02 - Step 3: Run the app locally in VS Code 1:36 - Step 4: Deploy to Posit Connect Learn more We’d love to have you join us at one of our monthly Posit Team Demos where we walk through a different end-to-end data science workflow each month. They are on the last Wednesday of every month at 11 am ET on YouTube. You can add the event to your calendar here: pos.it/team-demo What is Posit Team? Posit Team is the bundle of our most popular products including Workbench (for development work), Connect (for hosting and sharing your data products), and Package Manager (for managing your R and Python packages). Together, this bundle delivers an end-to-end toolchain for data science teams committed to R and Python, improving every step of a data scientist’s workflow, from developing insights to deploying data products, to managing environments. If you have any questions and would like to talk with our team, you can schedule a time to chat: https://posit.co/schedule-a-call/

The Evolution of Shiny with Posit's CTO, Joe Cheng

Posit’s Joe Cheng talks about the evolution of Shiny and the future of Shiny for Python. Joe is one of the original architects of Shiny and leads Posit’s Open Source software development. Learn more about Shiny for Python at shiny.posit.co/py

Joe Cheng

Winston Chang | Running Shiny without a server | RStudio (2022)

Shiny for Python has the ability to be deployed without a server that runs Python. These applications can be served by any web hosting service. They are easily deployed and can scale to handle large amounts of traffic. This mode of deployment is called Shinylive. It works by running Python in the user’s web browser, using Pyodide, which is a version of Python that is compiled to WebAssembly. Shinylive opens up new possibilities for how Shiny applications can be used. In this talk I discuss the advantages and the limitations of Shinylive applications. Session: Some of my best friends use Python

Winston Chang

Getting Started with Shiny for Python - in the browser! || Winston Chang || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

Multiple Inputs in Shiny for Python || Winston Chang || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

Plot Outputs in Shiny for Python || Winston Chang || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. You can try out Shiny for Python without installing a single thing… All in the browser. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang)

Winston Chang

A Beginner's Guide to Shiny for Python || Winston Chang || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Winston Chang

An Interview with Winston Chang: Building a Wordle App with Shiny for Python || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Winston Chang (@winston_chang) + Jesse Mostipak (@kierisi) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Winston Chang

Data visualization and plotting with Shiny for Python || Carson Sievert || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Hello, World! A Quick Tour of Shiny for Python || Carson Sievert || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Hey Shiny Team, what are some of your biggest learnings from 2022? || Shiny Developers || RStudio

BIG THINGS happened on the Shiny team in 2022! Our team built out a new Shiny UI Editor, Shiny for Python, and Shiny for Python in the browser using WebAssembly. So we asked some of our Developers what their biggest learnings have been from building these products! Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Content: Winston Chang (@winston_chang), Carson Sievert (@cpsievert), Nick Strayer (), Michael Chow (@chowthedog) Producer: Jesse Mostipak (@kierisi) Video editing + motion design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert, Michael Chow, Nick Strayer, Shiny Team, Winston Chang

Shiny Programming Practices || Joe Cheng || Posit

Have you ever wanted to sit down and talk with Joe Cheng, the creator of Shiny and CTO of Posit (RStudio) and ask him how he approaches programming? Look no further - we've got that conversation for you right here! Shiny makes it easy to build interactive web apps straight from R or Python. You can host standalone apps on a webpage or embed them in Markdown-style documents or build dashboards. You can also extend your Shiny apps with CSS themes, htmlwidgets, and JavaScript actions. Learn more about Shiny: https://shiny.rstudio.com/ Check out Shiny for Python: https://shiny.rstudio.com/py/ Explore our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Joe Cheng (@jcheng) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Joe Cheng

Shinywidgets - An Overview || Carson Sievert || RStudio

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Shinywidgets lets you use ipywidgets in Shiny for Python applications. We called it ipyShiny during development, but we're launching as Shinywidgets! Learn more about how to integrate them into your Shiny for Python apps. . Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Carson Sievert (@cpsievert) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Carson Sievert

Wrangling data for a Shiny app in Python || Michael Chow || Posit

Shiny makes it easy to build interactive web applications with the power of Python’s data and scientific stack. Learn more about Shiny for Python: https://shiny.rstudio.com/py/ Check out our interactive Shiny for Python examples: https://shinylive.io/py/examples/ Content: Michael Chow (@chowthedog) Producer: Jesse Mostipak (@kierisi) Editing and Motion Design: Tony Pelleriti (@TonyPelleriti)

Michael Chow