Maneira elegante de verificar se há pacotes ausentes e instalá-los?

Parece que estou compartilhando muito código com os co-autores atualmente. Muitos deles são usuários R iniciantes / intermediários e não percebem que precisam instalar pacotes que ainda não possuem.

Existe uma maneira elegante de ligar installed.packages(), comparar com as que estou carregando e instalando, se estiver faltando?

Sim. Se você possui sua lista de pacotes, compare-a com a saída installed.packages()[,"Package"]e instale os pacotes ausentes. Algo assim:

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 outra forma:

Se você colocar seu código em um pacote e torná-lo dependente, ele será instalado automaticamente quando você instalar o pacote.

Dason K. e eu temos o pacote pacman que pode fazer isso muito bem. A função p_loadno pacote faz isso. A primeira linha é apenas para garantir que o pacman esteja instalado.

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

Você pode apenas usar o valor de retorno de require:

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

Eu uso libraryapós a instalação, porque ela emitirá uma exceção se a instalação não tiver sido bem-sucedida ou se o pacote não puder ser carregado por algum outro motivo. Você torna isso mais robusto e reutilizável:

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

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

A desvantagem desse método é que você deve passar o nome do pacote entre aspas, o que você não faz de verdade require.

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

"ggplot2" é o pacote. Ele verifica se o pacote está instalado, se não está. Em seguida, ele carrega o pacote independentemente de qual ramificação foi realizada.

Essa solução pega um vetor de caracteres dos nomes dos pacotes e tenta carregá-los ou instalá-los se o carregamento falhar. Ele se baseia no comportamento de retorno de requirefazer isso porque ...

require retorna (invisivelmente) uma lógica indicando se o pacote necessário está disponível

Portanto, podemos simplesmente ver se conseguimos carregar o pacote necessário e, se não, instalá-lo com dependências. Então, dado um vetor de caractere de pacotes que você deseja carregar ...

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

Muitas das respostas acima (e duplicatas desta pergunta) dependem da installed.packagesmá forma. A partir da documentação:

Isso pode ser lento quando milhares de pacotes estão instalados; portanto, não use isso para descobrir se um pacote nomeado está instalado (use system.file ou find.package) nem para descobrir se um pacote é utilizável (chame exigir e verifique o valor de retorno) nem para encontrar detalhes de um pequeno número de pacotes (use packageDescription). Ele precisa ler vários arquivos por pacote instalado, o que será lento no Windows e em alguns sistemas de arquivos montados em rede.

Portanto, uma abordagem melhor é tentar carregar o pacote usando ee requireinstalando se o carregamento falhar ( requireretornará FALSEse não for encontrado). Eu prefiro esta implementação:

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 pode ser usado assim:

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

Dessa forma, ele carrega todos os pacotes, depois volta e instala todos os pacotes ausentes (que, se você quiser, é um local útil para inserir um prompt para perguntar se o usuário deseja instalar pacotes). Em vez de chamar install.packagesseparadamente para cada pacote, ele passa o vetor inteiro de pacotes desinstalados apenas uma vez.

Aqui está a mesma função, mas com uma caixa de diálogo do Windows que pergunta se o usuário deseja instalar os pacotes ausentes

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

Embora a resposta de Shane seja realmente boa, para um dos meus projetos eu precisava remover as mensagens de saída, avisos e instalar pacotes automaticamente . Finalmente consegui obter 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)
}

Usar:

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 é o objetivo do pacote rbundler : fornecer uma maneira de controlar os pacotes instalados para um projeto específico. No momento, o pacote trabalha com a funcionalidade devtools para instalar pacotes no diretório do seu projeto. A funcionalidade é semelhante ao empacotador de Ruby .

Se o seu projeto é um pacote (recomendado), tudo o que você precisa fazer é carregar o rbundler e empacotar os pacotes. A bundlefunção examinará o DESCRIPTIONarquivo do seu pacote para determinar quais pacotes agrupar.

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

Agora os pacotes serão instalados no diretório .Rbundle.

Se o seu projeto não é um pacote, você pode falsificá-lo criando um DESCRIPTIONarquivo no diretório raiz do seu projeto com um campo Depends que lista os pacotes que você deseja instalar (com informações opcionais da versão):

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

Aqui está o repositório do github para o projeto, se você estiver interessado em contribuir: rbundler .

Certo.

Você precisa comparar 'pacotes instalados' com 'pacotes desejados'. Isso é muito parecido com o que eu faço com o CRANberries, pois preciso comparar 'pacotes conhecidos armazenados' com 'pacotes atualmente conhecidos' para determinar pacotes novos e / ou atualizados.

Então faça algo como

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

Para obter todos os pacotes conhecidos, chame os pacotes atualmente instalados e compare-os a um determinado conjunto de pacotes de destino.

Use packratpara que as bibliotecas compartilhadas sejam exatamente iguais e não alterem o ambiente de outras pessoas.

Em termos de elegância e melhores práticas, acho que você está fundamentalmente fazendo isso da maneira errada. O pacote packratfoi projetado para esses problemas. É desenvolvido pelo RStudio por Hadley Wickham. Em vez de terem que instalar dependências e possivelmente atrapalhar o sistema de ambiente de alguém, packratusa seu próprio diretório e instala todas as dependências dos seus programas lá e não toca no ambiente de alguém.

Packrat é um sistema de gerenciamento de dependências para R.

As dependências do pacote R podem ser frustrantes. Você já teve que usar tentativa e erro para descobrir quais pacotes R você precisa instalar para que o código de outra pessoa funcionasse - e ficou com esses pacotes instalados globalmente para sempre, porque agora você não tem certeza se precisa deles ? Você já atualizou um pacote para que o código de um de seus projetos funcione, apenas para descobrir que o pacote atualizado faz com que o código de outro projeto pare de funcionar?

Criamos o packrat para resolver esses problemas. Use o packrat para tornar seus projetos R mais:

• Isolado: a instalação de um pacote novo ou atualizado para um projeto não interromperá os outros projetos e vice-versa. Isso porque o packrat fornece a cada projeto sua própria biblioteca de pacotes privada.
• Portátil: transporte facilmente seus projetos de um computador para outro, mesmo em diferentes plataformas. O Packrat facilita a instalação dos pacotes dos quais seu projeto depende.
• Reproduzível: O Packrat registra as versões exatas dos pacotes dos quais você depende e garante que essas versões exatas sejam as instaladas onde quer que você vá.

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

A seguinte função simples funciona como um 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)  
    }

(não o meu, encontrei isso na web há algum tempo e o estava usando desde então. não tenho certeza da fonte original)

Eu uso a seguinte função para instalar o pacote se require("<package>")sair com o erro do pacote não encontrado. Ele consultará os repositórios - CRAN e Bioconductor quanto a pacotes ausentes.

Adaptado do trabalho 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)))
  }
}

Exemplo:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)atualizará todos os pacotes instalados no sistema. Isso pode levar um longo tempo e considerá-lo uma atualização completa do R, que pode não ser garantida o tempo todo!

Você pode simplesmente usar a setdifffunção para obter os pacotes que não estão instalados e depois instalá-los. Na amostra abaixo, verificamos se os pacotes ggplot2e Rcppestão instalados antes de instalá-los.

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

Em uma linha, o acima pode ser escrito como:

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

Eu implementei a função para instalar e carregar pacotes R necessários silenciosamente. A esperança pode ajudar. Aqui está o 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);

A próxima versão do RStudio (1.2), já disponível como uma prévia, incluirá um recurso para detectar pacotes library()e require()chamadas ausentes e solicitar ao usuário que os instale:

Detectar pacotes R ausentes

Muitos scripts R são abertos com chamadas library()e require()para carregar os pacotes necessários para serem executados. Se você abrir um script R que faça referência a pacotes que você não instalou, o RStudio agora oferecerá a instalação de todos os pacotes necessários em um único clique. Não há mais digitação install.packages()repetida até os erros desaparecerem!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Isso parece abordar a preocupação original do OP particularmente bem:

Muitos deles são usuários R iniciantes / intermediários e não percebem que precisam instalar pacotes que ainda não possuem.

Em relação ao seu principal objetivo "instalar bibliotecas que elas ainda não possuem" e independentemente de usar "instllaed.packages ()". A função a seguir mascara a função original de require. Ele tenta carregar e verificar o pacote nomeado "x", se não estiver instalado, instale-o diretamente, incluindo dependências; e, finalmente, carregá-lo normalmente. você renomeia o nome da função de 'require' para 'library' para manter a integridade. A única limitação é que os nomes dos pacotes devem ser citados.

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

Portanto, você pode carregar e instalar o pacote da maneira antiga 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)

Pensei em contribuir com o que eu 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 a família lapply e a abordagem de função anônima, você pode:

1. Tente anexar todos os pacotes listados.
2. Instale apenas ausente (usando ||avaliação lenta).
3. Tente anexar novamente aqueles que estavam faltando na etapa 1 e instalados na etapa 2.

4. Imprima o status de carregamento final de cada pacote ( 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 

Eu uso o seguinte, que verificará se o pacote está instalado e se as dependências foram atualizadas e, em seguida, carrega o pacote.

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

Aqui está o meu código:

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

Isso funciona com nomes de pacotes não citados e é bastante elegante (consulte a resposta do GeoObserver)

No meu caso, eu queria um liner que pudesse ser executado a partir da linha de comando (na verdade, através de um Makefile). Aqui está um exemplo de instalação de "VGAM" e "feather" se eles ainda não estiverem 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")'

De dentro de R seria apenas:

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

Não há nada aqui além das soluções anteriores, exceto que:

• Eu mantenho isso em uma única linha
• Eu codifico o reposparâmetro (para evitar pop-ups perguntando sobre o espelho para usar)
• Eu não me preocupo em definir uma função para ser usada em outro lugar

Observe também o importante character.only=TRUE(sem ele, o requiretentaria carregar o pacote 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)
}

Deixe-me compartilhar um pouco de loucura:

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