Une manière élégante de vérifier les paquets manquants et de les installer?

Il semble que je partage beaucoup de code avec les co-auteurs ces jours-ci. Beaucoup d'entre eux sont des utilisateurs R novices / intermédiaires et ne réalisent pas qu'ils doivent installer des packages qu'ils n'ont pas déjà.

Existe-t-il un moyen élégant d'appeler installed.packages(), de comparer cela à ceux que je charge et d'installer s'il manque?

Oui. Si vous avez votre liste de packages, comparez-la à la sortie de installed.packages()[,"Package"]et installez les packages manquants. Quelque chose comme ça:

list.of.packages <- c("ggplot2", "Rcpp")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages)) install.packages(new.packages)

Autrement:

Si vous placez votre code dans un package et en faites des dépendances, ils seront automatiquement installés lorsque vous installerez votre package.

Dason K. et moi avons le paquet pacman qui peut très bien faire ça. La fonction p_loaddu package fait cela. La première ligne consiste simplement à s'assurer que pacman est installé.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(package1, package2, package_n)

Vous pouvez simplement utiliser la valeur de retour de require:

if(!require(somepackage)){
    install.packages("somepackage")
    library(somepackage)
}

J'utilise libraryaprès l'installation car cela lèvera une exception si l'installation n'a pas réussi ou si le package ne peut pas être chargé pour une autre raison. Vous rendez cela plus robuste et réutilisable:

dynamic_require <- function(package){
  if(eval(parse(text=paste("require(",package,")")))) return True

  install.packages(package)
  return eval(parse(text=paste("require(",package,")")))
}

L'inconvénient de cette méthode est que vous devez passer le nom du package entre guillemets, ce que vous ne faites pas pour le vrai require.

if (!require('ggplot2')) install.packages('ggplot2'); library('ggplot2')

"ggplot2" est le paquet. Il vérifie si le package est installé, sinon, il l'installe. Il charge ensuite le package quelle que soit la branche qu'il a prise.

Cette solution prendra un vecteur de caractères des noms de packages et tentera de les charger ou de les installer si le chargement échoue. Cela dépend du comportement de retour de requirepour ce faire car ...

require renvoie (de manière invisible) une logique indiquant si le package requis est disponible

Par conséquent, nous pouvons simplement voir si nous avons pu charger le package requis et sinon, l'installer avec les dépendances. Donc, étant donné un vecteur de caractères des packages que vous souhaitez charger ...

foo <- function(x){
  for( i in x ){
    #  require returns TRUE invisibly if it was able to load package
    if( ! require( i , character.only = TRUE ) ){
      #  If package was not able to be loaded then re-install
      install.packages( i , dependencies = TRUE )
      #  Load package after installing
      require( i , character.only = TRUE )
    }
  }
}

#  Then try/install packages...
foo( c("ggplot2" , "reshape2" , "data.table" ) )

Beaucoup de réponses ci-dessus (et sur des doublons de cette question) se fondent sur la installed.packagesmauvaise forme. De la documentation:

Cela peut être lent lorsque des milliers de packages sont installés, donc ne l'utilisez pas pour savoir si un package nommé est installé (utilisez system.file ou find.package) ni pour savoir si un package est utilisable (appelez require et vérifiez le valeur de retour) ni pour trouver les détails d'un petit nombre de packages (utilisez packageDescription). Il doit lire plusieurs fichiers par package installé, ce qui sera lent sous Windows et sur certains systèmes de fichiers montés en réseau.

Ainsi, une meilleure approche consiste à tenter de charger le package à l'aide de requireet à installer si le chargement échoue ( requireretournera FALSEs'il n'est pas trouvé). Je préfère cette implémentation:

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    if(length(need)>0){ 
        install.packages(need)
        lapply(need,require,character.only=TRUE)
    }
}

qui peut être utilisé comme ceci:

using("RCurl","ggplot2","jsonlite","magrittr")

De cette façon, il charge tous les packages, puis revient en arrière et installe tous les packages manquants (ce qui si vous le souhaitez, est un endroit pratique pour insérer une invite pour demander si l'utilisateur souhaite installer des packages). Au lieu d'appeler install.packagesséparément pour chaque paquet, il passe le vecteur entier des paquets désinstallés une seule fois.

Voici la même fonction mais avec une boîte de dialogue Windows qui demande si l'utilisateur souhaite installer les packages manquants

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    n<-length(need)
    if(n>0){
        libsmsg<-if(n>2) paste(paste(need[1:(n-1)],collapse=", "),",",sep="") else need[1]
        print(libsmsg)
        if(n>1){
            libsmsg<-paste(libsmsg," and ", need[n],sep="")
        }
        libsmsg<-paste("The following packages could not be found: ",libsmsg,"\n\r\n\rInstall missing packages?",collapse="")
        if(winDialog(type = c("yesno"), libsmsg)=="YES"){       
            install.packages(need)
            lapply(need,require,character.only=TRUE)
        }
    }
}

Bien que la réponse de Shane soit vraiment bonne, pour l'un de mes projets, j'avais besoin de supprimer les messages de sortie, les avertissements et d'installer les packages automatiquement . J'ai finalement réussi à obtenir ce script:

InstalledPackage <- function(package) 
{
    available <- suppressMessages(suppressWarnings(sapply(package, require, quietly = TRUE, character.only = TRUE, warn.conflicts = FALSE)))
    missing <- package[!available]
    if (length(missing) > 0) return(FALSE)
    return(TRUE)
}

CRANChoosen <- function()
{
    return(getOption("repos")["CRAN"] != "@CRAN@")
}

UsePackage <- function(package, defaultCRANmirror = "http://cran.at.r-project.org") 
{
    if(!InstalledPackage(package))
    {
        if(!CRANChoosen())
        {       
            chooseCRANmirror()
            if(!CRANChoosen())
            {
                options(repos = c(CRAN = defaultCRANmirror))
            }
        }

        suppressMessages(suppressWarnings(install.packages(package)))
        if(!InstalledPackage(package)) return(FALSE)
    }
    return(TRUE)
}

Utilisation:

libraries <- c("ReadImages", "ggplot2")
for(library in libraries) 
{ 
    if(!UsePackage(library))
    {
        stop("Error!", library)
    }
}

# List of packages for session
.packages = c("ggplot2", "plyr", "rms")

# Install CRAN packages (if not already installed)
.inst <- .packages %in% installed.packages()
if(length(.packages[!.inst]) > 0) install.packages(.packages[!.inst])

# Load packages into session 
lapply(.packages, require, character.only=TRUE)

C'est le but du package rbundler : fournir un moyen de contrôler les packages installés pour un projet spécifique. À l'heure actuelle, le package fonctionne avec la fonctionnalité devtools pour installer les packages dans le répertoire de votre projet. La fonctionnalité est similaire au bundler de Ruby .

Si votre projet est un package (recommandé), il vous suffit de charger rbundler et de regrouper les packages. La bundlefonction examinera le DESCRIPTIONfichier de votre package pour déterminer les packages à regrouper.

library(rbundler)
bundle('.', repos="http://cran.us.r-project.org")

Maintenant, les packages seront installés dans le répertoire .Rbundle.

Si votre projet n'est pas un package, vous pouvez le simuler en créant un DESCRIPTIONfichier dans le répertoire racine de votre projet avec un champ Depends qui répertorie les packages que vous souhaitez installer (avec des informations de version facultatives):

Depends: ggplot2 (>= 0.9.2), arm, glmnet

Voici le dépôt github du projet si vous êtes intéressé à contribuer: rbundler .

Sûr.

Vous devez comparer les «packages installés» avec les «packages souhaités». C'est très proche de ce que je fais avec CRANberries car j'ai besoin de comparer les «packages connus stockés» avec les «packages actuellement connus» pour déterminer les packages nouveaux et / ou mis à jour.

Alors fais quelque chose comme

AP <- available.packages(contrib.url(repos[i,"url"]))   # available t repos[i]

pour obtenir tous les packages connus, appelez simulairement les packages actuellement installés et comparez cela à un ensemble donné de packages cibles.

À utiliser packratpour que les bibliothèques partagées soient exactement les mêmes et ne changent pas l'environnement des autres.

En termes d'élégance et de meilleures pratiques, je pense que vous vous y prenez fondamentalement dans le mauvais sens. Le package a packratété conçu pour ces problèmes. Il est développé par RStudio par Hadley Wickham. Au lieu de devoir installer des dépendances et éventuellement gâcher le système d'environnement de quelqu'un, packratutilise son propre répertoire et installe toutes les dépendances pour vos programmes là-dedans et ne touche pas l'environnement de quelqu'un.

Packrat est un système de gestion des dépendances pour R.

Les dépendances du package R peuvent être frustrantes. Avez-vous déjà dû utiliser des essais et des erreurs pour déterminer les packages R que vous devez installer pour faire fonctionner le code de quelqu'un d'autre, puis vous êtes resté avec ces packages installés globalement pour toujours, car maintenant vous ne savez pas si vous en avez besoin ? Avez-vous déjà mis à jour un package pour que le code de l'un de vos projets fonctionne, pour constater que le package mis à jour fait que le code d'un autre projet cesse de fonctionner?

Nous avons construit packrat pour résoudre ces problèmes. Utilisez packrat pour rendre vos projets R plus:

• Isolé: l'installation d'un package nouveau ou mis à jour pour un projet n'interrompra pas vos autres projets, et vice versa. En effet, packrat donne à chaque projet sa propre bibliothèque de packages privés.
• Portable: transportez facilement vos projets d'un ordinateur à un autre, même sur différentes plates-formes. Packrat facilite l'installation des packages dont dépend votre projet.
• Reproductible: Packrat enregistre les versions exactes des packages dont vous dépendez et garantit que ces versions exactes sont celles qui sont installées où que vous alliez.

https://rstudio.github.io/packrat/

La fonction simple suivante fonctionne comme un charme:

  usePackage<-function(p){
      # load a package if installed, else load after installation.
      # Args:
      #   p: package name in quotes

      if (!is.element(p, installed.packages()[,1])){
        print(paste('Package:',p,'Not found, Installing Now...'))
        install.packages(p, dep = TRUE)}
      print(paste('Loading Package :',p))
      require(p, character.only = TRUE)  
    }

(pas le mien, je l'ai trouvé sur le Web il y a quelque temps et je l'ai utilisé depuis. Je ne suis pas sûr de la source d'origine)

J'utilise la fonction suivante pour installer le package en cas de require("<package>")sortie avec une erreur de package introuvable. Il interrogera les deux référentiels CRAN et Bioconductor pour le paquet manquant.

Adapté de l'œuvre originale de Joshua Wiley, http://r.789695.n4.nabble.com/Install-package-automatically-if-not-there-td2267532.html

install.packages.auto <- function(x) { 
  x <- as.character(substitute(x)) 
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else { 
    #update.packages(ask= FALSE) #update installed packages.
    eval(parse(text = sprintf("install.packages(\"%s\", dependencies = TRUE)", x)))
  }
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else {
    source("http://bioconductor.org/biocLite.R")
    #biocLite(character(), ask=FALSE) #update installed packages.
    eval(parse(text = sprintf("biocLite(\"%s\")", x)))
    eval(parse(text = sprintf("require(\"%s\")", x)))
  }
}

Exemple:

install.packages.auto(qvalue) # from bioconductor
install.packages.auto(rNMF) # from CRAN

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)mettra à jour tous les packages installés sur le système. Cela peut prendre du temps et le considérer comme une mise à niveau R complète qui peut ne pas être garantie tout le temps!

Vous pouvez simplement utiliser la setdifffonction pour obtenir les packages qui ne sont pas installés, puis les installer. Dans l'exemple ci-dessous, nous vérifions si les packages ggplot2et Rcppsont installés avant de les installer.

unavailable <- setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages()))
install.packages(unavailable)

En une ligne, ce qui précède peut s'écrire:

install.packages(setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages())))

J'ai implémenté la fonction pour installer et charger silencieusement les packages R requis. L'espoir pourrait aider. Voici le code:

# Function to Install and Load R Packages
Install_And_Load <- function(Required_Packages)
{
    Remaining_Packages <- Required_Packages[!(Required_Packages %in% installed.packages()[,"Package"])];

    if(length(Remaining_Packages)) 
    {
        install.packages(Remaining_Packages);
    }
    for(package_name in Required_Packages)
    {
        library(package_name,character.only=TRUE,quietly=TRUE);
    }
}

# Specify the list of required packages to be installed and load    
Required_Packages=c("ggplot2", "Rcpp");

# Call the Function
Install_And_Load(Required_Packages);

La prochaine version de RStudio (1.2), déjà disponible en avant-première, comprendra une fonctionnalité pour détecter les paquets manquants library()et les require()appels, et invitera l'utilisateur à les installer:

Détecter les packages R manquants

De nombreux scripts R s'ouvrent avec des appels à library()et require()pour charger les packages dont ils ont besoin pour s'exécuter. Si vous ouvrez un script R qui fait référence à des packages que vous n'avez pas installés, RStudio propose désormais d'installer tous les packages nécessaires en un seul clic. Plus besoin de taper à install.packages()plusieurs reprises jusqu'à ce que les erreurs disparaissent!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Cela semble répondre particulièrement bien à la préoccupation initiale du PO:

Beaucoup d'entre eux sont des utilisateurs R novices / intermédiaires et ne réalisent pas qu'ils doivent installer des packages qu'ils n'ont pas déjà.

Concernant votre objectif principal "installer des bibliothèques qu'ils n'ont pas déjà." Et indépendamment de l'utilisation de "instllaed.packages ()". La fonction suivante masque la fonction d'origine de require. Il essaie de charger et de vérifier le package nommé "x", s'il n'est pas installé, installez-le directement, y compris les dépendances; et enfin le charger normalement. vous renommez le nom de la fonction de 'require' en 'library' pour maintenir l'intégrité. La seule limitation est que les noms des packages doivent être cités.

require <- function(x) { 
  if (!base::require(x, character.only = TRUE)) {
  install.packages(x, dep = TRUE) ; 
  base::require(x, character.only = TRUE)
  } 
}

Vous pouvez donc charger et installer le package à l'ancienne façon de R. require ("ggplot2") require ("Rcpp")

Assez basique.

pkgs = c("pacman","data.table")
if(length(new.pkgs <- setdiff(pkgs, rownames(installed.packages())))) install.packages(new.pkgs)

Je pensais contribuer celui que j'utilise:

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")

source("https://bioconductor.org/biocLite.R")
if (!require("ggsci")) biocLite("ggsci")

En utilisant l'approche familiale paresseuse et la fonction anonyme, vous pouvez:

1. Essayez de joindre tous les packages répertoriés.
2. Installation manquante uniquement (utilisation || évaluation paresseuse).
3. Essayez de rattacher ceux qui manquaient à l'étape 1 et installés à l'étape 2.

4. Imprimez le statut de chargement final de chaque colis ( TRUE/ FALSE).

   req <- substitute(require(x, character.only = TRUE))
   lbs <- c("plyr", "psych", "tm")
   sapply(lbs, function(x) eval(req) || {install.packages(x); eval(req)})
   
   plyr psych    tm 
   TRUE  TRUE  TRUE 

J'utilise ce qui suit qui vérifiera si le package est installé et si les dépendances sont mises à jour, puis charge le package.

p<-c('ggplot2','Rcpp')
install_package<-function(pack)
{if(!(pack %in% row.names(installed.packages())))
{
  update.packages(ask=F)
  install.packages(pack,dependencies=T)
}
 require(pack,character.only=TRUE)
}
for(pack in p) {install_package(pack)}

completeFun <- function(data, desiredCols) {
  completeVec <- complete.cases(data[, desiredCols])
  return(data[completeVec, ])
}

Voici mon code pour cela:

packages <- c("dplyr", "gridBase", "gridExtra")
package_loader <- function(x){
    for (i in 1:length(x)){
        if (!identical((x[i], installed.packages()[x[i],1])){
            install.packages(x[i], dep = TRUE)
        } else {
            require(x[i], character.only = TRUE)
        }
    }
}
package_loader(packages)

 48 lapply_install_and_load <- function (package1, ...)
 49 {
 50     #
 51     # convert arguments to vector
 52     #
 53     packages <- c(package1, ...)
 54     #
 55     # check if loaded and installed
 56     #
 57     loaded        <- packages %in% (.packages())
 58     names(loaded) <- packages
 59     #
 60     installed        <- packages %in% rownames(installed.packages())
 61     names(installed) <- packages
 62     #
 63     # start loop to determine if each package is installed
 64     #
 65     load_it <- function (p, loaded, installed)
 66     {
 67         if (loaded[p])
 68         {
 69             print(paste(p, "loaded"))
 70         }
 71         else
 72         {
 73             print(paste(p, "not loaded"))
 74             if (installed[p])
 75             {
 76                 print(paste(p, "installed"))
 77                 do.call("library", list(p))
 78             }
 79             else
 80             {
 81                 print(paste(p, "not installed"))
 82                 install.packages(p)
 83                 do.call("library", list(p))
 84             }
 85         }
 86     }
 87     #
 88     lapply(packages, load_it, loaded, installed)
 89 }

library <- function(x){
  x = toString(substitute(x))
if(!require(x,character.only=TRUE)){
  install.packages(x)
  base::library(x,character.only=TRUE)
}}

Cela fonctionne avec les noms de paquets non cités et est assez élégant (cf. la réponse de GeoObserver)

Dans mon cas, je voulais une doublure que je pourrais exécuter à partir de la ligne de commande (en fait via un Makefile). Voici un exemple d'installation de "VGAM" et "feather" s'ils ne sont pas déjà installés:

R -e 'for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")'

De l'intérieur de R, ce serait juste:

for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")

Il n'y a rien ici au-delà des solutions précédentes, sauf que:

• Je le garde sur une seule ligne
• J'ai codé en dur le reposparamètre (pour éviter toute fenêtre contextuelle demandant le miroir à utiliser)
• Je n'ai pas la peine de définir une fonction à utiliser ailleurs

Notez également l'important character.only=TRUE(sans lui, le requiretenterait de charger le package p).

  packages_installed <- function(pkg_list){
        pkgs <- unlist(pkg_list)
        req <- unlist(lapply(pkgs, require, character.only = TRUE))
        not_installed <- pkgs[req == FALSE]
        lapply(not_installed, install.packages, 
               repos = "http://cran.r-project.org")# add lib.loc if needed
        lapply(pkgs, library, character.only = TRUE)
}

Permettez-moi de partager un peu de folie:

c("ggplot2","ggsci", "hrbrthemes", "gghighlight", "dplyr") %>%  # What will you need to load for this script?
  (function (x) ifelse(t =!(x %in% installed.packages()), 
    install.packages(x[t]),
    lapply(x, require)))