Określ ścieżkę skryptu wykonawczego

Mam skrypt o nazwie, foo.Rktóry zawiera inny skrypt other.R, który znajduje się w tym samym katalogu:

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

Ale chcę Rto stwierdzić other.Rbez względu na bieżący katalog roboczy.

Innymi słowy, foo.Rmusi znać własną ścieżkę. Jak mogę to zrobić?

Tutaj jest proste rozwiązanie problemu. To polecenie:

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

zwraca ścieżkę bieżącego pliku skryptu. Działa po zapisaniu skryptu.

Możesz użyć tej commandArgsfunkcji, aby pobrać wszystkie opcje przekazane przez Rscript do rzeczywistego interpretera języka R i wyszukać je --file=. Jeśli skrypt został uruchomiony ze ścieżki lub jeśli został uruchomiony z pełną ścieżką, script.nameponiżej rozpocznie się od '/'. W przeciwnym razie musi być względna cwdi można połączyć dwie ścieżki, aby uzyskać pełną ścieżkę.

Edycja: brzmi tak, jakbyś potrzebował tylko script.namepowyższego i zdjął ostatni element ścieżki. Usunąłem niepotrzebną cwd()próbkę, wyczyściłem główny skrypt i opublikowałem mój other.R. Po prostu zapisz ten skrypt i other.Rskrypt w tym samym katalogu chmod +xi uruchom skrypt główny.

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)

other.R :

print("hello")

wyjście :

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"

Tego właśnie szuka Dehmann.

Nie mogłem zmusić rozwiązania Suppressingfire do działania, gdy „źródło” pochodziło z konsoli R.
Nie mogłem zmusić rozwiązania Hadley do działania podczas korzystania z Rscript.

Najlepsze z obu światów?

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

Nie pytaj mnie, jak to działa, ponieważ zapomniałem: /

To działa dla mnie

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

Odpowiedź rakensi z Pierwsze ścieżki skryptu R jest najbardziej poprawna i naprawdę genialna IMHO. Jednak wciąż jest to hack z funkcją manekina. Cytuję to tutaj, aby inni mogli łatwiej to znaleźć.

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

Daje to katalog pliku, w którym została umieszczona instrukcja (w którym zdefiniowano funkcję fikcyjną). Następnie można go użyć do ustawienia katalogu roboczego i ścieżek względnych, np

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

lub stworzyć ścieżki bezwzględne

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

Moje wszystko w jednym! (--01 / 09/2019 zaktualizowany w celu obsługi konsoli 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)
                }
            }
        }
    }
}

Odchudzony wariant odpowiedzi Supressingfire:

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

To działa dla mnie. Po prostu wyłapuje go z argumentów wiersza poleceń, usuwa niechciany tekst, robi nazwę katalogu i w końcu uzyskuje pełną ścieżkę z tego:

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

Skompletowałem i rozszerzyłem odpowiedzi na to pytanie do nowej funkcji thisfile()w rprojroot . Działa również na drutach knitr.

Podobało mi się rozwiązanie steamer25, ponieważ wydaje się najbardziej niezawodne do moich celów. Jednak podczas debugowania w RStudio (w systemie Windows) ścieżka nie zostanie ustawiona poprawnie. Powodem jest to, że jeśli w RStudio ustawiony jest punkt przerwania, w źródle pliku używana jest alternatywna komenda „źródło debugowania”, która nieco inaczej ustawia ścieżkę skryptu. Oto ostateczna wersja, której obecnie używam, która dotyczy tego alternatywnego zachowania w RStudio podczas debugowania:

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

Próbowałem prawie wszystkiego z tego pytania, Uzyskiwanie ścieżki skryptu R , Uzyskiwanie ścieżki bieżącego skryptu , Znajdź lokalizację bieżącego pliku .R i polecenia R do ustawienia katalogu roboczego na lokalizację pliku źródłowego w Rstudio , ale na końcu znalazłem się ręcznie przeglądanie tabeli CRAN i znalezione

scriptName biblioteka

która udostępnia current_filename()funkcję, która zwraca prawidłową pełną ścieżkę skryptu podczas pobierania w RStudio, a także podczas wywoływania za pomocą pliku wykonywalnego R lub RScript.

Miałem również ten problem i żadne z powyższych rozwiązań nie działało dla mnie. Może zsource takimi lub podobnymi rzeczami, ale nie było to wystarczająco jasne.

Dla mnie to eleganckie rozwiązanie:

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

Ważną rzeczą jest to, fileSnapshot()że daje wiele informacji o pliku. Zwraca listę 8 elementów. Po wybraniu pathjako elementu listy ścieżka jest zwracana za pomocą\\ jako separator, więc reszta kodu jest po prostu to zmienić.

Mam nadzieję, że to pomoże.

Możesz owinąć skrypt rw skrypt bash i pobrać ścieżkę skryptu jako zmienną bash w następujący sposób:

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

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

     EOF

Podoba mi się to podejście:

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

Właśnie to wypracowałem. Aby zapewnić przenośność skryptu, zawsze zaczynaj od:

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

Działa, ponieważ „.” tłumaczy jak polecenie Unix $ PWD. Przypisanie tego ciągu do obiektu znakowego pozwala następnie wstawić ten obiekt znakowy do setwd () i Presto twój kod zawsze będzie działał z bieżącym katalogiem jako katalogiem roboczym, bez względu na to, na której maszynie się znajduje lub gdzie w strukturze pliku jest usytuowany. (Dodatkowa premia: Obiekt wd może być używany z file.path () (tzn. File.path (wd, „katalog_wyjściowy”), aby umożliwić utworzenie standardowego katalogu wyjściowego niezależnie od ścieżki pliku prowadzącej do nazwanego katalogu. Wymaga to utworzenia nowego katalogu przed odwołaniem się do niego w ten sposób, ale to również może być pomocne w przypadku obiektu wd.

Alternatywnie poniższy kod wykonuje dokładnie to samo:

wd <- getwd()
setwd(wd)

lub jeśli nie potrzebujesz ścieżki pliku w obiekcie, możesz po prostu:

setwd(".")

Zauważ, że pakiet getopt udostępnia get_Rscript_filenamefunkcję, która wykorzystuje tylko to samo rozwiązanie przedstawione tutaj, ale jest już dla Ciebie napisana w standardowym module R, więc nie musisz kopiować i wklejać funkcji „pobierz ścieżkę skryptu” do każdego skryptu ty piszesz.

Zobacz findSourceTraceback()na R.utils pakietu, który

Znajduje wszystkie obiekty „srcfile” generowane przez source () we wszystkich ramkach wywołań. Dzięki temu można dowiedzieć się, które pliki są obecnie skryptowane przez source ().

Miałem problemy z powyższymi implementacjami, ponieważ mój skrypt jest obsługiwany z katalogu z dowiązaniami symbolicznymi, a przynajmniej dlatego uważam, że powyższe rozwiązania nie działały dla mnie. Wzdłuż linii odpowiedzi @ ennuikiller, zawinąłem swój skrypt Rscript w bash. Ustawiam zmienną ścieżkową za pomocą pwd -P, która rozwiązuje dowiązania struktur katalogów. Następnie przekaż ścieżkę do 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)

Użyłbym wariantu podejścia @ steamer25. Chodzi o to, że wolę uzyskać ostatni skrypt, nawet jeśli moja sesja została uruchomiona za pomocą Rscript. Poniższy fragment kodu, jeśli jest zawarty w pliku, zapewni zmienną thisScriptzawierającą znormalizowaną ścieżkę skryptu. Przyznaję się do (ab) użycia źródła, więc czasami wywołuję Rscript, a skrypt podany w --fileźródłach argumentów ma inny skrypt, który pobiera inny ... Pewnego dnia zainwestuję w przekształcenie mojego niechlujnego kodu w pakiet.

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% przypadków, których możesz po prostu użyć:

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

Nie zadziała w przypadku szalonych wywołań, w których skrypt nie jest pierwszym argumentem, tj source(some args, file="myscript"). Użyj @ hadley w tych fantazyjnych przypadkach.

Podejście Steamer25 działa, ale tylko wtedy, gdy na ścieżce nie ma białych znaków. Na MacOS przynajmniej cmdArgs[match]powraca coś /base/some~+~dir~+~with~+~whitespace/dla /base/some\ dir\ with\ whitespace/.

Obejrzałem to, zastępując „~ + ~” prostą białą spacją przed jej zwróceniem.

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

Oczywiście nadal możesz rozszerzyć blok else, tak jak zrobił to aprstar.

Jeśli zamiast skryptu, foo.Rznając jego lokalizację ścieżki, możesz zmienić kod tak, aby zawsze odwoływał się do wszystkich sourceścieżek ze wspólnego, rootto mogą być bardzo pomocne:

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

Dany

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

To zadziała

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

Zobacz https://rprojroot.r-lib.org/, aby dowiedzieć się, jak zdefiniować katalog główny projektu.

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

Zadziwiające, że w R nie ma struktury typu „0 $”! Możesz to zrobić za pomocą wywołania system () skryptu bash napisanego w języku R:

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

Następnie po prostu podziel nazwę scriptpath.sh dla other.R

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

Patrząc na stos wywołań, możemy uzyskać ścieżkę pliku każdego wykonywanego skryptu, dwa najbardziej przydatne będą prawdopodobnie albo aktualnie wykonywanym skryptem, albo pierwszym skryptem, który zostanie pozyskany (pozycja).

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