Shiny + Projet

Avantages

Interface interactive / dashboard.
Assez facile à mettre en oeuvre.
Tout en R.

Inconvénients...

Debuggage parfois délicat car javascript-HTML.
Nécessite un serveur Shiny pour être déployé.

2 composants principaux (obligatoires)

UI : décrit l'interface. Mise en page, boutons, sliders, plots, ...
Inputs : actionButton, dateInput, actionLink, sliderInput, radioButtons, ...
Outputs : plotOutput, dataTableOutput, textOutput, ...
Server : décrit la logique applicative réactive.Met à jour les sorties quand les entrées changent.

Exemple - UI

library(shiny)
# Define UI for application that plots an histogram
shinyUI(fluidPage(
  # Application title
  titlePanel("Old Faithful Geyser Data"),
  # Sidebar with a slider input for number of bins
  sidebarLayout(
    sidebarPanel(
      sliderInput(inputID = "bins",
                  label = "Number of bins:",
                  min = 1,
                  max = 50,
                  value = 25)
    ),
    # Show a plot of the generated distribution
    mainPanel(
      plotOutput(outputId = "distPlot")
    )
  )
))

! inputId, outputId

Permet de référencer les entrées / sorties.
Fait le lien avec le code serveur.

Exemple - Serveur

# Faire le lien input <--> output
server <- function(input, output) {

  output$distPlot <- renderPlot({
    # Generate bins based on input$bins from ui.R
    x    <- faithful[,2]
    bins <- seq(min(x), max(x), length.out = input$bins+1)

    # Draw the histogram with the specified number of bins
    hist(x, breaks = bins, col = 'darkgray', border = 'white')
  })
}

Parties réactives : renderPlot, renderImage,renderTable, ...

→ Bloc ré-éxecuté quand une des entrées utilisée est modifiée.

MathJax

withMathJax(helpText("Some math here $$\\alpha+\\beta$$"))
# now we can just write "static" content without withMathJax()
div("more math here $$\\sqrt{2}$$")

Note : si on charge du contenu HTML plus tard via renderUI(), alors il faut entourer chaque expression LaTeX par "withMathJax(...)".

Grid system...

fluidPage(..., title = NULL, theme = NULL, lang = NULL)

A fluid page layout consists of rows which in turn include columns. Rows exist for the purpose of making sure their elements appear on the same line. Columns exist for the purpose of defining how much horizontal space within a 12-unit wide grid its elements should occupy.

Serveur, réactivité avancée

Structurer l'exécution pour éviter de dupliquer des traitements :

data = reactive({ ... })
data()

reactive : bloc réactif retournant une expression reactive
observe : bloc réactif ne retournant rien (effet de bord i/o)

data = reactive({ ... })
renderPlot(data())
observe({
  input$saveButton
  write.csv(data())
})

Note : observe() retourne un objet "observer" que l'on peut mettre en pause par exemple.

Isoler une partie du code :

observe({
  input$saveButton #take a dependency on input$saveButton
  # Isolate a whole block
  data <- isolate({
    a <- input$valueA #no dependency on input$valueA or input$valueB
    b <- input$valueB
    c(a=a, b=b)
  })
  writeToDatabase(data)
})

observeEvent / eventReactive

Exécuter un bloc de manière conditionelle au changement d'une ou plusieurs entrées.

shinyApp(
  ui = fluidPage(
    column(4,
      numericInput("x", "Value", 5),
      br(),
      actionButton("button", "Show")
    ),
    column(8, tableOutput("table"))
  ),
  server = function(input, output) {
    # Take an action every time button is pressed;
    # here, we just print a message to the console
    observeEvent(input$button, {
      cat("Showing", input$x, "rows\n")
    })
    # Take a reactive dependency on input$button, but
    # not on any of the stuff inside the function
    df <- eventReactive(input$button, {
      head(cars, input$x)
    })
    output$table <- renderTable({
      df()
    })
  }
)

insertUI / removeUI

Ajoute ou supprime des éléments du DOM (cf. cours précédent)

shinyApp(
  ui = basicPage(actionButton("go", "Go")),
  server = function(input, output, session) {
    observeEvent(input$go, {
      insertUI("#go", "afterEnd",
               actionButton("dynamic", "click to remove"))

      # Set up an observer that depends on the dynamic
      # input, so that it doesn't run when the input is
      # created, and only runs once after that (since
      # the side effect is remove the input from the DOM)
      observeEvent(input$dynamic, {
        removeUI("#dynamic")
      }, ignoreInit = TRUE, once = TRUE)
    })
  }
)

Reactive timers

ui <- fluidPage(
  sliderInput("n", "Number of observations", 2, 1000, 500),
  plotOutput("plot")
)
server <- function(input, output) {
  # Anything that calls autoInvalidate will automatically invalidate
  # every 2 seconds.
  autoInvalidate <- reactiveTimer(2000)
  observe({
    # Re-execute this reactive expression every time the timer fires.
    autoInvalidate()
    # Do something each time this is invalidated.
    # The isolate() makes this observer _not_ get invalidated and re-executed
    # when input$n changes.
    print(paste("The value of input$n is", isolate(input$n)))
  })
  # Generate a new histogram each time the timer fires, but not when
  # input$n changes.
  output$plot <- renderPlot({
    autoInvalidate()
    hist(rnorm(isolate(input$n)))
  })
}

Websockets : le retour

Un reactiveTimer est pratique pour par exemple demander une mise à jour au serveur toutes les $n$ minutes/secondes.

Mais, plus efficace de laisser un serveur notifier le client :

...Voir plus loin :)

Vue d'ensemble

Création d'un dossier spécial avec "git init"
Envoi d'une copie de ce dossier sur un serveur.
...
Des collaborateurs récupèrent le code : "git clone".
Modifications apportées au dossier : sauvegardées via "git push".
Les collaborateurs récupèrent les modifications : "git pull".
...

Point important : tout le monde dispose de l'ensemble des fichiers et de l'historique $\Rightarrow$ pas de perte de données en cas de plantage du serveur.

Publier des modifications

# Modifier des fichiers, en ajouter, supprimer, etc

# Ajout dans l’index :
git add -A #ajoute tout à l'index

# Ajout dans le repo local :
git commit #affiche un éditeur de texte
# Alternative:
git commit -m "Message décrivant les modifications"

# Envoi sur le repo principal (souvent GitHub)
git push [origin main]

Mettre à jour votre copie de travail

git pull [origin main]

# Résoudre les conflits éventuels, etc...

Suite

Suivre ce tutoriel et faire les exercices.

Concernant la gestion des conflits, vous pouvez par exemple développer à deux sur un même repo.

Shiny : visualisation / exploration interactive

2 composants principaux (obligatoires)

Exemple - UI

Exemple - Serveur

MathJax

Grid system...

En résumé :

Serveur, réactivité avancée

Reactive timers

Websockets : le retour

Déploiement

Projets

Digression : architecture d'une application shiny

App Shiny = interface à une API Plumber

TODO ?

Exercice

Contrôle de Version: Git

Plan

Motivations

Alternatives

Vue d'ensemble

Vue plus précise

GitHub : premiers pas

GitHub : créer un dépôt

Publier des modifications

Mettre à jour votre copie de travail

Suite

Clients

Gestion des fichiers binaires

Ce dont j'envisageais de parler (mais finalement non)

Créer un package R

Exercice