¿Una forma elegante de buscar paquetes faltantes e instalarlos?

Parece que estoy compartiendo mucho código con los coautores en estos días. Muchos de ellos son usuarios novatos / intermedios de R y no se dan cuenta de que tienen que instalar paquetes que ya no tienen.

¿Hay una manera elegante de llamar installed.packages(), compararla con las que estoy cargando e instalar si falta?

Si. Si tiene su lista de paquetes, compárela con el resultado installed.packages()[,"Package"]e instale los paquetes que faltan. Algo como esto:

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)

De otra manera:

Si coloca su código en un paquete y las convierte en dependencias, se instalarán automáticamente cuando instale su paquete.

Dason K. y yo tenemos el paquete pacman que puede hacer esto bien. La función p_loaden el paquete hace esto. La primera línea es solo para garantizar que pacman esté instalado.

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

Puede usar el valor de retorno de require:

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

Lo uso librarydespués de la instalación porque arrojará una excepción si la instalación no fue exitosa o el paquete no se puede cargar por alguna otra razón. Lo haces más robusto y reutilizable:

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

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

La desventaja de este método es que debe pasar el nombre del paquete entre comillas, lo que no hace de verdad require.

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

"ggplot2" es el paquete. Comprueba si el paquete está instalado, si no lo está, lo instala. Luego carga el paquete independientemente de la rama que tomó.

Esta solución tomará un vector de caracteres de los nombres de los paquetes e intentará cargarlos o instalarlos si falla la carga. Se basa en el comportamiento de retorno de requirehacer esto porque ...

require devuelve (invisiblemente) una lógica que indica si el paquete requerido está disponible

Por lo tanto, simplemente podemos ver si pudimos cargar el paquete requerido y, de lo contrario, instalarlo con dependencias. Entonces, dado un vector de caracteres de los paquetes que desea cargar ...

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

Muchas de las respuestas anteriores (y en duplicados de esta pregunta) dependen de installed.packagescuál es una mala forma. De la documentación:

Esto puede ser lento cuando se instalan miles de paquetes, así que no lo use para averiguar si un paquete con nombre está instalado (use system.file o find.package) ni para averiguar si un paquete es utilizable (llame y solicite valor de retorno) ni para encontrar detalles de una pequeña cantidad de paquetes (use packageDescription). Necesita leer varios archivos por paquete instalado, lo que será lento en Windows y en algunos sistemas de archivos montados en red.

Por lo tanto, un mejor enfoque es intentar cargar el paquete usando requiree instalarlo si falla la carga ( requirevolverá FALSEsi no se encuentra). Prefiero esta implementación:

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

que se puede usar así:

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

De esta manera, carga todos los paquetes, luego regresa e instala todos los paquetes que faltan (que si lo desea, es un lugar útil para insertar un mensaje para preguntar si el usuario desea instalar paquetes). En lugar de llamar install.packagespor separado para cada paquete, pasa el vector completo de los paquetes desinstalados solo una vez.

Aquí está la misma función pero con un cuadro de diálogo de Windows que pregunta si el usuario desea instalar los paquetes faltantes

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

Aunque la respuesta de Shane es realmente buena, para uno de mis proyectos necesitaba eliminar los mensajes de salida, advertencias e instalar paquetes automáticamente . Finalmente logré obtener este 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)
}

Utilizar:

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)

Este es el propósito del paquete rbundler : proporcionar una forma de controlar los paquetes que están instalados para un proyecto específico. En este momento, el paquete funciona con la funcionalidad devtools para instalar paquetes en el directorio de su proyecto. La funcionalidad es similar al paquete de Ruby .

Si su proyecto es un paquete (recomendado), todo lo que tiene que hacer es cargar rbundler y agrupar los paquetes. La bundlefunción mirará el DESCRIPTIONarchivo de su paquete para determinar qué paquetes agrupar.

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

Ahora los paquetes se instalarán en el directorio .Rbundle.

Si su proyecto no es un paquete, puede simularlo creando un DESCRIPTIONarchivo en el directorio raíz de su proyecto con un campo Depende que enumere los paquetes que desea instalar (con información de versión opcional):

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

Aquí está el repositorio de github para el proyecto si está interesado en contribuir: rbundler .

Por supuesto.

Necesita comparar 'paquetes instalados' con 'paquetes deseados'. Eso está muy cerca de lo que hago con CRANberries, ya que necesito comparar 'paquetes conocidos almacenados' con 'paquetes conocidos actualmente' para determinar paquetes nuevos y / o actualizados.

Entonces haz algo como

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

para obtener todos los paquetes conocidos, llame de forma simulada a los paquetes instalados actualmente y compárelos con un conjunto dado de paquetes de destino.

Úselo packratpara que las bibliotecas compartidas sean exactamente iguales y no cambien el entorno de los demás.

En términos de elegancia y mejores prácticas, creo que básicamente lo estás haciendo mal. El paquete packratfue diseñado para estos problemas. Está desarrollado por RStudio por Hadley Wickham. En lugar de tener que instalar dependencias y posiblemente estropear el sistema de entorno de alguien, packratusa su propio directorio e instala todas las dependencias para sus programas allí y no toca el entorno de alguien.

Packrat es un sistema de gestión de dependencias para R.

Las dependencias del paquete R pueden ser frustrantes. ¿Alguna vez ha tenido que usar prueba y error para descubrir qué paquetes R necesita instalar para que el código de otra persona funcione? Y luego se quedó con esos paquetes instalados globalmente para siempre, porque ahora no está seguro de si los necesita ? ¿Alguna vez ha actualizado un paquete para que el código de uno de sus proyectos funcione, solo para descubrir que el paquete actualizado hace que el código de otro proyecto deje de funcionar?

Construimos Packrat para resolver estos problemas. Use packrat para hacer que sus proyectos de R sean más:

• Aislado: la instalación de un paquete nuevo o actualizado para un proyecto no interrumpirá sus otros proyectos, y viceversa. Eso es porque packrat le da a cada proyecto su propia biblioteca de paquetes privados.
• Portátil: transporte fácilmente sus proyectos de una computadora a otra, incluso a través de diferentes plataformas. Packrat facilita la instalación de los paquetes de los que depende su proyecto.
• Reproducible: Packrat registra las versiones exactas de los paquetes de los que depende y garantiza que esas versiones exactas sean las que se instalan donde quiera que vaya.

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

La siguiente función simple funciona como un encanto:

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

(no el mío, encontré esto en la web hace algún tiempo y lo había estado usando desde entonces. No estoy seguro de la fuente original)

Uso la siguiente función para instalar el paquete si require("<package>")sale con un error de paquete no encontrado. Consultará los repositorios CRAN y Bioconductor para el paquete faltante.

Adaptado del trabajo original 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)))
  }
}

Ejemplo:

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

PD: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)actualizará todos los paquetes instalados en el sistema. ¡Esto puede llevar mucho tiempo y considerarlo como una actualización completa de R que puede no estar garantizada todo el tiempo!

Simplemente puede usar la setdifffunción para obtener los paquetes que no están instalados y luego instalarlos. En el ejemplo a continuación, verificamos si los paquetes ggplot2y Rcppestán instalados antes de instalarlos.

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

En una línea, lo anterior se puede escribir como:

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

He implementado la función para instalar y cargar los paquetes R necesarios de forma silenciosa. La esperanza podría ayudar. Aquí está el código:

# 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 próxima versión de RStudio (1.2), ya disponible como vista previa, incluirá una función para detectar paquetes faltantes library()y require()llamadas, y solicitará al usuario que los instale:

Detectar paquetes R faltantes

Muchos scripts R se abren con llamadas library()y require()para cargar los paquetes que necesitan para ejecutarlos. Si abre un script R que hace referencia a paquetes que no ha instalado, RStudio ahora ofrecerá instalar todos los paquetes necesarios con un solo clic. ¡No más escribir install.packages()repetidamente hasta que los errores desaparezcan!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Esto parece abordar la preocupación original de OP particularmente bien:

Muchos de ellos son usuarios R principiantes / intermedios y no se dan cuenta de que tienen que instalar paquetes que ya no tienen.

Con respecto a su objetivo principal "instalar bibliotecas que aún no tienen" e independientemente del uso de "instllaed.packages ()". La siguiente función enmascara la función original de require. Intenta cargar y verificar el paquete con nombre "x"; si no está instalado, instálelo directamente, incluidas las dependencias; y por último cargarlo normalmente. cambia el nombre de la función de 'require' a 'library' para mantener la integridad. La única limitación es que se deben citar los nombres de los paquetes.

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

Por lo tanto, puede cargar e instalar el paquete a la antigua usanza de R. require ("ggplot2") require ("Rcpp")

Bastante básico.

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

Pensé que contribuiría con el que 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")

Usando el enfoque de familia anónima y función anónima, usted puede:

1. Intente adjuntar todos los paquetes enumerados.
2. Instalar solo faltante (usando ||evaluación perezosa).
3. Intente adjuntar nuevamente los que faltaban en el paso 1 y se instalaron en el paso 2.

4. Imprima el estado de carga final de cada paquete ( 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 

Utilizo lo siguiente que verificará si el paquete está instalado y si las dependencias se actualizan, luego carga el paquete.

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

Aquí está mi código para ello:

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

Esto funciona con nombres de paquetes sin comillas y es bastante elegante (véase la respuesta de GeoObserver)

En mi caso, quería un trazador de líneas que pudiera ejecutar desde la línea de comandos (en realidad a través de un Makefile). Aquí hay un ejemplo de instalación de "VGAM" y "pluma" si aún no están instalados:

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

Desde dentro de R solo sería:

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

Aquí no hay nada más allá de las soluciones anteriores, excepto que:

• Lo mantengo en una sola línea
• Codifico el repos parámetro (para evitar cualquier ventana emergente que pregunte sobre el espejo para usar)
• No me molesto en definir una función para usar en otro lugar

También tenga en cuenta lo importante character.only=TRUE(sin él, requireintentaría cargar el paquete 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)
}

Déjame compartir un poco de locura:

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