Елегантний спосіб перевірити відсутні пакети та встановити їх?

Я, здається, цими днями ділиться великим кодом з співавторами. Багато з них є початківцями / проміжними користувачами R і не розуміють, що їм доведеться встановлювати пакети, яких у них ще немає.

Чи є елегантний спосіб зателефонувати installed.packages(), порівняти його з тими, які я завантажую та встановлюю, якщо таких немає?

Так. Якщо у вас є список пакунків, порівняйте його з результатами installed.packages()[,"Package"]та встановіть відсутні пакети. Щось на зразок цього:

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)

Інакше:

Якщо ви помістите свій код в пакет і зробите їх залежними, вони автоматично встановляться при встановленні вашого пакету.

Dason К. і у мене є pacman пакет , який може зробити це красиво. Функція p_loadв пакеті робить це. Перший рядок полягає лише в тому, щоб встановити Pacman.

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

Ви можете просто використовувати повернене значення require:

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

Я використовую libraryпісля встановлення, оскільки він викине виняток, якщо встановлення не вдалося або пакет не вдасться завантажити з якоїсь іншої причини. Ви робите це більш надійним і багаторазовим:

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

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

Мінусом цього методу є те, що вам потрібно передати назву пакета в лапках, що ви не робите для справжнього require.

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

"ggplot2" - пакет. Він перевіряє, чи встановлений пакет, чи не він його встановлює. Потім він завантажує пакет незалежно від того, яку галузь він взяв.

Це рішення займе символьний вектор імен пакунків і спробує завантажити їх або встановити їх, якщо завантаження не вдалося. Він покладається на зворотну поведінку, requireщоб зробити це, тому що ...

require повертає (невидимо) логічне вказівку, чи є необхідний пакет доступним

Тому ми можемо просто побачити, чи змогли ми завантажити необхідний пакет, а якщо ні, встановити його залежно. Отже, заданий векторний символ пакетів, які ви хочете завантажити ...

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

Дуже багато відповідей вище (і на дублікати цього питання) покладаються на те, installed.packagesщо це погана форма. З документації:

Це може бути повільним, коли встановлено тисячі пакетів, тому не використовуйте це, щоб дізнатися, чи встановлений іменований пакет (використовуйте system.file або find.package), а також щоб дізнатись, чи є пакет корисним (вимагайте дзвінка та перевірте прапорець повернути значення), ні знайти деталі невеликої кількості пакунків (використовуйте packageDescription). Потрібно прочитати кілька файлів на встановлений пакет, який буде повільним в Windows та на деяких мережевих файлових системах.

Отже, кращим підходом є спроба завантажити пакет за допомогою requireта встановлення, якщо завантаження не вдасться ( requireповернеться, FALSEякщо його не знайдено). Я віддаю перевагу цій реалізації:

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

які можна використовувати так:

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

Таким чином він завантажує всі пакунки, потім повертається назад і встановлює всі відсутні пакети (що, якщо ви хочете, це зручне місце для вставки підказки, щоб запитати, чи хоче користувач встановити пакунки). Замість виклику install.packagesокремо для кожного пакету він передає весь вектор видалених пакетів лише один раз.

Ось така ж функція, але з діалоговим вікном Windows, яке запитує, чи хоче користувач встановити відсутні пакети

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

Хоча відповідь Шейна справді хороша, для одного з моїх проектів мені потрібно було видалити повідомлення про вихід, попередження та встановити пакети автоматично . Нарешті мені вдалося отримати цей сценарій:

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

Використання:

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 : забезпечити спосіб управління пакетами, встановленими для конкретного проекту. Зараз пакет працює з функцією devtools для встановлення пакетів у каталог вашого проекту. Функціонал аналогічний постачальнику Ruby .

Якщо ваш проект - це пакет (рекомендований), тоді все, що вам потрібно зробити, це завантажити rbundler і зв’язати пакунки. bundleФункція буде виглядати в вашому пакеті DESCRIPTIONфайл , щоб визначити , які пакети для об'єднання.

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

Тепер пакети будуть встановлені в каталозі .Rbundle.

Якщо ваш проект не є пакетом, ви можете підробити його, створивши DESCRIPTIONфайл у кореневій папці вашого проекту із полем залежно, в якому перераховані пакети, які ви хочете встановити (з додатковою інформацією про версію):

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

Ось github repo для проекту, якщо вам цікаво внести участь: rbundler .

Звичайно.

Вам потрібно порівняти "встановлені пакети" з "потрібними пакетами". Це дуже близько до того, що я роблю з CRANberry, оскільки мені потрібно порівняти "збережені відомі пакети" з "відомими в даний час пакетами", щоб визначити нові та / або оновлені пакети.

Тож роби щось подібне

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

щоб отримати всі відомі пакети, синхронний виклик для встановлених поточних пакетів та порівняйте їх із заданим набором цільових пакетів.

Використовуйте packratтак, щоб спільні бібліотеки були абсолютно однаковими і не змінювали оточення інших.

Щодо елегантності та найкращої практики, я думаю, ви принципово йдете про це неправильним шляхом. Пакет packratбув розроблений для цих питань. Він розроблений RStudio Hadley Wickham. Замість того, щоб їм встановити залежності та, можливо, зіпсувати чиюсь оточуючу систему, він packratвикористовує власний каталог та встановлює всі залежності для ваших програм там і не торкається когось оточення.

Packrat - система управління залежностями для Р.

Залежності від R-пакету можуть бути неприємними. Вам коли-небудь доводилося використовувати пробну та помилкову помилку, щоб з'ясувати, які пакети R потрібно встановити, щоб чийсь код працював, а потім залишилися з цими пакетами назавжди встановленими, тому що тепер ви не впевнені, чи потрібні вони ? Ви коли-небудь оновлювали пакет, щоб отримати код в одному з ваших проектів, лише щоб дізнатися, що оновлений пакет перетворює код в інший проект?

Ми створили пакет для вирішення цих проблем. Використовуйте packrat, щоб зробити ваші R проекти більше:

• Ізольовано: Встановлення нового або оновленого пакету для одного проекту не порушить інші ваші проекти, і навпаки. Це тому, що packrat надає кожному проекту власну приватну бібліотеку пакетів.
• Портативний: Легко транспортуйте свої проекти з одного комп’ютера на інший, навіть через різні платформи. Packrat дозволяє легко встановлювати пакети, від яких залежить ваш проект.
• Відтворювальний: Packrat записує точні версії пакету, від яких ви залежите, і гарантує, що саме ці версії будуть встановлені там, де ви йдете.

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

Наступна проста функція працює як шарм:

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

(не моє, знайшов це в Інтернеті деякий час назад і використовував його з тих пір. не впевнений у первинному джерелі)

Я використовую наступну функцію для встановлення пакета, якщо require("<package>")вихід із пакетом не знайдено помилки. Він запитає як CRAN, так і сховища біокондуктора щодо відсутнього пакету.

Адаптовано з оригінальної роботи Джошуа Вілі, 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)))
  }
}

Приклад:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)оновить усі встановлені пакети в системі. Це може зайняти багато часу і розглядати це як повне оновлення R, яке, можливо, не гарантується весь час!

Ви можете просто скористатися setdiffфункцією, щоб отримати пакунки, які не встановлені, а потім встановити їх. У наведеному нижче прикладі ми перевіряємо, чи встановлені пакети ggplot2та Rcppпакети перед їх встановленням.

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

В одному рядку вище можна записати так:

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

Я реалізував функцію безшумно встановлювати та завантажувати необхідні пакети R. Надія може допомогти. Ось код:

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

Наступна версія RStudio (1.2), яка вже доступна у вигляді попереднього перегляду, буде включати в себе функцію виявлення відсутніх пакетів у дзвінках library()та require()викликах та спонукати користувача встановити їх:

Виявити відсутні R-пакети

Багато сценаріїв R відкриваються з дзвінками library()та require()завантаженням необхідних пакетів для виконання. Якщо ви відкриєте скрипт R, на який посилаються пакети, які у вас не встановлені, RStudio запропонує встановити всі необхідні пакети одним натисканням кнопки. Більше не друкуйте install.packages()повторно, поки помилки не зникнуть!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Це, мабуть, особливо добре вирішує проблему первинного заходу:

Багато з них є початківцями / проміжними користувачами R і не розуміють, що їм доведеться встановлювати пакети, яких у них ще немає.

Що стосується вашої основної мети "встановити бібліотеки, яких у них вже немає", і незалежно від використання "instllaed.packages ()". Наступна функція маскує оригінальну функцію Requ. Він намагається завантажити та перевірити названий пакет "x", якщо він не встановлений, встановити його безпосередньо, включаючи залежності; і нарешті завантажуйте його нормально. ви перейменовуєте назву функції з "вимагати" в "бібліотеку", щоб зберегти цілісність. Єдине обмеження - це котирування назв пакетів.

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

Таким чином, ви можете завантажити та встановити пакет старим способом R. вимагати ("ggplot2") вимагати ("Rcpp")

Досить базовий.

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

Думав, я б сприяв тому, кого я використовую:

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

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

Використовуючи підхід сімейства ламп та анонімних функцій, ви можете:

1. Спробуйте долучити всі перелічені пакети.
2. Встановити лише відсутні (за допомогою ||ледачих оцінок).
3. Спроба приєднати знову ті, які були відсутні на кроці 1 та встановлені на кроці 2.

4. Роздрукуйте кінцевий стан завантаження кожного пакету ( 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 

Я використовую наступне, яке перевірить, чи встановлено пакет, і чи залежать оновлення залежностей, а потім завантажує пакунок.

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

Ось мій код для цього:

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

Це працює з котируваними назвами пакетів і є досить елегантним (пор. Відповідь GeoObserver)

У моєму випадку я хотів одного вкладиша, який я міг би запустити з командного рядка (фактично через Makefile). Ось приклад встановлення "VGAM" і "перо", якщо вони ще не встановлені:

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 це було б просто:

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

Тут немає нічого, крім попередніх рішень:

• Я тримаю його до єдиного рядка
• Я жорстко кодую repos параметр (щоб уникнути появи спливаючих вікон про дзеркало)
• Я не намагаюся визначати функцію, яку слід використовувати в іншому місці

Також зауважте важливе значення character.only=TRUE(без цього requireнамагайтеся завантажити пакет 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)
}

Дозвольте мені поділитися трохи божевілля:

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