Déterminer le chemin du script d'exécution

J'ai un script appelé foo.Rqui inclut un autre script other.R, qui se trouve dans le même répertoire:

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

Mais je veux Rtrouver que other.Rquel que soit le répertoire de travail actuel.

En d'autres termes, foo.Rdoit connaître son propre chemin. Comment puis je faire ça?

Ici, il existe une solution simple au problème. Cette commande:

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

renvoie le chemin du fichier de script actuel. Cela fonctionne après que le script a été enregistré.

Vous pouvez utiliser la commandArgsfonction pour obtenir toutes les options passées par Rscript à l'interpréteur R réel et les rechercher --file=. Si votre script a été lancé à partir du chemin d'accès ou s'il a été lancé avec un chemin d'accès complet, ce qui script.namesuit commencera par un '/'. Sinon, il doit être relatif à la cwdet vous pouvez concaténer les deux chemins pour obtenir le chemin complet.

Modifier: il semble que vous n'ayez besoin que de ce qui script.nameprécède et que vous supprimiez le dernier composant du chemin. J'ai supprimé l' cwd()échantillon inutile , nettoyé le script principal et publié mon other.R. Enregistrez simplement ce script et le other.Rscript dans le même répertoire, chmod +xeux, et exécutez le 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)

autre.R :

print("hello")

sortie :

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"

C'est ce que je crois que dehmann recherche.

Je n'ai pas pu faire fonctionner la solution de Suppressingfire lors de la 'source' à partir de la console R.
Je n'ai pas pu faire fonctionner la solution de hadley lors de l'utilisation de Rscript.

Le meilleur des deux mondes?

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

Ne me demandez pas comment ça marche, car j'ai oublié: /

Ça marche pour moi

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

La réponse de rakensi de Obtenir le chemin d'un script R est à mon humble avis le plus correct et le plus brillant. Pourtant, c'est toujours un hack intégrant une fonction factice. Je le cite ici, afin qu'il soit plus facile à trouver par les autres.

sourceDir <- getSrcDirectory (fonction (factice) {factice})

Cela donne le répertoire du fichier où l'instruction a été placée (où la fonction factice est définie). Il peut ensuite être utilisé pour définir le répertoire de travail et utiliser des chemins relatifs, par exemple

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

ou pour créer des chemins absolus

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

Mon tout en un! (--01 / 09/2019 mis à jour pour gérer la 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)
                }
            }
        }
    }
}

Une variante allégée de la réponse 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="/"))
}

Cela fonctionne pour moi. Il suffit de le sortir des arguments de la ligne de commande, de supprimer le texte indésirable, de faire un nom de répertoire et d'obtenir enfin le chemin complet à partir de cela:

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

J'ai terminé et étendu les réponses à cette question dans une nouvelle fonction thisfile()dans rprojroot . Fonctionne également pour tricoter avec knitr.

J'ai aimé la solution de steamer25 car elle semble la plus robuste pour mes besoins. Cependant, lors du débogage dans RStudio (dans Windows), le chemin ne serait pas correctement défini. La raison étant que si un point d'arrêt est défini dans RStudio, le sourcing du fichier utilise une autre commande "debug source" qui définit le chemin du script un peu différemment. Voici la version finale que j'utilise actuellement et qui explique ce comportement alternatif dans RStudio lors du débogage:

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

J'ai essayé presque tout de cette question, obtenir le chemin d'un script R , obtenir le chemin du script actuel , trouver l'emplacement du fichier .R actuel et la commande R pour définir le répertoire de travail à l'emplacement du fichier source dans Rstudio , mais à la fin je me suis retrouvé manuellement parcourant la table CRAN et trouvé

scriptName bibliothèque

qui fournit une current_filename()fonction, qui renvoie le chemin d'accès complet du script lors de l'approvisionnement dans RStudio et également lors de l'appel via un exécutable R ou RScript.

J'ai également eu ce problème et aucune des solutions ci-dessus n'a fonctionné pour moi. Peut-être avec lesource ou des choses comme ça, mais ce n'était pas assez clair.

J'ai trouvé cette solution, élégante pour moi:

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

L'important est fileSnapshot()que cela vous donne beaucoup d'informations sur un fichier. Il renvoie une liste de 8 éléments. Lorsque vous choisissez pathcomme élément de liste, le chemin d'accès est renvoyé avec\\ comme séparateur, donc le reste du code est juste pour changer cela.

J'espère que ça aide.

Vous pouvez encapsuler le script r dans un script bash et récupérer le chemin du script en tant que variable bash comme ceci:

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

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

     EOF

J'aime cette approche:

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

Je viens de résoudre ça moi-même. Pour garantir la portabilité de votre script, commencez toujours par:

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

Cela fonctionne parce que "." traduit comme la commande Unix $ PWD. L'affectation de cette chaîne à un objet caractère vous permet ensuite d'insérer cet objet caractère dans setwd () et Presto votre code s'exécutera toujours avec son répertoire actuel comme répertoire de travail, quelle que soit la machine sur laquelle il se trouve ou où dans la structure de fichiers où il se trouve. situé. (Bonus supplémentaire: l'objet wd peut être utilisé avec file.path () (c'est-à-dire file.path (wd, "output_directory") pour permettre la création d'un répertoire de sortie standard quel que soit le chemin de fichier menant à votre répertoire nommé. Cela vous oblige à créer le nouveau répertoire avant de le référencer de cette façon, mais cela aussi peut être aidé avec l'objet wd.

Alternativement, le code suivant effectue exactement la même chose:

wd <- getwd()
setwd(wd)

ou, si vous n'avez pas besoin du chemin du fichier dans un objet, vous pouvez simplement:

setwd(".")

Notez que le package getopt fournit la get_Rscript_filenamefonction, qui utilise simplement la même solution présentée ici, mais est déjà écrite pour vous dans un module R standard, vous n'avez donc pas à copier et coller la fonction "get script path" dans chaque script vous écrivez.

Voir findSourceTraceback()le package R.utils , qui

Recherche tous les objets 'srcfile' générés par source () dans tous les frames d'appel. Cela permet de savoir quels fichiers sont actuellement scriptés par source ().

J'ai eu des problèmes avec les implémentations ci-dessus car mon script est exploité à partir d'un répertoire de liens symboliques, ou du moins c'est pourquoi je pense que les solutions ci-dessus n'ont pas fonctionné pour moi. Dans le sens de la réponse de @ ennuikiller, j'ai enveloppé mon Rscript dans bash. J'ai défini la variable de chemin à l'aide de pwd -P, qui résout les structures de répertoires à liens symboliques. Passez ensuite le chemin dans le 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)

J'utiliserais une variante de l'approche de @ steamer25. Le fait est que je préfère obtenir le dernier script source même lorsque ma session a été lancée via Rscript. L'extrait suivant, lorsqu'il est inclus dans un fichier, fournira une variable thisScriptcontenant le chemin normalisé du script. J'avoue l'utilisation (ab) de source'ing, donc parfois j'invoque Rscript et le script fourni dans l' --fileargument sources un autre script qui en source un autre ... Un jour, j'investirai pour transformer mon code en désordre en un package.

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% des cas que vous pourriez simplement utiliser:

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

Cela ne fonctionnera pas pour les appels fous où le script n'est pas le premier argument, c'est-à-dire source(some args, file="myscript"). Utilisez @ hadley dans ces cas fantaisistes.

L'approche de Steamer25 fonctionne, mais uniquement s'il n'y a pas d'espace dans le chemin. Sur macOS au moins, le cmdArgs[match]retourne quelque chose comme /base/some~+~dir~+~with~+~whitespace/pour/base/some\ dir\ with\ whitespace/ .

J'ai travaillé autour de cela en remplaçant le "~ + ~" par un simple espace blanc avant de le retourner.

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

De toute évidence, vous pouvez toujours étendre le bloc else comme l'a fait aprstar.

Si plutôt que le script, foo.Rconnaissant son emplacement de chemin, si vous pouvez changer votre code pour toujours référencer tous sourceles chemins d'un commun rootalors ceux-ci peuvent être d'une grande aide:

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

Donné

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

Cela fonctionnera

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

Voir https://rprojroot.r-lib.org/ pour savoir comment définir les racines du projet.

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

Étonnant, il n'y a pas de structure de type «$ 0» dans R! Vous pouvez le faire avec un appel system () à un script bash écrit en R:

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

Ensuite, divisez simplement le nom scriptpath.sh pour other.R

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

En regardant la pile d'appels, nous pouvons obtenir le chemin de fichier de chaque script en cours d'exécution, les deux plus utiles seront probablement soit le script en cours d'exécution, soit le premier script à trouver (entrée).

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