Como determinar corretamente o diretório de script atual?

Gostaria de ver qual é a melhor maneira de determinar o diretório de script atual em python?

Descobri que, devido às muitas maneiras de chamar código python, é difícil encontrar uma boa solução.

Aqui estão alguns problemas:

• __file__não está definido se o script for executado com exec,execfile
• __module__ é definido apenas em módulos

Casos de uso:

• ./myfile.py
• python myfile.py
• ./somedir/myfile.py
• python somedir/myfile.py
• execfile('myfile.py') (de outro script, que pode estar localizado em outro diretório e que pode ter outro diretório atual.

Sei que não existe uma solução perfeita, mas estou procurando a melhor abordagem que resolva a maioria dos casos.

A abordagem mais usada é, os.path.dirname(os.path.abspath(__file__))mas isso realmente não funciona se você executar o script de outra com exec().

Aviso

Qualquer solução que use o diretório atual falhará, isso pode ser diferente com base na maneira como o script é chamado ou pode ser alterado dentro do script em execução.

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

é realmente o melhor que você vai conseguir.

É incomum executar um script com exec/ execfile; normalmente você deve usar a infraestrutura do módulo para carregar scripts. Se você deve usar esses métodos, sugiro definir __file__a opção de globalspassar para o script para que ele possa ler esse nome de arquivo.

Não há outra maneira de obter o nome do arquivo no código executado: como você observa, o CWD pode estar em um local completamente diferente.

Se você realmente deseja cobrir o caso pelo qual um script é chamado execfile(...), você pode usar o inspectmódulo para deduzir o nome do arquivo (incluindo o caminho). Tanto quanto sei, isso funcionará para todos os casos que você listou:

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

Funciona em CPython, Jython, Pypy. Funciona se o script for executado usando execfile()(as soluções baseadas em sys.argv[0]e __file__falhariam aqui). Funciona se o script estiver dentro de um arquivo zip executável (/ um ovo) . Funciona se o script for "importado" ( PYTHONPATH=/path/to/library.zip python -mscript_to_run) de um arquivo zip; retorna o caminho do arquivo morto neste caso. Funciona se o script for compilado em um executável independente ( sys.frozen). Funciona para links simbólicos ( realpathelimina links simbólicos). Funciona em um intérprete interativo; retorna o diretório de trabalho atual neste caso.

No Python 3.4+, você pode usar o pathlibmódulo mais simples :

from inspect import currentframe, getframeinfo
from pathlib import Path

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

A os.path...abordagem foi a 'coisa feita' no Python 2.

No Python 3, você pode encontrar o diretório do script da seguinte maneira:

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

Basta usar os.path.dirname(os.path.abspath(__file__))e examinar com muito cuidado se existe uma necessidade real do caso em que execé usado. Pode ser um sinal de design problemático se você não conseguir usar o script como um módulo.

Lembre-se do Zen do Python # 8 , e se você acredita que há um bom argumento para um caso de uso em que ele deve funcionar exec, informe-nos mais alguns detalhes sobre o plano de fundo do problema.

Seria

import os
cwd = os.getcwd()

faça o que você quiser? Não sei o que exatamente você quer dizer com o "diretório de scripts atual". Qual seria a saída esperada para os casos de uso que você forneceu?

Primeiro .. alguns casos de uso ausentes aqui, se estamos falando de maneiras de injetar código anônimo ..

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

Mas, a verdadeira questão é: qual é o seu objetivo - você está tentando impor algum tipo de segurança? Ou você está apenas interessado no que está sendo carregado.

Se você estiver interessado em segurança , o nome do arquivo que está sendo importado via exec / execfile é irrelevante - você deve usar o rexec , que oferece o seguinte:

Este módulo contém a classe RExec, que suporta os métodos r_eval (), r_execfile (), r_exec () e r_import (), que são versões restritas das funções padrão do Python eval (), execfile () e as instruções exec e import. O código executado neste ambiente restrito somente terá acesso aos módulos e funções que são considerados seguros; você pode subclassar o RExec para adicionar ou remover recursos, conforme desejado.

No entanto, se isso é mais uma busca acadêmica ... aqui estão algumas abordagens patetas que você poderá aprofundar um pouco ..

Scripts de exemplo:

./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)

Resultado

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

Obviamente, essa é uma maneira que exige muitos recursos, pois você rastreará todo o seu código. Não é muito eficiente. Mas acho que é uma abordagem inovadora, pois continua a funcionar mesmo quando você se aprofunda no ninho. Você não pode substituir 'eval'. Embora você possa substituir execfile ().

Observe que essa abordagem abrange apenas exec / execfile, não 'importação'. Para um gancho de carga de 'módulo' de nível superior, você pode usar o uso sys.path_hooks (gravação cortesia de PyMOTW).

É tudo o que tenho em cima da minha cabeça.

Aqui está uma solução parcial, ainda melhor do que todas as publicadas até agora.

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

Agora isso funciona todas as chamadas, mas se alguém usar chdir()para alterar o diretório atual, isso também falhará.

Notas:

• sys.argv[0]não funcionar, retornará -cse você executar o script compython -c "execfile('path-tester.py')"
• Publiquei um teste completo em https://gist.github.com/1385555 e você pode aprimorá-lo.

Isso deve funcionar na maioria dos casos:

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

Espero que isso ajude: - Se você executar um script / módulo de qualquer lugar, poderá acessar a __file__variável, que é uma variável de módulo que representa a localização do script.

Por outro lado, se você estiver usando o intérprete, não terá acesso a essa variável, onde receberá um nome NameErrore os.getcwd()fornecerá o diretório incorreto se estiver executando o arquivo em outro local.

Esta solução deve fornecer o que você procura em todos os casos:

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

Ainda não o testei completamente, mas resolveu o meu problema.