Determinar o caminho do script em execução

Eu tenho um script chamado foo.Rque inclui outro script other.R, que está no mesmo diretório:

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

Mas quero Rdescobrir que, other.Rindependentemente do diretório de trabalho atual.

Em outras palavras, foo.Rprecisa conhecer seu próprio caminho. Como eu posso fazer isso?

Aqui há uma solução simples para o problema. Este comando:

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

retorna o caminho do arquivo de script atual. Funciona depois que o script foi salvo.

Você pode usar a commandArgsfunção para obter todas as opções que foram passadas pelo Rscript para o intérprete R real e procurá-las --file=. Se seu script foi iniciado a partir do caminho ou se foi iniciado com um caminho completo, o script.nameabaixo começará com a '/'. Caso contrário, ele deve ser relativo ao cwde você pode concaturar os dois caminhos para obter o caminho completo.

Editar: parece que você precisaria apenas do item script.nameacima e retira o componente final do caminho. Eu removi a cwd()amostra desnecessária, limpei o script principal e postei o meu other.R. Apenas salve esse script e o other.Rscript no mesmo diretório chmod +x, e execute o 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)

outro.R :

print("hello")

saída :

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"

É isso que acredito que dehmann está procurando.

Eu não conseguia que a solução do Suppressingfire funcionasse quando 'originava' do console R.
Não consegui que a solução da hadley funcionasse ao usar o Rscript.

Melhor dos dois 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)]])

Não me pergunte como funciona, porque eu esqueci: /

Isso funciona para mim

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

A resposta de rakensi de Como localizar um script R é o IMHO mais correto e realmente brilhante. No entanto, ainda é um hack incorporando uma função fictícia. Estou citando aqui, para que seja mais fácil encontrar outras pessoas.

sourceDir <- getSrcDirectory (função (dummy) {dummy})

Isso fornece o diretório do arquivo onde a instrução foi colocada (onde a função fictícia está definida). Em seguida, ele pode ser usado para definir o diretório de trabalho e usar caminhos relativos, por exemplo

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

ou para criar caminhos absolutos

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

Meu tudo em um! (- 01/09/2019 atualizado para lidar com o console RStudio)

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

Uma variante reduzida da resposta do Supressingfire:

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

Isso funciona para mim. Apenas o apaga dos argumentos da linha de comando, retira o texto indesejado, cria um nome de diretório e, finalmente, obtém o caminho completo disso:

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

Eu encerrei e estendi as respostas para esta pergunta em uma nova função thisfile()no rprojroot . Também funciona para tricô knitr.

Gostei da solução do steamer25, pois parece a mais robusta para meus propósitos. No entanto, ao depurar no RStudio (no Windows), o caminho não seria definido corretamente. A razão é que, se um ponto de interrupção for definido no RStudio, a fonte do arquivo usará um comando "debug source" alternativo, que define o caminho do script de maneira um pouco diferente. Aqui está a versão final que estou usando no momento e que explica esse comportamento alternativo no RStudio ao 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))
        }
    }
}

Eu tentei quase tudo nesta questão, Obtendo o caminho de um script R , Obter o caminho do script atual , Encontrar o local do arquivo .R atual e o comando R para definir o diretório de trabalho no local do arquivo de origem no Rstudio , mas no final me encontrei manualmente navegando na tabela CRAN e encontrado

scriptName biblioteca

que fornece a current_filename()função, que retorna o caminho completo adequado do script ao buscar no RStudio e também ao chamar via executável R ou RScript.

Eu também tive esse problema e nenhuma das soluções acima funcionou para mim. Talvez com osource ou coisas assim, mas não estava claro o suficiente.

Achei isso, para mim, solução elegante:

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

O importante é fileSnapshot()que você fornece muitas informações sobre um arquivo. Retorna uma lista de 8 elementos. Quando você escolhe pathcomo o elemento da lista, o caminho é retornado com\\ como separador; portanto, o restante do código é apenas para alterar isso.

Eu espero que isso ajude.

Você pode agrupar o script r em um script bash e recuperar o caminho do script como uma variável bash da seguinte forma:

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

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

     EOF

Eu gosto desta abordagem:

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

Eu mesmo resolvi isso sozinho. Para garantir a portabilidade do seu script, inicie-o sempre com:

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

Funciona porque "." traduz como o comando Unix $ PWD. Atribuir essa sequência a um objeto de caractere permite inserir esse objeto de caractere em setwd () e Presto seu código sempre será executado com o diretório atual como diretório de trabalho, independentemente da máquina em que está ou na estrutura do arquivo. localizado. (Bônus extra: o objeto wd pode ser usado com file.path () (ou seja, file.path (wd, "output_directory") para permitir a criação de um diretório de saída padrão, independentemente do caminho do arquivo que leva ao diretório nomeado. Isso exige que você crie o novo diretório antes de referenciá-lo dessa maneira, mas que também pode ser auxiliado com o objeto wd.

Como alternativa, o código a seguir executa exatamente a mesma coisa:

wd <- getwd()
setwd(wd)

ou, se você não precisar do caminho do arquivo em um objeto, pode simplesmente:

setwd(".")

Observe que o pacote getopt fornece a get_Rscript_filenamefunção, que apenas usa a mesma solução apresentada aqui, mas já está escrita para você em um módulo R padrão, portanto, você não precisa copiar e colar a função "get script path" em todos os scripts você escreve.

Veja findSourceTraceback()o pacote R.utils , que

Localiza todos os objetos 'srcfile' gerados pela origem () em todos os quadros de chamada. Isso torna possível descobrir quais arquivos estão atualmente em script por source ().

Eu tive problemas com as implementações acima, pois meu script é operado a partir de um diretório com link simbólico, ou pelo menos é por isso que acho que as soluções acima não funcionaram para mim. Na linha da resposta do @ ennuikiller, envolvi meu Rscript no bash. Defino a variável de caminho usando pwd -P, que resolve as estruturas de diretório com links simbólicos. Em seguida, passe o caminho para o 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)

Eu usaria uma variante da abordagem do @ steamer25. O ponto é que eu prefiro obter o último script de origem, mesmo quando minha sessão foi iniciada pelo Rscript. O seguinte snippet, quando incluído em um arquivo, fornecerá uma variável que thisScriptcontém o caminho normalizado do script. Confesso o (ab) uso de source'ing, então, às vezes, invoco o Rscript e o script fornecido no --fileargumento origina outro script que origina outro ... Algum dia eu investirei para transformar meu código confuso em um pacote.

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

99% dos casos você pode simplesmente usar:

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

Não funcionará para chamadas malucas onde o script não é o primeiro argumento, ou seja source(some args, file="myscript"),. Use @ hadley's nesses casos sofisticados.

A abordagem do Steamer25 funciona, mas apenas se não houver espaço em branco no caminho. No macOS, pelo menos, os cmdArgs[match]retornos são parecidos /base/some~+~dir~+~with~+~whitespace/com /base/some\ dir\ with\ whitespace/.

Eu resolvi isso substituindo o "~ + ~" por um espaço em branco simples antes de devolvê-lo.

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, você ainda pode estender o bloco else como o aprstar fez.

Se, em vez do script, foo.Rconhecendo a localização do caminho, se você puder alterar seu código para sempre fazer referência a todos sourceos caminhos de um comum root, pode ser uma grande ajuda:

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

Dado

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

Isso vai funcionar

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

Veja https://rprojroot.r-lib.org/ para saber como definir as raízes do projeto.

#!/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='/'))

Incrível, não existe uma estrutura do tipo '$ 0' no R! Você pode fazer isso com uma chamada system () para um script bash escrito em R:

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

Em seguida, apenas divida o nome scriptpath.sh para other.R

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

Observando a pilha de chamadas, podemos obter o caminho do arquivo de cada script sendo executado, os dois mais úteis provavelmente serão o script atualmente em execução ou o primeiro script a ser originado (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) ))()