Modo elegante per verificare la presenza di pacchetti mancanti e installarli?

In questi giorni mi sembra di condividere molto codice con i coautori. Molti di loro sono utenti R principianti / intermedi e non si rendono conto che devono installare pacchetti che non hanno già.

Esiste un modo elegante per chiamare installed.packages(), confrontarlo con quelli che sto caricando e installare se manca?

Sì. Se hai il tuo elenco di pacchetti, confrontalo con l'output di installed.packages()[,"Package"]e installa i pacchetti mancanti. Qualcosa come questo:

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)

Altrimenti:

Se si inserisce il codice in un pacchetto e si creano loro dipendenze, verranno installate automaticamente quando si installa il pacchetto.

Dason K. e io abbiamo il pacchetto pacman che può farlo bene. La funzione p_loadnel pacchetto fa questo. La prima riga è solo per garantire che pacman sia installato.

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

Puoi semplicemente usare il valore restituito di require:

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

Uso librarydopo l'installazione perché genererà un'eccezione se l'installazione non è andata a buon fine o il pacchetto non può essere caricato per qualche altro motivo. Lo rendi più robusto e riutilizzabile:

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

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

L'aspetto negativo di questo metodo è che devi passare il nome del pacchetto tra virgolette, cosa che non fai per davvero require.

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

"ggplot2" è il pacchetto. Verifica se il pacchetto è installato, in caso contrario lo installa. Quindi carica il pacchetto indipendentemente dal ramo preso.

Questa soluzione prenderà un vettore di caratteri dei nomi dei pacchetti e tenterà di caricarli o installarli se il caricamento non riesce. Si basa sul comportamento di ritorno di requirefare questo perché ...

require restituisce (invisibilmente) una logica che indica se il pacchetto richiesto è disponibile

Pertanto possiamo semplicemente vedere se siamo stati in grado di caricare il pacchetto richiesto e, in caso contrario, installarlo con dipendenze. Quindi dato un carattere vettoriale di pacchetti che desideri caricare ...

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" ) )

Molte delle risposte sopra (e sui duplicati di questa domanda) si basano su installed.packagesquale sia la cattiva forma. Dalla documentazione:

Questo può essere lento quando sono installati migliaia di pacchetti, quindi non utilizzarlo per scoprire se è installato un pacchetto denominato (usa system.file o find.package) né per sapere se un pacchetto è utilizzabile (chiama richiede e controlla il valore di ritorno) né per trovare i dettagli di un numero limitato di pacchetti (usare packageDescription). Deve leggere diversi file per pacchetto installato, che sarà lento su Windows e su alcuni file system montati in rete.

Quindi, un approccio migliore è tentare di caricare il pacchetto usando ee requireinstallarlo se il caricamento fallisce ( requiretornerà FALSEse non viene trovato). Preferisco questa implementazione:

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)
    }
}

che può essere usato in questo modo:

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

In questo modo carica tutti i pacchetti, quindi torna indietro e installa tutti i pacchetti mancanti (che, se lo si desidera, è un posto utile in cui inserire un prompt per chiedere se l'utente desidera installare i pacchetti). Invece di chiamare install.packagesseparatamente per ogni pacchetto, passa l'intero vettore di pacchetti disinstallati una sola volta.

Ecco la stessa funzione ma con una finestra di dialogo di Windows che chiede se l'utente desidera installare i pacchetti mancanti

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)
        }
    }
}

Anche se la risposta di Shane è veramente buono, per una del mio progetto avevo bisogno di rimuovere i messaggi ouput, le avvertenze e installare i pacchetti automagicamente . Sono finalmente riuscito a ottenere questo 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)
}

Uso:

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)

Questo è lo scopo del pacchetto rbundler : fornire un modo per controllare i pacchetti installati per un progetto specifico. In questo momento il pacchetto funziona con la funzionalità devtools per installare i pacchetti nella directory del progetto. La funzionalità è simile al bundler di Ruby .

Se il tuo progetto è un pacchetto (consigliato), tutto ciò che devi fare è caricare rbundler e raggruppare i pacchetti. La bundlefunzione esaminerà il DESCRIPTIONfile del pacchetto per determinare quali pacchetti raggruppare.

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

Ora i pacchetti verranno installati nella directory .Rbundle.

Se il tuo progetto non è un pacchetto, puoi falsificarlo creando un DESCRIPTIONfile nella directory principale del tuo progetto con un campo Dipende che elenca i pacchetti che desideri installare (con informazioni sulla versione facoltative):

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

Ecco il repository github per il progetto se sei interessato a contribuire: rbundler .

Sicuro.

È necessario confrontare "pacchetti installati" con "pacchetti desiderati". È molto vicino a quello che faccio con CRANberries quanto devo confrontare i "pacchetti noti memorizzati" con i "pacchetti attualmente noti" per determinare i pacchetti nuovi e / o aggiornati.

Quindi fai qualcosa del genere

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

per ottenere tutti i pacchetti noti, chiamare similmente i pacchetti attualmente installati e confrontarli con un determinato set di pacchetti di destinazione.

Uso packrat modo che le librerie condivise siano esattamente le stesse e non cambino l'ambiente altrui.

In termini di eleganza e buone pratiche, penso che tu stia fondamentalmente nel modo sbagliato. Il pacchetto è packratstato progettato per questi problemi. È sviluppato da RStudio da Hadley Wickham. Invece di dover installare dipendenze e possibilmente rovinare il sistema ambientale di qualcuno, packratusa la sua directory e installa tutte le dipendenze per i tuoi programmi lì dentro e non tocca l'ambiente di qualcuno.

Packrat è un sistema di gestione delle dipendenze per R.

Le dipendenze del pacchetto R possono essere frustranti. Hai mai dovuto usare tentativi ed errori per capire quali pacchetti R hai bisogno di installare per far funzionare il codice di qualcun altro e poi sei rimasto con quei pacchetti installati a livello globale per sempre, perché ora non sei sicuro di averne bisogno ? Hai mai aggiornato un pacchetto per far funzionare il codice in uno dei tuoi progetti, solo per scoprire che il pacchetto aggiornato fa smettere di funzionare il codice in un altro progetto?

Abbiamo creato packrat per risolvere questi problemi. Usa packrat per rendere di più i tuoi progetti R:

• Isolata: l'installazione di un pacchetto nuovo o aggiornato per un progetto non interromperà gli altri progetti e viceversa. Questo perché packrat fornisce a ciascun progetto la propria libreria di pacchetti privata.
• Portatile: trasporta facilmente i tuoi progetti da un computer all'altro, anche su piattaforme diverse. Packrat semplifica l'installazione dei pacchetti da cui dipende il progetto.
• Riproducibile: Packrat registra le versioni esatte del pacchetto da cui dipendi e garantisce che quelle versioni esatte siano quelle che vengono installate ovunque tu vada.

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

La seguente semplice funzione funziona come un incantesimo:

  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)  
    }

(non mio, l'ho trovato sul web qualche tempo fa e lo usavo da allora. non sono sicuro della fonte originale)

Uso la seguente funzione per installare il pacchetto se require("<package>") esce con errore pacchetto non trovato. Interrogherà entrambi i repository CRAN e Bioconductor per il pacchetto mancante.

Adattato dall'opera originale di 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)))
  }
}

Esempio:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)aggiornerà tutti i pacchetti installati sul sistema. Questo può richiedere molto tempo e considerarlo come un aggiornamento R completo che potrebbe non essere garantito tutto il tempo!

È possibile semplicemente utilizzare la setdifffunzione per ottenere i pacchetti che non sono installati e quindi installarli. Nell'esempio seguente, controlliamo se i pacchetti ggplot2e Rcppsono installati prima di installarli.

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

In una riga, quanto sopra può essere scritto come:

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

Ho implementato la funzione per installare e caricare i pacchetti R richiesti in silenzio. La speranza potrebbe aiutare. Ecco il codice:

# 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 prossima versione di RStudio (1.2), già disponibile come anteprima, includerà una funzione per rilevare i pacchetti library()e le require()chiamate mancanti e chiederà all'utente di installarli:

Rileva i pacchetti R mancanti

Molti script R si aprono con chiamate a library()e require()per caricare i pacchetti necessari per l'esecuzione. Se apri uno script R che fa riferimento a pacchetti che non hai installato, RStudio ora offrirà di installare tutti i pacchetti necessari con un solo clic. Non è più necessario digitare più install.packages()volte fino a quando gli errori scompaiono!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Questo sembra rispondere particolarmente bene alla preoccupazione originale di OP:

Molti di loro sono utenti R principianti / intermedi e non si rendono conto che devono installare pacchetti che non hanno già.

Per quanto riguarda il tuo obiettivo principale "installare librerie che non hanno già." E indipendentemente dall'uso di "instllaed.packages ()". La seguente funzione maschera la funzione originale di request. Cerca di caricare e controllare il pacchetto denominato "x", se non è installato, installalo direttamente includendo le dipendenze; e infine caricarlo normalmente. rinominare il nome della funzione da "request" a "library" per mantenere l'integrità. L'unica limitazione è che i nomi dei pacchetti devono essere citati.

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

Quindi puoi caricare e installare il pacchetto come richiesto da R. alla moda ("ggplot2") ("Rcpp")

Molto semplice.

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

Ho pensato di contribuire con quello che uso:

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

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

Utilizzando la famiglia lappone e l'approccio con funzioni anonime è possibile:

1. Prova ad allegare tutti i pacchetti elencati.
2. Installa solo mancante (usando || valutazione lazy).
3. Tentare di ricollegare quelli mancanti nel passaggio 1 e installati nel passaggio 2.

4. Stampa lo stato di caricamento finale di ciascun pacchetto ( 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 

Uso quanto segue per verificare se il pacchetto è installato e se le dipendenze vengono aggiornate, quindi carica il pacchetto.

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, ])
}

Ecco il mio codice per questo:

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)
}}

Funziona con nomi di pacchetti non quotati ed è abbastanza elegante (vedi la risposta di GeoObserver)

Nel mio caso, volevo un solo liner che potevo eseguire dalla riga di comando (in realtà tramite un Makefile). Ecco un esempio di installazione di "VGAM" e "feather" se non sono già installati:

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

Dall'interno di R sarebbe solo:

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

Non c'è nulla qui oltre alle soluzioni precedenti tranne che:

• Lo tengo su una sola riga
• Ho codificato il repos parametro (per evitare che i popup richiedano il mirror da utilizzare)
• Non mi preoccupo di definire una funzione da utilizzare altrove

Nota anche l'importante character.only=TRUE(senza di esso, il requiretentativo di caricare il pacchetto 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)
}

Vorrei condividere un po 'di follia:

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)))