sirven - Actualizar un paquete R específico y sus dependencias

r paquetes instalados

Question

Tengo alrededor de 4000 paquetes R instalados en mi sistema (un servidor) y la mayoría de ellos están desactualizados porque fueron creados antes de R-3.0.0. Ahora sé

update.packages(checkBuilt=TRUE, ask=FALSE)

actualizaría todos mis paquetes pero eso es demasiado lento. La cosa es que los usuarios no usan la mayoría de los paquetes y de vez en cuando me piden que actualice un paquete (por ejemplo, campos) que usarían. Ahora si corro

install.packages("fields")

solo actualizaría los campos del paquete, pero no los mapas del paquete, incluso si los campos dependen de los mapas. Así cuando intento cargar los campos del paquete:

library("fields")

Me aparece un mensaje de error

Error: package ‘maps’ was built before R 3.0.0: please re-install it

¿Hay alguna forma de actualizar los campos para que también actualice automáticamente los campos de los paquetes?

Answer 1

Como Ben indicó en su comentario, debe obtener las dependencias para los fields , luego filtrar los paquetes con Prioridad "Base" o "Recommended" , y luego pasar esa lista de paquetes a install.packages() para tratar la instalación. Algo como:

instPkgPlusDeps <- function(pkg, install = FALSE,
which = c("Depends", "Imports", "LinkingTo"),
inc.pkg = TRUE) {
stopifnot(require("tools")) ## load tools
ap <- available.packages() ## takes a minute on first use
## get dependencies for pkg recursively through all dependencies
deps <- package_dependencies(pkg, db = ap, which = which, recursive = TRUE)
## the next line can generate warnings; I think these are harmless
## returns the Priority field. `NA` indicates not Base or Recommended
pri <- sapply(deps[[1]], packageDescription, fields = "Priority")
## filter out Base & Recommended pkgs - we want the `NA` entries
deps <- deps[[1]][is.na(pri)]
## install pkg too?
if (inc.pkg) {
deps = c(pkg, deps)
}
## are we installing?
if (install) {
install.packages(deps)
}
deps ## return dependencies
}

Esto da:

R> instPkgPlusDeps("fields")
Loading required package: tools
[1] "fields" "spam" "maps"

que coincide con

> packageDescription("fields", fields = "Depends")
[1] "R (>= 2.13), methods, spam, maps"

Obtendrá advertencias de la línea sapply() si una dependencia en deps no está realmente instalada. Creo que estos son inofensivos ya que el valor devuelto en ese caso es NA y lo usamos para indicar los paquetes que queremos instalar. Dudo que te afecte si tienes 4000 paquetes instalados.

El valor predeterminado es no instalar paquetes, sino simplemente devolver la lista de dependencias. Pensé que esto era lo más seguro, ya que es posible que no se dé cuenta de la cadena de dependencias implícitas y termine de instalar cientos de paquetes accidentalmente. Pase in install = TRUE si está dispuesto a instalar los paquetes indicados.

Tenga en cuenta que restrinjo los tipos de dependencias buscadas (el globo de las cosas si utiliza el campo which = "most" ) tiene más de 300 dependencias de este tipo una vez que resuelve recursivamente esas dependencias (que también incluyen los campos Suggests: . which = "all" buscará todo, incluyendo Enhances: que será una lista más grande de paquetes nuevamente. Vea ?tools::package_dependencies para entradas válidas para el argumento which .

Answer 2

Mi respuesta se basa en la respuesta de Gavin ... Tenga en cuenta que el póster original, user3175783, solicitó una versión más inteligente de update.packages() . Esa función omite la instalación de paquetes que ya están actualizados. Pero la solución de Gavin instala un paquete y todas sus dependencias, estén actualizadas o no. Utilicé la punta de Gavin de omitir paquetes base (que en realidad no son instalables), y codifiqué una solución que también omite paquetes actualizados.

La función principal es installPackages() . Esta función y sus ayudantes realizan una ordenación topológica del árbol de dependencias enraizado en un conjunto dado de paquetes. Los paquetes en la lista resultante se comprueban para comprobar su estabilidad y se instalan uno por uno. Aquí hay un ejemplo de salida:

> remove.packages("tibble")
Removing package from ‘/home/frederik/.local/lib/x86_64/R/packages’
(as ‘lib’ is unspecified)
> installPackages(c("ggplot2","stringr","Rcpp"), dry_run=T)
## Package digest is out of date ( 0.6.9 < 0.6.10 )
Would have installed package digest
## Package gtable is up to date ( 0.2.0 )
## Package MASS is up to date ( 7.3.45 )
## Package Rcpp is out of date ( 0.12.5 < 0.12.8 )
Would have installed package Rcpp
## Package plyr is out of date ( 1.8.3 < 1.8.4 )
Would have installed package plyr
## Package stringi is out of date ( 1.0.1 < 1.1.2 )
Would have installed package stringi
## Package magrittr is up to date ( 1.5 )
## Package stringr is out of date ( 1.0.0 < 1.1.0 )
Would have installed package stringr
...
## Package lazyeval is out of date ( 0.1.10 < 0.2.0 )
Would have installed package lazyeval
## Package tibble is not currently installed, installing
Would have installed package tibble
## Package ggplot2 is out of date ( 2.1.0 < 2.2.0 )
Would have installed package ggplot2

Aquí está el código, perdón por la longitud:

library(tools)
# Helper: a "functional" interface depth-first-search
fdfs = function(get.children) {
rec = function(root) {
cs = get.children(root);
out = c();
for(c in cs) {
l = rec(c);
out = c(out, setdiff(l, out));
}
c(out, root);
}
rec
}
# Entries in the package "Priority" field which indicate the
# package can''t be upgraded. Not sure why we would exclude
# recommended packages, since they can be upgraded...
#excl_prio = c("base","recommended")
excl_prio = c("base")
# Find the non-"base" dependencies of a package.
nonBaseDeps = function(packages,
ap=available.packages(),
ip=installed.packages(), recursive=T) {
stopifnot(is.character(packages));
all_deps = c();
for(p in packages) {
# Get package dependencies. Note we are ignoring version
# information
deps = package_dependencies(p, db = ap, recursive = recursive)[[1]];
ipdeps = match(deps,ip[,"Package"])
# We want dependencies which are either not installed, or not part
# of Base (e.g. not installed with R)
deps = deps[is.na(ipdeps) | !(ip[ipdeps,"Priority"] %in% excl_prio)];
# Now check that these are in the "available.packages()" database
apdeps = match(deps,ap[,"Package"])
notfound = is.na(apdeps)
if(any(notfound)) {
notfound=deps[notfound]
stop("Package ",p," has dependencies not in database: ",paste(notfound,collapse=" "));
}
all_deps = union(deps,all_deps);
}
all_deps
}
# Return a topologically-sorted list of dependencies for a given list
# of packages. The output vector contains the "packages" argument, and
# recursive dependencies, with each dependency occurring before any
# package depending on it.
packageOrderedDeps = function(packages, ap=available.packages()) {
# get ordered dependencies
odeps = sapply(packages,
fdfs(function(p){nonBaseDeps(p,ap=ap,recursive=F)}))
# "unique" preserves the order of its input
odeps = unique(unlist(odeps));
# sanity checks
stopifnot(length(setdiff(packages,odeps))==0);
seen = list();
for(d in odeps) {
ddeps = nonBaseDeps(d,ap=ap,recursive=F)
stopifnot(all(ddeps %in% seen));
seen = c(seen,d);
}
as.vector(odeps)
}
# Checks if a package is up-to-date.
isPackageCurrent = function(p,
ap=available.packages(),
ip=installed.packages(),
verbose=T) {
if(verbose) msg = function(...) cat("## ",...)
else msg = function(...) NULL;
aprow = match(p, ap[,"Package"]);
iprow = match(p, ip[,"Package"]);
if(!is.na(iprow) && (ip[iprow,"Priority"] %in% excl_prio)) {
msg("Package ",p," is a ",ip[iprow,"Priority"]," package/n");
return(T);
}
if(is.na(aprow)) {
stop("Couldn''t find package ",p," among available packages");
}
if(is.na(iprow)) {
msg("Package ",p," is not currently installed, installing/n");
F;
} else {
iv = package_version(ip[iprow,"Version"]);
av = package_version(ap[aprow,"Version"]);
if(iv < av) {
msg("Package ",p," is out of date (",
as.character(iv),"<",as.character(av),")/n");
F;
} else {
msg("Package ",p," is up to date (",
as.character(iv),")/n");
T;
}
}
}
# Like install.packages, but skips packages which are already
# up-to-date. Specify dry_run=T to just see what would be done.
installPackages =
function(packages,
ap=available.packages(), dry_run=F,
want_deps=T) {
stopifnot(is.character(packages));
ap=tools:::.remove_stale_dups(ap)
ip=installed.packages();
ip=tools:::.remove_stale_dups(ip)
if(want_deps) {
packages = packageOrderedDeps(packages, ap);
}
for(p in packages) {
curr = isPackageCurrent(p,ap,ip);
if(!curr) {
if(dry_run) {
cat("Would have installed package ",p,"/n");
} else {
install.packages(p,dependencies=F);
}
}
}
}
# Convenience function to make sure all the libraries we have loaded
# in the current R session are up-to-date (and to update them if they
# are not)
updateAttachedLibraries = function(dry_run=F) {
s=search();
s=s[grep("^package:",s)];
s=gsub("^package:","",s)
installPackages(s,dry_run=dry_run);
}