TP4 : Partager son application R Shiny

BUT 3 - Domaines d’application

Auteur

Jean-Francois Rey

Objectif du TP

Nous allons apprendre à embarquer une application R {Shiny} dans un package R.

Pourquoi ?

Pour faciliter le partage de votre application.

Prérequis

  • TP1
  • TP2
  • TP3
  • Disposer d’un projet package R
  • Savoir développer une application R {Shiny}

Rappel

Ce qu’on a vu

Nous avons vu comment créer un package R de base normé et valide avec l’automatisation de la documentation et des tests.

Ce que vous avait déjà vu

Vous avez du voir comment créer une application R {Shiny}.
Un application R {Shiny} se compose de deux fonctions ui et server qui sont appelées par shinyApp(ui, server,…).

Important

Un membre du binôme doit faire le TP sur sa session (différent du TP précédent). Au prochain TP vous changerez de membre.
Pensez à sauvegarder et à versionner votre travail aux étapes importantes.
Pensez bien a faire un pull avant de commencer à travailler.
Vous travaillez dans le répertoire versionné <monpackage>.

L’issue du TP

  • Créer une issue dans votre projet GitLab avec pour nom TP4.
  • Y ajouter ceci :
# TP4 : Partager son application R Shiny

## Tâches :   

1. [ ] Inclure une app R Shiny
2. [ ] Installer et instancier l'app
3. [ ] Tester et valider le package  
etc.

## Version

Le commit correspondant au rendu final du TP : <clé SHA>
  • Dans l’issue principal du projet Rendu de notre projet associer cette dernière issue dans Linked Items
    • utiliser le numéro de l’issue ou son nom

Les 2 options

Deux posibilités

Il est possible d’inclure une application R {Shiny} dans un package de deux manières différentes.
L’option 1 est à titre d’information, préférer l’option 2 pour le TP.

Option 1

  • La première option consiste à englober dans une fonction ui(), server() et shinyApp() dans un fichier app.R dans le dossier R/ avec le reste de votre code.
R/app.R
library(shiny)

monApp <- function(...) {
  ui <- fluidPage(
    ...
  )
  server <- function(input, output, session) {
    ...
  }
  shinyApp(ui, server, ...)
}
  • Par la suite vous devez modifier les fichiers DESCRIPTION et NAMESPACE pour prendre en compte cette application et les dépendances.

  • Pour utiliser votre application il suffira alors de faire ceci :

monpackage::monApp()
A savoir

Cette manière de faire est très simple et le package ce comporte comme un package classique.
Néanmoins il peut avoir quelques désavantages. Comme par exemple, si l’application devient très grosse elle sera dur à maintenir dans un unique fichier (même en utilisant les modules) ou encore cela peut compliquer l’installation du package si l’application est en complément des outils déjà présents dans votre package (où mettre les images ? les ressources statiques ?).

Astuce

Vous pouvez retrouver des informations sur mastering-shiny pour approfondir cette piste.

Il est possible de construire un package R dédicacé à une application R Shiny qui soit maintenable. Pour en savoir plus aller sur engineering-shiny.org qui vous présente une manière de faire cela avec le package {golem}.

Option 2

  • La seconde option consiste à mettre l’intégralité du code et des ressources de votre application dans le dossier inst/shinyapps/. Un simple appel au dossier depuis une fonction permettra de l’instancier.

Le dossier inst d’un package contient des ressources qui sont simplement installées sans être vérifié et/ou qui répondent à une nomenclature.

Voici a quoi ressemble l’arboressence finale (pour information) :

- monpackage
  |- inst
     |- shinyapps
        |- monapp
           |- ui.R
           |- server.R
           |- www
           |- ...
  |- R
     |- runMonApp.R
     |- ...
  |- DESCRIPTION
  |- ...
  • Depuis votre projet de package R
  • Créer les dossiers inst/shinyapps/<monapp>
  • Inclure dans ce dernier ( <monapp> ) une application R Shiny

Voici 3 fichiers simples pour disposer d’une app de test.

global.R
library(<monpackage>)
library(shiny)
ui.R
ui <- fluidPage(
  textOutput("message")
)
server.R
server <- function(input, output, session) {

    output$message <- shiny::renderText({
        caption <- capture.output(res <- <monpackage>::ma_fonction("les BUTs"))
        print(caption)
    })
}
  • Créer un fichier R/runMonApp.R
runMonApp.R
#' runMonApp
#' @description Mon application R Shiny demo
#' @details Mon application a besoin du package shiny pour fonctionner.
#' install.packages(c("shiny"))
#' @export
runMonApp <- function() {
  appDir <- system.file("shinyapps", "<monapp>", package = "<monpackage>")
  if (appDir == "") {
    stop("Could not find shinyapps directory. Try re-installing `<monpackage>`.", call. = FALSE)
  }
  shiny::runApp(appDir, display.mode = "normal")
}
  • Check, Test et installer le package
  • Dans la console R
<monpackage>::runMonApp()
ajouter les dépendances

Pour permettre à l’utilisateur d’installer les packages R dont dépend votre application, il est conseillé de les ajouter dans le fichier DESCRIPTION dans l’attribut Suggests.

Suggests:
  shiny

De plus, ajouter dans le README.md comment installer les dépendances et comment utiliser votre application est la bienvenue.

Vous pouvez ajouter dans la fonction d’appel de l’application un test pour savoir si les dépendances sont satisfaites.

runMonApp.R
## Dans la fonction runMonApp()
  needed_packages <- c("shiny", "shinyalert", "DT", "shinyjs", "future", "promises")
  if( sum(needed_packages %in% utils::installed.packages()[,1] == FALSE) != 0) {
    stop('Install packages : install.packages(c("shiny", "shinyalert", "DT", "shinyjs", "future", "promises"))')
  } 

Maintenant vous disposez d’un package R de base normé et valide. Il est testé, packagé et documenté automatiquement, il contient une application R {Shiny} et toutes les informations utiles à l’utilisateur sont accessibles via une page web.


Avant d’aller plus loin

  • Vérifier que vous avez suivie les consignes.
  • Vérifier que la documentation du package est à jour.
  • Vérifier que les Tests sont implémentés.
  • Vérifier que les dépendances à l’application R {shiny} sont installées et/ou que l’utilisateur est informé de ces dernières.
  • Vérifier que l’application R {shiny} fonctionne.
  • Vérifier que votre package est toujours normé et valide (Check, Test, Source, Install).
  • Vérifier que le dépôt GitLab de votre package est à jour.
  • Vérifier que le CI/CD fonctionne et est vert.
  • Vérifier que le siteweb est accessible.

Questions:

  • Dans l’issue de ce TP (“TP4”).
  • Ajouter le message et la version du commit correspondant à ce TP
    (menu de gauche -> Code -> Commits) le commit correspond à la clé SHA.
  • Ajouter le Tags TP4 au commit
  • Répondez aux questions suivantes dans la description de l’issue :
    • Quels sont les avantages d’embarquer une application R {Shiny} dans un package R ?
    • Est-il nécessaire d’installer le package pour utiliser l’application Shiny ?
    • Que se passerait-il si tous les fichiers de l’application se trouvés dans le dossier R/ ?
    • Quel est la différence entre runApp() et shinyApp() ?

Pour aller plus loin