Shiny

https://shiny.posit.co/
Admin
Shiny is a framework for building interactive web applications with R or Python, enabling data...
Tokens:308,539
Snippets:3,141
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Bookmark Example Setup

Source: https://shiny.posit.co/py/api/core/bookmark.Bookmark.html

Initial imports for setting up bookmarking functionality in a Shiny application.

```python
from starlette.requests import Request
  

from shiny import App, Inputs, Outputs, Session, reactive, render, ui
from shiny.bookmark import BookmarkState
```

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

### Install and Run Redis

Source: https://shiny.posit.co/r/articles/improve/caching

Commands to install Redis via Homebrew and start the Redis server.

```shell
# Install redis via Homebrew
brew install redis

redis-server /usr/local/etc/redis.conf
```

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

### Data Frame UI and Server Setup

Source: https://shiny.posit.co/py/api/core/render.data_frame.html

Example of setting up a Shiny application with multiple reactive data frames.

```python
from shared import mtcars
  

from shiny import App, reactive, render, ui
  

app_ui = ui.page_fillable(
ui.layout_columns(
ui.card(
ui.card_header(ui.markdown("""
##### Editable data frame
* Edit the cells!
* Sort the columns!
"""))),
ui.output_data_frame("df_original"),
),
ui.card(
ui.card_header(ui.markdown("""
##### Updated data from the first data frame
* Select the rows!
* Filter and sort the columns!
"""))),
ui.output_data_frame("df_edited"),
),
ui.card(
ui.card_header(ui.markdown("""
##### Selected data from the second data frame
* Sort the columns!
"""))),
ui.output_data_frame("df_selected"),
),
col_widths=[4, 4, 4],
),
)
  

  

def server(input, output, session):
df = reactive.value(mtcars.iloc[:, range(4)])
```

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

### Install C3 gauges from GitHub

Source: https://shiny.posit.co/r/articles/build/js-build-widget

This command installs a more complete version of C3 gauges from GitHub, useful for running the example app without manual steps.

```r
devtools::install_github("FrissAnalytics/shinyJsTutorials/widgets/C3")
```

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

### Run the HTML UI example

Source: https://shiny.posit.co/r/articles/build/html-ui

To run the example type:

```r
library(shiny)
runExample("08_html")
```

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

### Installation

Source: https://shiny.posit.co/r/articles/build/pool-basics

Instructions for installing the shiny, DBI, and pool packages.

```r
install.packages("shiny")
install.packages("DBI")

# get pool from GitHub, since it's not yet on CRAN
devtools::install_github("rstudio/pool")
```

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

### Example Shiny app setup with color palette

Source: https://shiny.posit.co/r/articles/build/communicating-with-js

Initializes a Shiny app by creating a palette of 40 rainbow colors.

```r
library(shiny)

# Make a palette of 40 colors
colors <- rainbow(40, alpha = NULL)
```

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

### Install development versions

Source: https://shiny.posit.co/py/get-started/install.html

Direct installation of Shiny and htmltools from their respective GitHub repositories.

```bash
pip install https://github.com/posit-dev/py-htmltools/tarball/main
pip install https://github.com/posit-dev/py-shiny/tarball/main
```

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

### Full bookmarking application example

Source: https://shiny.posit.co/py/api/core/bookmark.Bookmark.html

A complete example demonstrating UI restoration and bookmarking event handling.

```python
from starlette.requests import Request
  

from shiny import App, Inputs, Outputs, Session, reactive, render, ui
from shiny.bookmark import BookmarkState
  

  
# App UI **must** be a function to ensure that each user restores their own UI values.
def app_ui(request: Request):
return ui.page_fluid(
ui.markdown(
"Directions: "
"\n1. Change the radio buttons below"
"\n2. Refresh your browser."
"\n3. The radio buttons should be restored to their previous state."
"\n4. Check the console messages for bookmarking events."
),
ui.hr(),
ui.input_radio_buttons(
"letter",
"Choose a letter (Store in Bookmark 'input')",
choices=["A", "B", "C"],
),
ui.input_radio_buttons(
"letter_values",
"Choose a letter (Stored in Bookmark 'values' as lowercase)",
choices=["A", "B", "C"],
),
"Selection:",
ui.output_code("letters"),
)
  

  
def server(input: Inputs, output: Outputs, session: Session):
```

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

### Install OpenTelemetry SDK manually

Source: https://shiny.posit.co/py/docs/opentelemetry.html

Alternative installation method for explicit SDK configuration without the wrapper.

```bash
# Option 1: Install with Shiny's optional dependencies
uv add "shiny[otel]"

# Option 2: Install the SDK manually
uv add opentelemetry-sdk opentelemetry-exporter-otlp
```

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

### Run the 01_hello example app

Source: https://shiny.posit.co/r/articles/build/html-tags

This code snippet shows how to run the example '01_hello' app.

```R
library(shiny)
runExample("01_hello")
```

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

### Run Tabsets Example

Source: https://shiny.posit.co/r/articles/build/tabsets

Command to run the Tabsets example application.

```r
library(shiny)
runExample("06_tabsets")
```

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

### Install testing dependencies

Source: https://shiny.posit.co/py/docs/end-to-end-testing.html

Command to install the necessary packages for running tests.

```bash
pip install pytest pytest-playwright
```

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

### Install the shinylive package

Source: https://shiny.posit.co/py/get-started/shinylive.html

Installs the necessary CLI tools for exporting Shiny applications.

```bash
pip install shinylive
```

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

### Complete HTML Example for Gauge Widget

Source: https://shiny.posit.co/r/articles/build/js-build-widget

A full HTML file demonstrating the setup of a C3.js gauge widget, including CSS and JavaScript.

```html
<html>
<head>
    <!-- required css style file for C3.js -->
    <link href="c3.min.css" rel="stylesheet" type="text/css">
</head>
<body>

<!-- container element in which we will create the chart -->
<div id="chart1"></div>

<!-- required javascript libraries-->
<script src="d3.v3.min.js" charset="utf-8"></script>
<script src="c3.min.js"></script>

<!-- javascript block to render and update the chart-->
<script>

    var gaugeData = {'data': 80.0}

    // create a chart and set options
    // note that we bind the chart to the element with id equal to chart1 via the c3.js API
    var chart = c3.generate ({
        bindto: '#chart1',
        data: {
            json: gaugeData,
            type: 'gauge',
        },
        gauge: {
            label:{
                //returning the value here and not the ratio
                format: function(value, ratio){ return value;}
            },
            min: 0,
            max: 100,
            width: 15,
            units: 'value' //this is only the text for the label
        }
    });

    // this function will update every 2000 milliseconds
    // and create a new value between 0 and 100
    setInterval(function () {

        // create a random value between 0 and 100, rounded to 2 digits
        var newValue = Math.floor(100 * Math.random());

        // create a data array holding the random value
        var newData = {'data', newValue };

        // tell the chart to load the new data
        chart.load ({
          json: newData
        });
    }, 2000);


</script>
</body>
</html>
```

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

### Install rsconnect-python

Source: https://shiny.posit.co/py/get-started/deploy-cloud.html

Install the required package to manage deployments to shinyapps.io.

```bash
pip install rsconnect-python
```

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

### Run the upload example

Source: https://shiny.posit.co/r/articles/build/upload

Instructions on how to run the file upload example provided by Shiny.

```R
> library(shiny)
> runExample("09_upload")
```

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

### Install miniUI

Source: https://shiny.posit.co/r/articles/build/gadget-ui

Installs the miniUI package from GitHub using the devtools package.

```r
devtools::install_github("rstudio/miniUI")
```

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

### Install Shiny via uv

Source: https://shiny.posit.co/py/get-started/install.html

Installation of the Shiny package using the uv package manager.

```bash
uv pip install shiny
```

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

### Install Shiny with theme support

Source: https://shiny.posit.co/blog/posts/shiny-python-1.2-brand-yml/index.html

Install the required shiny package with the theme extra to enable brand.yml functionality.

```bash
pip install "shiny[theme]"
```

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

### Install Agent Skill on Windows

Source: https://shiny.posit.co/py/get-started/agent-skills.html

Installs the bundled Shiny skill using the --copy flag, which is required on Windows.

```bash
uvx library-skills --copy
```

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

### Set up a virtual environment with uv

Source: https://shiny.posit.co/py/get-started/install.html

Commands to create a project directory, initialize a virtual environment with uv, and install Shiny.

```bash
# Create and move into your shiny application directory
mkdir myapp
cd myapp

# Create a virtual environment, defaults to .venv
uv venv

# Activate the virtual environment
source .venv/bin/activate
# .venv\Scripts\Activate.ps1 # on Windows (PowerShell)

# Your prompt will prepend with the current directory name

# Install into venv
uv pip install shiny
```

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

### Full Application Example (app.R)

Source: https://shiny.posit.co/r/articles/improve/usage-metrics

This is a complete Shiny application example that includes setup for both Google Analytics and Matomo tracking, demonstrating how to include external Javascript files.

```r
library(shiny)

ui <- fluidPage(

  # -- Add Tracking JS File
  tags$head(
    tags$script(
      async = NA,
      # !! Replace with your TAG_ID !!
      src = "https://www.googletagmanager.com/gtag/js?id=TAG_ID"
    )
  )
  tags$head(includeScript("google-analytics.js")),

  # ...or remove the above and use matomo.js instead
  # tags$head(includeScript("matomo.js")),

  # -- Application UI
  sidebarLayout(
    sidebarPanel(
      sliderInput("bins", "Number of bins:",
                  min = 1, max = 50, value = 30),
      selectInput("col", "Barplot Color",
                  c("blue", "grey", "purple", "orange"), selected = "grey")
    ),

    mainPanel(
      h1(textOutput("user")),
      plotOutput("distPlot")
    )
  )
)

server <- function(input, output, session) {

  output$user <- renderText({
    paste0("Hello ", session$user,
      "! This app is tracked by Matomo")
  })

  output$distPlot <- renderPlot({
    x <- faithful[, 2]
    bins <- seq(min(x), max(x), length.out = input$bins + 1)
    hist(x, breaks = bins, col = input$col, border = 'white')

  })

}

shinyApp(ui = ui, server = server)
```

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

### Set up a virtual environment with venv

Source: https://shiny.posit.co/py/get-started/install.html

Commands to create a project directory, initialize a virtual environment, and install Shiny.

```bash
# Create and move into your shiny application directory
mkdir myapp
cd myapp

# Create a virtual environment in the .venv subdirectory
python3 -m venv .venv

# Activate the virtual environment
source .venv/bin/activate

# Your prompt will change to have the .venv prefix

# Now install Shiny in your environment
pip install shiny
```

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

### Distributing styles with HTMLDependency

Source: https://shiny.posit.co/py/docs/ui-customize.html

An example of creating a function that returns an HTMLDependency object for distributing custom styles and scripts, making them accessible after installing a Python package.

```python
from htmltools import HTMLDependency

def acme_theme():
    return HTMLDependency(
        name="acme_theme",
        version="0.01",
        source={"package": "acme_theme", "subdir": "acme-theme"},
        stylesheet=[{"href": "acme-theme.css"}],
        script=[{"src": "acme-theme.js"}],
        # If you want other files in the acme-theme dir to be served
        all_files=True
    )
```

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

### Tracking Slider Value History

Source: https://shiny.posit.co/py/docs/reactive-foundations.html

This example demonstrates how to use `reactive.value` to track the history of a slider's values. An `@reactive.effect` appends the new slider value to the `vals` reactive value whenever it changes. `@reactive.event` is used to prevent infinite loops when both getting and setting `vals` within the effect.

```python
from shiny import reactive
from shiny.express import input, render, ui
  

ui.input_slider("x", "Slider value", min=0, max=100, value=10)
  

vals = reactive.value([])
  
# Track the history of the slider
@reactive.effect
@reactive.event(input.x)
def _():
vals.set([input.x()] + vals())
  
@render.ui
def out():
return [ui.p(x) for x in vals()]
  
  
  
  

```

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

### IntroJS Initialization and Start Methods

Source: https://shiny.posit.co/r/articles/build/js-introjs

This code snippet shows the core introJS methods for initializing the library, setting options with the steps array, and starting the tour.

```javascript
// initialize an introjs instance
var intro = introJs();

// pass in the Steps array created earlier
intro.setOptions({steps: Steps });

// start intro.js
intro.start();
```

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

### Launch example app

Source: https://shiny.posit.co/r/articles/build/display-modes

Shiny’s built in example apps will automatically open in showcase mode when you call `runExample`.

```R
> runExample("01_hello")
```

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

### Create Dinner Recipe Template

Source: https://shiny.posit.co/py/docs/genai-inspiration.html

Command to initialize the Dinner Recipe application template.

```bash
shiny create --template dinner-recipe \
    --github posit-dev/py-shiny-templates/gen-ai
```

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

### Install Shiny via conda

Source: https://shiny.posit.co/py/get-started/install.html

Installation of the Shiny package using the conda-forge channel.

```bash
conda install -c conda-forge shiny
```

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

### Create Workout Plan Template

Source: https://shiny.posit.co/py/docs/genai-inspiration.html

Command to initialize the Workout Plan application template.

```bash
shiny create --template workout-plan \
    --github posit-dev/py-shiny-templates/gen-ai
```

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

### Initialize ui.Theme

Source: https://shiny.posit.co/py/api/core/ui.Theme.html

Basic constructor signature for the Theme class.

```python
ui.Theme(preset=None, name=None, include_paths=None)
```

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

### Install Shiny package

Source: https://shiny.posit.co/py

Use pip to install the Shiny framework in your Python environment.

```bash
pip install shiny
```

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

### Tag Example

Source: https://shiny.posit.co/py/api/core/TagTypes.html

Example of creating and displaying a div tag.

```python
>>> from htmltools import div
>>> x = div("hello", id="foo", class_="bar")
>>> x
<div id="foo" class="bar">hello</div>
>>> x.show()
```

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

### Create Image Describer Template

Source: https://shiny.posit.co/py/docs/genai-inspiration.html

Command to initialize the Image Describer application template.

```bash
shiny create --github jonkeane/shinyImages
```

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

### Install and Load ellmer in R

Source: https://shiny.posit.co/blog/posts/shiny-side-of-llms-part-2

Install the ellmer package from CRAN and load it into your R session.

```r
install.packages("ellmer")
```

```r
library(ellmer)
```

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

### Install the rsconnect package

Source: https://shiny.posit.co/r/articles/share/shinyapps

Install the package required for deploying applications to the shinyapps.io service from CRAN.

```R
install.packages('rsconnect')__
```

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

### Create a basic reactable table in Shiny

Source: https://shiny.posit.co/r/components/outputs/table-reactable

A complete example demonstrating the UI and server implementation for rendering a reactable table.

```R
#| standalone: true
#| components: [viewer]
#| viewerHeight: 200

library(shiny)
library(bslib)
library(reactable)
library(palmerpenguins)

ui <- page_fluid(
  reactableOutput("table") 
)

server <- function(input, output) {
  output$table <- renderReactable({reactable(penguins)}) 
}

shinyApp(ui = ui, server = server)
```

```R
library(shiny)
library(bslib)
library(reactable)
library(palmerpenguins)

ui <- page_fluid(
  reactableOutput("table") 
)

server <- function(input, output) {
  output$table <- renderReactable({reactable(penguins)}) 
}

shinyApp(ui = ui, server = server)
```

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

### server.R with shinyServer()

Source: https://shiny.posit.co/r/articles/build/app-formats

Example server.R file using shinyServer() for older Shiny versions.

```r
## server.R ##
shinyServer(function(input, output) {
  output$distPlot <- renderPlot({
    hist(rnorm(input$obs), col = 'darkgray', border = 'white')
  })
})
```

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

### Basic Switch Example

Source: https://shiny.posit.co/r/components/inputs/switch

A basic example of how to use the input_switch component in a Shiny app.

```r
library(shiny)
library(bslib)

ui <- page_fluid(
  input_switch("switch", "Switch"), 
  verbatimTextOutput("value")
)

server <- function(input, output) {
  output$value <- renderText({input$switch})
}

shinyApp(ui = ui, server = server)
```

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

### Run the Sliders Example

Source: https://shiny.posit.co/r/articles/build/sliders

Command to run the Sliders example locally.

```r
library(shiny)
runExample("05_sliders")
```

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

### Basic example with an input field

Source: https://shiny.posit.co/py/docs/genai-stream.html

This example shows how to create a startup message with an input field using MarkdownStream().

```python
from shiny.express import ui

with ui.hold() as welcome:
    "**Hello!** What's your name?"
    ui.input_text("name", None, placeholder="Enter name here")

chat = ui.Chat(id="chat")
chat.ui(messages=[welcome])
```

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

### Initialize and execute structured chat workflow

Source: https://shiny.posit.co/blog/posts/shiny-side-of-llms-part-2

Demonstrates initializing a ChatAnthropic session, registering a tool, and performing multi-task analysis using structured data models.

```python
# Initialise chat with Claude Sonnet 4 model
chat = ChatAnthropic(
    model="claude-sonnet-4-20250514",
    system_prompt="Your system prompt",
)

# Register the tool with the chat
chat.register_tool(calculate_slide_metric)

# Start conversation with the chat
# Task 1: regular chat to extract meta-data
chat.chat(
    interpolate(
        "Execute Task 1 (counts). Here are the slides in Markdown: ..."
    )
)

# Task 2: structured chat to further analyse the slides
chat.chat_structured(
    "Execute Task 2 (suggestions)",
    data_model=DeckAnalysis,
)
```

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

### Action button example

Source: https://shiny.posit.co/py/get-started/what-is-shiny.html

An example of an action button, which is a regular HTML <button> element.

```python
from shiny import ui
ui.input_action_button("update_data", "Button")
```

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

### Initialize Bookmark

Source: https://shiny.posit.co/py/api/core/bookmark.Bookmark.html

Basic instantiation of the Bookmark class.

```python
bookmark.Bookmark()
```

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

### Utility Classes Example

Source: https://shiny.posit.co/py/docs/ui-customize.html

Example of using Bootstrap utility classes for styling.

```python
from shiny.express import ui

with ui.card():
    ui.card_header("Card header", class_="bg-primary-subtle lead")
    "Card body"
```

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

### Initialize Chatbot Templates

Source: https://shiny.posit.co/py/docs/genai-chatbots.html

Terminal commands to scaffold a new Shiny chatbot project using various LLM providers.

```bash
shiny create --template chat-ai-ollama
```

```bash
shiny create --template chat-ai-anthropic
```

```bash
shiny create --template chat-ai-openai
```

```bash
shiny create --template chat-ai-gemini
```

```bash
shiny create --template chat-ai-anthropic-aws
```

```bash
shiny create --template chat-ai-azure-openai
```

```bash
shiny create --template chat-ai-langchain
```

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

### Install and Import chatlas in Python

Source: https://shiny.posit.co/blog/posts/shiny-side-of-llms-part-2

Install the chatlas package via pip or uv and import it into your script.

```bash
pip install chatlas
```

```bash
uv add chatlas
```

```python
import chatlas
```

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

### Example App with File Downloads

Source: https://shiny.posit.co/r/articles/build/download

This code snippet shows how to run an example Shiny app that demonstrates file downloads.

```R
library(shiny)
runExample("10_download")
```

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

### Define dependencies with requirements.txt

Source: https://shiny.posit.co/py/get-started/shinylive.html

Specify additional application dependencies by creating a requirements.txt file.

```text
isodate
attrs==21.4.0
```

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

### Install Shiny with OpenTelemetry support

Source: https://shiny.posit.co/py/docs/opentelemetry.html

Install the necessary dependencies to enable OpenTelemetry instrumentation in your Shiny project.

```bash
uv add "shiny[otel]"
```

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

### Install Shiny application dependencies

Source: https://shiny.posit.co/r/articles/share/shinyapps

Install the required ggplot2 and shiny packages locally before deploying the application.

```R
install.packages(c('ggplot2', 'shiny'))__
```

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

### R code to invoke the help system from the server

Source: https://shiny.posit.co/r/articles/build/js-introjs

This R code snippet shows how to use `observeEvent` and `session$sendCustomMessage` to trigger the JavaScript `startHelp` handler and initiate the intro.js tour.

```r
# listen to the action button
observeEvent(input$startHelp,{

  # on click, send custom message to start help
  session$sendCustomMessage(type = 'startHelp', message = list(""))
})
```

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

### Install Shiny Testing Dependencies

Source: https://shiny.posit.co/py/docs/end-to-end-testing.html

Ensure the required testing extras are installed in your environment before generating tests.

```bash
pip install "shiny[add-test]"
```

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

### ui.R with shinyUI()

Source: https://shiny.posit.co/r/articles/build/app-formats

Example ui.R file using shinyUI() for older Shiny versions.

```r
## ui.R ##
shinyUI(fluidPage(
  sidebarLayout(
    sidebarPanel(
      sliderInput("obs", "Number of observations:", min = 10, max = 500, value = 100)
    ),
    mainPanel(plotOutput("distPlot"))
  )
))
```

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

### server.R example

Source: https://shiny.posit.co/r/articles/build/two-file

Example code for the server.R file, defining the server logic.

```r
server <- function(input, output) {
  output$distPlot <- renderPlot({
    hist(rnorm(input$obs), col = 'darkgray', border = 'white')
  })
}
```

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

### server.R

Source: https://shiny.posit.co/r/articles/build/app-formats

Example server.R file for a Shiny application.

```r
## server.R ##
function(input, output) {
  output$distPlot <- renderPlot({
    hist(rnorm(input$obs), col = 'darkgray', border = 'white')
  })
}
```
Tokens:
Raw