Come determinare correttamente la directory di script corrente?

Vorrei vedere qual è il modo migliore per determinare l'attuale directory di script in Python?

Ho scoperto che, a causa dei molti modi di chiamare il codice Python, è difficile trovare una buona soluzione.

Ecco alcuni problemi:

• __file__non è definito se lo script viene eseguito con exec,execfile
• __module__ è definito solo in moduli

Casi d'uso:

• ./myfile.py
• python myfile.py
• ./somedir/myfile.py
• python somedir/myfile.py
• execfile('myfile.py') (da un altro script, che può trovarsi in un'altra directory e che può avere un'altra directory corrente.

So che non esiste una soluzione perfetta, ma sto cercando l'approccio migliore che risolva la maggior parte dei casi.

L'approccio più usato è os.path.dirname(os.path.abspath(__file__))ma questo in realtà non funziona se si esegue lo script da un altro con exec().

avvertimento

Qualsiasi soluzione che utilizza la directory corrente non funzionerà, ciò può variare in base al modo in cui viene chiamato lo script o può essere modificato all'interno dello script in esecuzione.

os.path.dirname(os.path.abspath(__file__))

è davvero il migliore che otterrai.

È insolito eseguire uno script con exec/ execfile; normalmente dovresti usare l'infrastruttura del modulo per caricare gli script. Se devi usare questi metodi, ti suggerisco di impostare __file__il globalspassaggio allo script in modo che possa leggere quel nome file.

Non c'è altro modo per ottenere il nome file nel codice eseguito: come noti, il CWD potrebbe trovarsi in una posizione completamente diversa.

Se vuoi davvero coprire il caso in cui viene chiamato uno script execfile(...), puoi usare il inspectmodulo per dedurre il nome del file (incluso il percorso). Per quanto ne so, questo funzionerà per tutti i casi che hai elencato:

filename = inspect.getframeinfo(inspect.currentframe()).filename
path = os.path.dirname(os.path.abspath(filename))

#!/usr/bin/env python
import inspect
import os
import sys

def get_script_dir(follow_symlinks=True):
    if getattr(sys, 'frozen', False): # py2exe, PyInstaller, cx_Freeze
        path = os.path.abspath(sys.executable)
    else:
        path = inspect.getabsfile(get_script_dir)
    if follow_symlinks:
        path = os.path.realpath(path)
    return os.path.dirname(path)

print(get_script_dir())

Funziona su CPython, Jython, Pypy. Funziona se lo script viene eseguito utilizzando execfile()( sys.argv[0]e le __file__soluzioni basate su base fallirebbero qui). Funziona se lo script si trova all'interno di un file zip eseguibile (/ un uovo) . Funziona se lo script è "importato" ( PYTHONPATH=/path/to/library.zip python -mscript_to_run) da un file zip; in questo caso restituisce il percorso dell'archivio. Funziona se lo script è compilato in un eseguibile standalone ( sys.frozen). Funziona con realpathcollegamenti simbolici ( elimina i collegamenti simbolici). Funziona in un interprete interattivo; in questo caso restituisce la directory di lavoro corrente.

In Python 3.4+ puoi usare il pathlibmodulo più semplice :

from inspect import currentframe, getframeinfo
from pathlib import Path

filename = getframeinfo(currentframe()).filename
parent = Path(filename).resolve().parent

L' os.path...approccio era la "cosa fatta" in Python 2.

In Python 3, puoi trovare la directory di script come segue:

from pathlib import Path
cwd = Path(__file__).parents[0]

Basta usare os.path.dirname(os.path.abspath(__file__))ed esaminare con molta attenzione se esiste una reale necessità per il caso in cui execviene utilizzato. Potrebbe essere un segno di design problematico se non sei in grado di utilizzare lo script come modulo.

Tieni a mente Zen of Python # 8 e, se ritieni che ci sia un buon argomento per un caso d'uso in cui deve funzionare exec, ti preghiamo di farci sapere qualche dettaglio in più sullo sfondo del problema.

Voluto

import os
cwd = os.getcwd()

Fai quello che vuoi? Non sono sicuro di cosa significhi esattamente la "directory di script corrente". Quale sarebbe l'output previsto per i casi d'uso forniti?

Innanzitutto ... un paio di casi d'uso mancanti qui se stiamo parlando di modi per iniettare codice anonimo ..

code.compile_command()
code.interact()
imp.load_compiled()
imp.load_dynamic()
imp.load_module()
__builtin__.compile()
loading C compiled shared objects? example: _socket?)

Ma la vera domanda è: qual è il tuo obiettivo: stai cercando di applicare una sorta di sicurezza? Oppure sei solo interessato a cosa viene caricato.

Se sei interessato alla sicurezza , il nome del file che viene importato tramite exec / execfile non ha importanza: dovresti usare rexec , che offre quanto segue:

Questo modulo contiene la classe RExec, che supporta i metodi r_eval (), r_execfile (), r_exec () e r_import (), che sono versioni limitate delle funzioni standard di Python eval (), execfile () e le istruzioni exec e import. Il codice eseguito in questo ambiente limitato avrà accesso solo a moduli e funzioni ritenute sicure; è possibile sottoclassare RExec aggiungere o rimuovere funzionalità come desiderato.

Tuttavia, se questo è più di una ricerca accademica ... ecco un paio di approcci sciocchi che potresti essere in grado di scavare un po 'più a fondo in ..

Script di esempio:

./deep.py

print ' >> level 1'
execfile('deeper.py')
print ' << level 1'

./deeper.py

print '\t >> level 2'
exec("import sys; sys.path.append('/tmp'); import deepest")
print '\t << level 2'

/tmp/deepest.py

print '\t\t >> level 3'
print '\t\t\t I can see the earths core.'
print '\t\t << level 3'

./codespy.py

import sys, os

def overseer(frame, event, arg):
    print "loaded(%s)" % os.path.abspath(frame.f_code.co_filename)

sys.settrace(overseer)
execfile("deep.py")
sys.exit(0)

Produzione

loaded(/Users/synthesizerpatel/deep.py)
>> level 1
loaded(/Users/synthesizerpatel/deeper.py)
    >> level 2
loaded(/Users/synthesizerpatel/<string>)
loaded(/tmp/deepest.py)
        >> level 3
            I can see the earths core.
        << level 3
    << level 2
<< level 1

Certo, questo è un modo ad alta intensità di risorse per farlo, tracceresti tutto il tuo codice .. Non molto efficiente. Ma penso che sia un approccio nuovo dal momento che continua a funzionare anche man mano che approfondisci il nido. Non puoi ignorare "eval". Sebbene sia possibile sovrascrivere execfile ().

Nota, questo approccio copre solo exec / execfile, non 'import'. Per l'aggancio del 'modulo' di livello superiore potresti essere in grado di usare sys.path_hooks (Scrittura per gentile concessione di PyMOTW).

Questo è tutto quello che ho in cima alla mia testa.

Ecco una soluzione parziale, ancora migliore di tutte quelle pubblicate finora.

import sys, os, os.path, inspect

#os.chdir("..")

if '__file__' not in locals():
    __file__ = inspect.getframeinfo(inspect.currentframe())[0]

print os.path.dirname(os.path.abspath(__file__))

Ora funzionerà tutte le chiamate ma se qualcuno usa chdir()per cambiare la directory corrente, anche questo fallirà.

Appunti:

• sys.argv[0]non funzionerà, tornerà -cse si esegue lo script conpython -c "execfile('path-tester.py')"
• Ho pubblicato un test completo su https://gist.github.com/1385555 e siete invitati a migliorarlo.

Questo dovrebbe funzionare nella maggior parte dei casi:

import os,sys
dirname=os.path.dirname(os.path.realpath(sys.argv[0]))

Speriamo che questo aiuti: - Se esegui uno script / modulo da qualsiasi luogo, sarai in grado di accedere alla __file__variabile che è una variabile del modulo che rappresenta la posizione dello script.

D'altra parte, se stai usando l'interprete non hai accesso a quella variabile, dove otterrai un nome NameErrore os.getcwd()ti darà la directory errata se stai eseguendo il file da qualche altra parte.

Questa soluzione dovrebbe darti quello che stai cercando in tutti i casi:

from inspect import getsourcefile
from os.path import abspath
abspath(getsourcefile(lambda:0))

Non l'ho testato a fondo ma ha risolto il mio problema.