Determinar la ruta del script de ejecución

Tengo un script llamado foo.Rque incluye otro script other.R, que está en el mismo directorio:

#!/usr/bin/env Rscript
message("Hello")
source("other.R")

Pero quiero Rencontrar eso other.Rsin importar el directorio de trabajo actual.

En otras palabras, foo.Rnecesita conocer su propio camino. ¿Cómo puedo hacer eso?

Aquí hay una solución simple para el problema. Este comando:

script.dir <- dirname(sys.frame(1)$ofile)

devuelve la ruta del archivo de script actual. Funciona después de que se guardó el guión.

Puede utilizar la commandArgsfunción para obtener todas las opciones que Rscript pasó al intérprete R real y buscarlas.--file= . Si su script se inició desde la ruta o si se inició con una ruta completa, lo script.namesiguiente comenzará con un '/'. De lo contrario, debe ser relativo al cwdy puede concatenar las dos rutas para obtener la ruta completa.

Editar: parece que solo necesitarías lo script.nameanterior y quitar el componente final de la ruta. Eliminé la cwd()muestra innecesaria, limpié el script principal y publiqué miother.R . Simplemente guarde este script y el other.Rscript en el mismo directorio chmod +x, y ejecute el script principal.

main.R :

#!/usr/bin/env Rscript
initial.options <- commandArgs(trailingOnly = FALSE)
file.arg.name <- "--file="
script.name <- sub(file.arg.name, "", initial.options[grep(file.arg.name, initial.options)])
script.basename <- dirname(script.name)
other.name <- file.path(script.basename, "other.R")
print(paste("Sourcing",other.name,"from",script.name))
source(other.name)

otro.R :

print("hello")

salida :

burner@firefighter:~$ main.R
[1] "Sourcing /home/burner/bin/other.R from /home/burner/bin/main.R"
[1] "hello"
burner@firefighter:~$ bin/main.R
[1] "Sourcing bin/other.R from bin/main.R"
[1] "hello"
burner@firefighter:~$ cd bin
burner@firefighter:~/bin$ main.R
[1] "Sourcing ./other.R from ./main.R"
[1] "hello"

Esto es lo que creo que Dehmann está buscando.

No pude lograr que la solución Suppressingfire funcionara cuando 'fuente' desde la consola R.
No pude conseguir que la solución de Hadley funcionara al usar Rscript.

¿Lo mejor de ambos mundos?

thisFile <- function() {
        cmdArgs <- commandArgs(trailingOnly = FALSE)
        needle <- "--file="
        match <- grep(needle, cmdArgs)
        if (length(match) > 0) {
                # Rscript
                return(normalizePath(sub(needle, "", cmdArgs[match])))
        } else {
                # 'source'd via R console
                return(normalizePath(sys.frames()[[1]]$ofile))
        }
}

frame_files <- lapply(sys.frames(), function(x) x$ofile)
frame_files <- Filter(Negate(is.null), frame_files)
PATH <- dirname(frame_files[[length(frame_files)]])

Sin embargo, no me preguntes cómo funciona, porque he olvidado: /

Esto funciona para mi

library(rstudioapi)    
rstudioapi::getActiveDocumentContext()$path

La respuesta de rakensi de Getting path of a R script es la IMHO más correcta y realmente brillante. Sin embargo, sigue siendo un truco que incorpora una función ficticia. Lo estoy citando aquí, para que otros lo encuentren más fácilmente.

sourceDir <- getSrcDirectory (function (dummy) {dummy})

Esto proporciona el directorio del archivo donde se colocó la instrucción (donde se define la función ficticia). Luego se puede usar para establecer el directorio de trabajo y usar rutas relativas, por ejemplo

setwd(sourceDir)
source("other.R")

o para crear caminos absolutos

 source(paste(sourceDir, "/other.R", sep=""))

Mi todo en uno! (--01 / 09/2019 actualizado para tratar con RStudio Console)

#' current script file (in full path)
#' @description current script file (in full path)
#' @examples
#' works with Rscript, source() or in RStudio Run selection, RStudio Console
#' @export
ez.csf <- function() {
    # http://stackoverflow.com/a/32016824/2292993
    cmdArgs = commandArgs(trailingOnly = FALSE)
    needle = "--file="
    match = grep(needle, cmdArgs)
    if (length(match) > 0) {
        # Rscript via command line
        return(normalizePath(sub(needle, "", cmdArgs[match])))
    } else {
        ls_vars = ls(sys.frames()[[1]])
        if ("fileName" %in% ls_vars) {
            # Source'd via RStudio
            return(normalizePath(sys.frames()[[1]]$fileName))
        } else {
            if (!is.null(sys.frames()[[1]]$ofile)) {
            # Source'd via R console
            return(normalizePath(sys.frames()[[1]]$ofile))
            } else {
                # RStudio Run Selection
                # http://stackoverflow.com/a/35842176/2292993
                pth = rstudioapi::getActiveDocumentContext()$path
                if (pth!='') {
                    return(normalizePath(pth))
                } else {
                    # RStudio Console
                    tryCatch({
                            pth = rstudioapi::getSourceEditorContext()$path
                            pth = normalizePath(pth)
                        }, error = function(e) {
                            # normalizePath('') issues warning/error
                            pth = ''
                        }
                    )
                    return(pth)
                }
            }
        }
    }
}

Una variante reducida de la respuesta de Supressingfire:

source_local <- function(fname){
    argv <- commandArgs(trailingOnly = FALSE)
    base_dir <- dirname(substring(argv[grep("--file=", argv)], 8))
    source(paste(base_dir, fname, sep="/"))
}

Esto funciona para mi. Simplemente lo saca de los argumentos de la línea de comando, elimina el texto no deseado, hace un nombre de directorio y finalmente obtiene la ruta completa de eso:

args <- commandArgs(trailingOnly = F)  
scriptPath <- normalizePath(dirname(sub("^--file=", "", args[grep("^--file=", args)])))

He terminado y extendido las respuestas a esta pregunta en una nueva función thisfile()en rprojroot . También funciona para tejer con knitr.

Me gustó la solución de steamer25, ya que parece la más robusta para mis propósitos. Sin embargo, al depurar en RStudio (en Windows), la ruta no se configuraría correctamente. La razón es que si se establece un punto de interrupción en RStudio, el origen del archivo utiliza un comando alternativo de "fuente de depuración" que establece la ruta del script de forma un poco diferente. Aquí está la versión final que estoy usando actualmente que explica este comportamiento alternativo dentro de RStudio al depurar:

# @return full path to this script
get_script_path <- function() {
    cmdArgs = commandArgs(trailingOnly = FALSE)
    needle = "--file="
    match = grep(needle, cmdArgs)
    if (length(match) > 0) {
        # Rscript
        return(normalizePath(sub(needle, "", cmdArgs[match])))
    } else {
        ls_vars = ls(sys.frames()[[1]])
        if ("fileName" %in% ls_vars) {
            # Source'd via RStudio
            return(normalizePath(sys.frames()[[1]]$fileName)) 
        } else {
            # Source'd via R console
            return(normalizePath(sys.frames()[[1]]$ofile))
        }
    }
}

Intenté casi todo desde esta pregunta, Obtener la ruta de un script R , Obtener la ruta del script actual , Buscar la ubicación del archivo .R actual y el comando R para configurar el directorio de trabajo en la ubicación del archivo fuente en Rstudio , pero al final me encontré manualmente hojeando la tabla CRAN y encontrado

scriptName biblioteca

que proporciona la current_filename()función, que devuelve la ruta completa adecuada del script cuando se obtiene en RStudio y también cuando se invoca a través de R o RScript ejecutable.

También tuve este problema, y ​​ninguna de las soluciones anteriores funcionó para mí. Quizás con elsource eso o cosas así, pero no estaba lo suficientemente claro.

Encontré esta solución, para mí elegante:

paste0(gsub("\\", "/", fileSnapshot()$path, fixed=TRUE),"/")

Lo importante es fileSnapshot()que le brinda mucha información sobre un archivo. Devuelve una lista de 8 elementos. Cuando elige pathcomo elemento de la lista, la ruta se devuelve con un \\separador, por lo que el resto del código es solo para cambiar eso.

Espero que esto ayude.

Puede ajustar el script r en un script bash y recuperar la ruta del script como una variable bash de la siguiente manera:

#!/bin/bash
     # [environment variables can be set here]
     path_to_script=$(dirname $0)

     R --slave<<EOF
        source("$path_to_script/other.R")

     EOF

Me gusta este enfoque:

this.file <- sys.frame(tail(grep('source',sys.calls()),n=1))$ofile
this.dir <- dirname(this.file)

Acabo de resolver esto yo mismo. Para garantizar la portabilidad de su script, comience siempre con:

wd <- setwd(".")
setwd(wd)

Funciona porque "." se traduce como el comando Unix $ PWD. Asignar esta cadena a un objeto de caracteres le permite insertar ese objeto de caracteres en setwd () y Presto su código siempre se ejecutará con su directorio actual como directorio de trabajo, sin importar en qué máquina se encuentre o en qué parte de la estructura de archivos se encuentre. situado. (Bonificación adicional: el objeto wd se puede usar con file.path () (es decir, file.path (wd, "output_directory") para permitir la creación de un directorio de salida estándar independientemente de la ruta del archivo que conduce a su directorio nombrado. Esto requiere que cree el nuevo directorio antes de hacer referencia a él de esta manera, pero eso también se puede ayudar con el objeto wd.

Alternativamente, el siguiente código realiza exactamente lo mismo:

wd <- getwd()
setwd(wd)

o, si no necesita la ruta del archivo en un objeto, simplemente puede:

setwd(".")

Tenga en cuenta que el paquete getopt proporciona la get_Rscript_filenamefunción, que solo usa la misma solución presentada aquí, pero ya está escrita para usted en un módulo R estándar, por lo que no tiene que copiar y pegar la función "get script path" en cada script usted escribe.

Consulte findSourceTraceback()el paquete R.utils , que

Encuentra todos los objetos 'srcfile' generados por source () en todos los marcos de llamadas. Esto hace posible averiguar qué archivos están actualmente programados por source ().

Tuve problemas con las implementaciones anteriores, ya que mi script se maneja desde un directorio con enlaces simbólicos, o al menos por eso creo que las soluciones anteriores no funcionaron para mí. En la línea de la respuesta de @ennuikiller, envolví mi Rscript en bash. Establezco la variable de ruta usando pwd -P, que resuelve las estructuras de directorios enlazados. Luego pase el camino hacia el Rscript.

Bash.sh

#!/bin/bash

# set path variable
path=`pwd -P`

#Run Rscript with path argument
Rscript foo.R $path

foo.R

args <- commandArgs(trailingOnly=TRUE)
setwd(args[1])
source(other.R)

Usaría una variante del enfoque de @ steamer25. El punto es que prefiero obtener el último script de origen incluso cuando mi sesión se inició a través de Rscript. El siguiente fragmento, cuando se incluye en un archivo, proporcionará una variable que thisScriptcontiene la ruta normalizada del script. Confieso el uso (ab) de la fuente, por lo que a veces invoco Rscript y el script proporcionado en el --fileargumento genera otro script que genera otro ... Algún día invertiré para hacer que mi código desordenado se convierta en un paquete.

thisScript <- (function() {
  lastScriptSourced <- tail(unlist(lapply(sys.frames(), function(env) env$ofile)), 1)

  if (is.null(lastScriptSourced)) {
    # No script sourced, checking invocation through Rscript
    cmdArgs <- commandArgs(trailingOnly = FALSE)
    needle <- "--file="
    match <- grep(needle, cmdArgs)
    if (length(match) > 0) {
      return(normalizePath(sub(needle, "", cmdArgs[match]), winslash=.Platform$file.sep, mustWork=TRUE))
    }
  } else {
    # 'source'd via R console
    return(normalizePath(lastScriptSourced, winslash=.Platform$file.sep, mustWork=TRUE))
  }
})()

El 99% de los casos que podrías usar simplemente:

sys.calls()[[1]] [[2]]

No funcionará para las llamadas de locos en el que el guión no es el primer argumento, es decir, source(some args, file="myscript"). Use @ hadley en estos casos elegantes.

El enfoque de Steamer25 funciona, pero solo si no hay espacios en blanco en el camino. En macOS, al menos, cmdArgs[match]devuelve algo así como /base/some~+~dir~+~with~+~whitespace/para /base/some\ dir\ with\ whitespace/.

Trabajé alrededor de esto reemplazando el "~ + ~" con un espacio en blanco simple antes de devolverlo.

thisFile <- function() {
  cmdArgs <- commandArgs(trailingOnly = FALSE)
  needle <- "--file="
  match <- grep(needle, cmdArgs)
  if (length(match) > 0) {
    # Rscript
    path <- cmdArgs[match]
    path <- gsub("\\~\\+\\~", " ", path)
    return(normalizePath(sub(needle, "", path)))
  } else {
    # 'source'd via R console
    return(normalizePath(sys.frames()[[1]]$ofile))
  }
}

Obviamente, aún puede extender el bloque else como lo hizo aprstar.

Si en lugar de la secuencia de comandos, foo.Rconociendo su ubicación de ruta, si puede cambiar su código para que siempre haga referencia a todas sourcelas rutas 'd desde un comúnroot , estas pueden ser de gran ayuda:

• https://github.com/r-lib/rprojroot o https://rprojroot.r-lib.org/
• https://here.r-lib.org/

Dado

• /app/deeply/nested/foo.R
• /app/other.R

Esto funcionará

#!/usr/bin/env Rscript
library(here)
source(here("other.R"))

Consulte https://rprojroot.r-lib.org/ para saber cómo definir las raíces del proyecto.

#!/usr/bin/env Rscript
print("Hello")

# sad workaround but works :(
programDir <- dirname(sys.frame(1)$ofile)
source(paste(programDir,"other.R",sep='/'))
source(paste(programDir,"other-than-other.R",sep='/'))

¡Es increíble que no haya una estructura tipo '$ 0' en R! Puede hacerlo con una llamada system () a un script bash escrito en R:

write.table(c("readlink -e $0"), file="scriptpath.sh",col=F, row=F, quote=F)
thisscript <- system("sh scriptpath.sh", intern = TRUE)

Luego solo divide el nombre scriptpath.sh para otro.

splitstr <- rev(strsplit(thisscript, "\\/")[[1]])
otherscript <- paste0(paste(rev(splitstr[2:length(splitstr)]),collapse="/"),"/other.R")

Al observar la pila de llamadas, podemos obtener la ruta de archivo de cada script que se está ejecutando, los dos más útiles probablemente serán el script que se está ejecutando actualmente o el primer script que se obtendrá (entrada).

script.dir.executing = (function() return( if(length(sys.parents())==1) getwd() else dirname( Filter(is.character,lapply(rev(sys.frames()),function(x) x$ofile))[[1]] ) ))()

script.dir.entry = (function() return( if(length(sys.parents())==1) getwd() else dirname(sys.frame(1)$ofile) ))()