Eksik paketleri kontrol etmenin ve kurmanın zarif yolu?

Bugünlerde yazarlarla çok fazla kod paylaşıyor gibi görünüyorum. Birçoğu acemi / orta düzeydeki R kullanıcılarıdır ve zaten sahip olmadıkları paketleri kurmaları gerektiğinin farkında değildir.

Aramanın installed.packages(), yüklediğim ve eksik olduğum kişilerle karşılaştırmanın zarif bir yolu var mı ?

Evet. Paket listeniz varsa, listeyi çıktıyla karşılaştırın installed.packages()[,"Package"]ve eksik paketleri yükleyin. Bunun gibi bir şey:

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)

Aksi takdirde:

Kodunuzu bir pakete koyar ve bağımlılık yaparsanız, paketinizi yüklediğinizde bunlar otomatik olarak yüklenir.

Dason K. ve ben bunu güzelce yapabilen pacman paketine sahibiz . p_loadPaketteki işlev bunu yapar. İlk satır pacman'ın kurulu olduğundan emin olmaktır.

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

Sadece dönüş değerini kullanabilirsiniz require:

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

Kurulumdan librarysonra kullanıyorum çünkü kurulum başarılı değilse veya paket başka bir nedenden dolayı yüklenemiyorsa bir istisna atar. Bunu daha sağlam ve tekrar kullanılabilir hale getirirsiniz:

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

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

Bu yöntemin dezavantajı, paket adını gerçek için yapmadığınız tırnak işaretleri içinde iletmenizdir require.

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

"ggplot2" paketidir. Paketin kurulu olup olmadığını, kurulup kurulmadığını kontrol eder. Daha sonra hangi dalda olursa olsun paketi yükler.

Bu çözüm, paket adlarının bir karakter vektörünü alır ve bunları yüklemeye çalışır veya yükleme başarısız olursa bunları yükler. Bunu requireyapmak için geri dönüş davranışına dayanır çünkü ...

require gerekli paketin mevcut olup olmadığını gösteren bir mantık döndürür

Bu nedenle, gerekli paketi yükleyip yükleyemediğimizi görebilir ve değilse, bağımlılıklarla yükleyebiliriz. Yüklemek istediğiniz paketlerin bir karakter vektörü verildiğinde ...

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

Yukarıdaki cevapların çoğu (ve bu sorunun kopyalarında) installed.packageshangisinin kötü olduğuna güvenmektedir . Belgelerden:

Binlerce paket yüklendiğinde bu yavaş olabilir, bu nedenle adlandırılmış bir paketin kurulu olup olmadığını (system.file veya find.package kullanın) öğrenmek ya da bir paketin kullanılabilir olup olmadığını öğrenmek (arama gereksinimi ve kontrol etmek için) kullanmayın. dönüş değeri) veya az sayıda paketin ayrıntılarını bulmak için (packageDescription kullanın). Yüklü paket başına birkaç dosya okumalıdır, bu da Windows ve ağa bağlı bazı dosya sistemlerinde yavaş olacaktır.

Bu nedenle, paketi kullanarak requireve yüklemede başarısız olursa yükleme yapmaya çalışmak daha iyi bir yaklaşımdır ( bulunmazsa requiregeri dönecektir FALSE). Bu uygulamayı tercih ederim:

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

Bu şekilde kullanılabilir:

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

Bu şekilde tüm paketleri yükler, sonra geri döner ve tüm eksik paketleri yükler (isterseniz, kullanıcının paketleri yüklemek isteyip istemediğini sormak için kullanışlı bir yerdir). install.packagesHer paket için ayrı ayrı çağırmak yerine, kaldırılan paketlerin tüm vektörünü sadece bir kez geçirir.

İşte aynı işlev, ancak kullanıcının eksik paketleri yüklemek isteyip istemediğini soran bir pencere iletişim kutusu ile

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

Shane cevabı projemin biri için, gerçekten iyi olmasına rağmen ben çıkışına mesajları, uyarıları kaldırmak ve paketleri yüklemek için gereken automagicallylar . Sonunda bu komut dosyasını almayı başardım:

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

kullanın:

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)

Rbundler paketinin amacı budur : belirli bir proje için kurulan paketleri kontrol etmek için bir yol sağlamak. Şu anda paket, projenizin dizinine paketleri yüklemek için devtools işlevselliği ile çalışmaktadır. İşlevi Ruby'nin paketleyicisine benzer .

Projeniz bir paketse (önerilen), tek yapmanız gereken rbundler yüklemek ve paketleri paketlemektir. bundleFonksiyon paketin bakacağız DESCRIPTIONpaket için hangi paketleri belirlemek için dosyanın.

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

Şimdi paketler .Rbundle dizinine kurulacaktır.

Projeniz bir paket değilse, DESCRIPTIONyüklenmesini istediğiniz paketleri (isteğe bağlı sürüm bilgileriyle) listeleyen bir Bağımlılar alanı ile projenizin kök dizininde bir dosya oluşturarak sahte yapabilirsiniz :

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

İşte katkıda bulunmak istiyorsanız proje için github repo: rbundler .

Elbette.

'Kurulu paketleri' ile 'istenen paketleri' karşılaştırmanız gerekir. Yeni ve / veya güncellenmiş paketleri belirlemek için 'depolanmış bilinen paketleri' şu anda bilinen paketleri 'karşılaştırmam gerektiğinden , CRANberries ile yaptığım şeye çok yakın .

Yani böyle bir şey yap

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

bilinen tüm paketleri almak için, şu anda yüklü paketler için benzetimli çağrı yapın ve verilen hedef paketlerle karşılaştırın.

Kullan packratpaylaşılan kütüphaneler tam olarak aynı ve diğer çevreyi değiştirmeme, böylece.

Zarafet ve en iyi uygulama açısından, temelde yanlış yolda olduğunuzu düşünüyorum. Paket packratbu sorunlar için tasarlanmıştır. Hadley Wickham tarafından RStudio tarafından geliştirilmiştir. Bağımlılıkları kurmak ve muhtemelen birinin çevre sistemini karıştırmak yerine, packratkendi dizinini kullanır ve programlarınız için tüm bağımlılıkları oraya yükler ve birinin ortamına dokunmaz.

Packrat, R için bir bağımlılık yönetim sistemidir.

R paket bağımlılıkları sinir bozucu olabilir. Hiç kimsenin kodunun çalışması için hangi R paketlerini yüklemeniz gerektiğini denemek için yan yana deneme yanılma yöntemini kullanmak zorunda kaldınız mı? ? Hiç projelerinizden birinde kod almak için bir paketi güncellediniz mi, sadece güncellenmiş paketin başka bir projedeki kodu çalışmayı durdurduğunu bulmak için?

Bu sorunları çözmek için packrat oluşturduk. R projelerinizi daha fazla yapmak için packrat kullanın:

• Yalıtılmış: Bir proje için yeni veya güncellenmiş bir paket yüklemek, diğer projelerinizi bozmaz veya tam tersi. Çünkü packrat her projeye kendi özel paket kütüphanesini veriyor.
• Taşınabilir: Farklı platformlarda bile projelerinizi bir bilgisayardan diğerine kolayca taşıyın. Packrat, projenizin bağlı olduğu paketleri kurmayı kolaylaştırır.
• Tekrarlanabilir: Packrat, bağlı olduğunuz tam paket sürümlerini kaydeder ve bu kesin sürümlerin gittiğiniz her yere yüklenen sürümler olmasını sağlar.

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

Aşağıdaki basit işlev bir cazibe gibi çalışır:

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

(benim değil, bunu bir süre önce web'de buldum ve o zamandan beri kullanıyordum. orijinal kaynaktan emin değilim)

require("<package>")Paket bulunamadı hatasıyla çıkarsa paketi yüklemek için aşağıdaki işlevi kullanıyorum . Eksik paket için hem CRAN hem de Bioiletken depolarını sorgulayacaktır.

Joshua Wiley'in orijinal çalışmasından uyarlanmış, 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)))
  }
}

Misal:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)sistemdeki yüklü tüm paketleri güncelleyecektir. Bu uzun zaman alabilir ve her zaman garanti edilmeyebilecek tam bir R yükseltmesi olarak düşünülebilir!

setdiffYüklü olmayan paketleri almak ve sonra yüklemek için bu işlevi kullanabilirsiniz . Aşağıdaki örnekte, ggplot2ve Rcpppaketlerinin kurulmadan önce kurulu olup olmadığını kontrol ediyoruz .

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

Bir satırda, yukarıdaki gibi yazılabilir:

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

Gerekli R paketlerini sessizce kurma ve yükleme işlevini uyguladım. Umut yardımcı olabilir. İşte kod:

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

Önizleme olarak zaten mevcut olan RStudio'nun (1.2) gelecek sürümü, eksik paketleri library()ve require()çağrıları tespit etmek ve kullanıcıdan bunları yüklemesini istemek için bir özellik içerecektir :

Eksik R paketlerini algılama

Birçok R komut dosyası yürütmek için ihtiyaç duydukları paketleri çağırmak library()ve require()yüklemek için açılır . Yüklemediğiniz paketlere başvuruda bulunan bir R komut dosyasını açarsanız, RStudio artık tüm gerekli paketleri tek bir tıklamayla yüklemeyi önerecektir. install.packages()Hatalar ortadan kalkana kadar tekrar tekrar yazmaya gerek yok !
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Bu OP'nin asıl endişesini özellikle iyi ele alıyor gibi görünüyor:

Birçoğu acemi / orta düzeydeki R kullanıcılarıdır ve zaten sahip olmadıkları paketleri kurmaları gerektiğinin farkında değildir.

"Hedefi olmayan kütüphaneleri kurmak" gibi temel hedefiniz ve "instllaed.packages ()" kullanılmasına bakılmaksızın. Aşağıdaki işlev, orijinal işlev maskesini gerektirir. "X" adlı paketi yüklemeye ve kontrol etmeye çalışır, yüklü değilse doğrudan bağımlılıklar dahil olarak kurun; ve son olarak normal olarak yükleyin. bütünlüğü korumak için işlev adını 'zorunlu' olarak 'kütüphane' olarak yeniden adlandırırsınız. Tek sınırlama paket adlarının alıntılanmasıdır.

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

Böylece yükleyebilir ve yükleyebilirsiniz paketi R eski moda yolu gerektirir ("ggplot2") gerektirir ("Rcpp")

Oldukça basit olan.

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

Kullandığım kişiye katkıda bulunacağımı düşündüm:

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

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

Laponya ailesi ve anonim işlev yaklaşımını kullanarak şunları yapabilirsiniz:

1. Listelenen tüm paketleri eklemeyi deneyin.
2. Yalnızca eksik yükleyin ( ||tembel değerlendirme kullanarak ).
3. Adım 1'de eksik olan ve adım 2'de kurulanları tekrar takmaya çalışın.

4. Her paketin son yükleme durumunu ( TRUE/ FALSE) yazdırın .

   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 

Paketin yüklü olup olmadığını ve bağımlılıkların güncellenip güncellenmediğini kontrol edecek aşağıdakileri kullanıyorum, sonra paketi yükler.

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

İşte bunun için benim kod:

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

Bu, sıralanmamış paket adları ile çalışır ve oldukça zariftir (bkz. GeoObserver cevabı)

Benim durumumda, komut satırından (aslında bir Makefile aracılığıyla) çalıştırabileceğim bir astar istedim. Zaten yüklü değilse "VGAM" ve "feather" i yükleyen bir örnek:

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

R içinden sadece şöyle olurdu:

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

Burada önceki çözümlerin ötesinde hiçbir şey yoktur:

• Tek bir çizgide tutuyorum
• reposParametreyi sabit kodluyorum (kullanılacak ayna hakkında soran pop-up'ları önlemek için)
• Başka bir yerde kullanılacak bir işlevi tanımlamak için zahmet etmiyorum

Ayrıca önemli olanlara dikkat edin character.only=TRUE(onsuz require, paketi yüklemeye çalışır 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)
}

Biraz deliliği paylaşmama izin verin:

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