Determina il percorso dello script in esecuzione

Ho uno script chiamato foo.Rche include un altro script other.R, che si trova nella stessa directory:

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

Ma voglio Rscoprire che other.Rnon importa quale sia l'attuale directory di lavoro.

In altre parole, foo.Rdeve conoscere il proprio percorso. Come lo posso fare?

Qui c'è una soluzione semplice per il problema. Questo comando:

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

restituisce il percorso del file di script corrente. Funziona dopo che lo script è stato salvato.

È possibile utilizzare la commandArgsfunzione per ottenere tutte le opzioni che sono state passate da Rscript all'interprete R attuale e cercarle --file=. Se lo script è stato avviato dal percorso o se è stato avviato con un percorso completo, il script.nameseguito inizierà con a '/'. Altrimenti, deve essere relativo alcwd e puoi concatenare i due percorsi per ottenere il percorso completo.

Modifica: sembra che avresti solo bisogno di quanto script.namesopra e di eliminare il componente finale del percorso. Ho rimosso il cwd()campione non necessario, ripulito lo script principale e pubblicato il mio other.R. Basta salvare questo script e lo other.Rscript nella stessa directory chmod +x, ed esegui lo script principale.

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)

altro.R :

print("hello")

uscita :

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"

Questo è ciò che credo dehmann stia cercando.

Non riuscivo a far funzionare la soluzione di Suppressingfire durante il "source" dalla console R.
Non riuscivo a far funzionare la soluzione di Hadley quando usavo Rscript.

Il meglio di entrambi i mondi?

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

Non chiedermi come funziona, perché ho dimenticato: /

Questo funziona per me

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

La risposta di rakensi da Ottenere il percorso di uno script R è l'IMHO più corretto e davvero brillante. Tuttavia, è ancora un trucco che incorpora una funzione fittizia. Lo sto citando qui, per farlo trovare più facilmente da altri.

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

Ciò fornisce la directory del file in cui è stata posizionata l'istruzione (in cui è definita la funzione fittizia). Può quindi essere utilizzato per impostare la directory di lavoro e utilizzare percorsi relativi, ad es

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

o per creare percorsi assoluti

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

Il mio tutto in uno! (--01 / 09/2019 aggiornato per gestire 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 ridotta della risposta di Supressingfire:

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

Questo funziona per me. Basta estrarlo dagli argomenti della riga di comando, rimuovere il testo indesiderato, fare un dirname e finalmente ottenere il percorso completo da quello:

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

Ho racchiuso ed esteso le risposte a questa domanda in una nuova funzione thisfile()in rprojroot . Funziona anche con la maglia knitr.

Mi è piaciuta la soluzione di steamer25 in quanto sembra la più robusta per i miei scopi. Tuttavia, durante il debug in RStudio (in Windows), il percorso non verrebbe impostato correttamente. Il motivo è che se un punto di interruzione è impostato in RStudio, l'approvvigionamento del file utilizza un comando "debug source" alternativo che imposta il percorso dello script in modo leggermente diverso. Ecco la versione finale che sto attualmente utilizzando, che tiene conto di questo comportamento alternativo all'interno di RStudio durante il debug:

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

Ho provato quasi tutto da questa domanda, Ottenere il percorso di uno script R , Ottenere il percorso dello script corrente , Trovare la posizione del file .R corrente e il comando R per impostare la directory di lavoro sulla posizione del file di origine in Rstudio , ma alla fine mi sono trovato manualmente sfogliando la tabella CRAN e trovando

scriptName biblioteca

che fornisce la current_filename()funzione, che restituisce il percorso completo corretto dello script durante l'approvvigionamento in RStudio e anche quando si richiama tramite eseguibile R o RScript.

Ho avuto anche questo problema, e nessuna delle soluzioni di cui sopra ha funzionato per me. Forse con il sourceo cose del genere, ma non era abbastanza chiaro.

Ho trovato questa soluzione per me elegante:

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

La cosa importante è fileSnapshot()che ti dà molte informazioni su un file. Restituisce un elenco di 8 elementi. Quando si seleziona pathcome elemento dell'elenco, il percorso viene restituito con \\come separatore, quindi il resto del codice serve solo a cambiarlo.

Spero che aiuti.

Puoi avvolgere lo script r in uno script bash e recuperare il percorso dello script come variabile bash in questo modo:

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

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

     EOF

Mi piace questo approccio:

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

L'ho appena capito da solo. Per garantire la portabilità del tuo script, inizia sempre con:

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

Funziona perché "." si traduce come il comando Unix $ PWD. L'assegnazione di questa stringa a un oggetto carattere consente quindi di inserire l'oggetto carattere in setwd () e Presto il codice verrà sempre eseguito con la directory corrente come directory di lavoro, indipendentemente dal computer su cui si trova o dalla struttura del file trova. (Bonus extra: l'oggetto wd può essere utilizzato con file.path () (es. File.path (wd, "directory_output") per consentire la creazione di una directory di output standard indipendentemente dal percorso del file che porta alla directory denominata. Ciò richiede di creare la nuova directory prima di fare riferimento in questo modo, ma anche questo può essere aiutato con l'oggetto wd.

In alternativa, il codice seguente esegue esattamente la stessa cosa:

wd <- getwd()
setwd(wd)

oppure, se non hai bisogno del percorso del file in un oggetto, puoi semplicemente:

setwd(".")

Si noti che il pacchetto getopt fornisce la get_Rscript_filenamefunzione, che utilizza solo la stessa soluzione presentata qui, ma è già scritta per te in un modulo R standard, quindi non è necessario copiare e incollare la funzione "get script path" in ogni script Scrivi.

Vedi findSourceTraceback()del pacchetto R.utils , che

Trova tutti gli oggetti 'srcfile' generati da source () in tutti i frame di chiamata. Ciò consente di scoprire quali file sono attualmente copiati da source ().

Ho avuto problemi con le implementazioni di cui sopra poiché il mio script è gestito da una directory con collegamenti simbolici, o almeno è per questo che penso che le soluzioni di cui sopra non abbiano funzionato per me. Sulla falsariga della risposta di @ennuikiller, ho racchiuso il mio Rscript in bash. Ho impostato la variabile path usando pwd -P, che risolve le strutture di directory con link simbolici. Quindi passa il percorso in 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)

Vorrei usare una variante dell'approccio di @ steamer25. Il punto è che preferisco ottenere l'ultimo script di provenienza anche quando la mia sessione è stata avviata tramite Rscript. Il frammento seguente, quando incluso in un file, fornirà una variabile thisScriptcontenente il percorso normalizzato dello script. Confesso l'uso (ab) del source, quindi a volte invoco Rscript e lo script fornito --filenell'argomento genera un altro script che ne genera un altro ... Un giorno investirò per trasformare il mio codice disordinato in un pacchetto.

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% dei casi che potresti semplicemente usare:

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

Non funzionerà con chiamate folli in cui lo script non è il primo argomento, vale a dire source(some args, file="myscript"). Usa @ hadley in questi casi fantasiosi.

L'approccio di Steamer25 funziona, ma solo se non c'è spazio nel percorso. Su macOS almeno cmdArgs[match]ritorna qualcosa di simile /base/some~+~dir~+~with~+~whitespace/a/base/some\ dir\ with\ whitespace/ .

Ho risolto il problema sostituendo "~ + ~" con un semplice spazio bianco prima di restituirlo.

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

Ovviamente puoi comunque estendere il blocco else come ha fatto aprstar.

Se anziché lo script, foo.Rconoscendo la posizione del percorso, se è possibile modificare il codice per fare sempre riferimento a tutti sourcei percorsi da un comune, rootquesti potrebbero essere di grande aiuto:

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

Dato

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

Questo funzionerà

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

Vedi https://rprojroot.r-lib.org/ per come definire le radici del progetto.

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

Incredibile non esiste una struttura di tipo "$ 0" in R! Puoi farlo con una chiamata di sistema () a uno script bash scritto in R:

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

Quindi dividi il nome scriptpath.sh per other.R

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

Osservando lo stack di chiamate, è possibile ottenere il percorso del file di ogni script in esecuzione, i due più utili saranno probabilmente lo script attualmente in esecuzione o il primo script da reperire (voce).

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