Emulando 'fonte' do Bash em Python

Eu tenho um script parecido com este:

export foo=/tmp/foo                                          
export bar=/tmp/bar

Toda vez que eu construo, eu executo 'source init_env' (onde init_env é o script acima) para configurar algumas variáveis.

Para fazer o mesmo em Python, coloquei este código em execução,

reg = re.compile('export (?P<name>\w+)(\=(?P<value>.+))*')
for line in open(file):
    m = reg.match(line)
    if m:
        name = m.group('name')
        value = ''
        if m.group('value'):
            value = m.group('value')
        os.putenv(name, value)

Mas então alguém decidiu que seria bom adicionar uma linha como a seguinte ao init_envarquivo:

export PATH="/foo/bar:/bar/foo:$PATH"     

Obviamente, meu script Python se desfez. Eu poderia modificar o script Python para lidar com essa linha, mas ele apenas será interrompido mais tarde, quando alguém surgir com um novo recurso para usar no init_envarquivo.

A questão é se existe uma maneira fácil de executar um comando Bash e deixá-lo modificar o meu os.environ?

O problema com sua abordagem é que você está tentando interpretar scripts bash. Primeiro, você apenas tenta interpretar a instrução de exportação. Então você percebe que as pessoas estão usando expansão variável. Posteriormente, as pessoas colocarão condicionais em seus arquivos ou substituições de processos. No final, você terá um interpretador de script bash completo com zilhões de bugs. Não faça isso.

Deixe o Bash interpretar o arquivo para você e coletar os resultados.

Você pode fazer assim:

#! /usr/bin/env python

import os
import pprint
import shlex
import subprocess

command = shlex.split("env -i bash -c 'source init_env && env'")
proc = subprocess.Popen(command, stdout = subprocess.PIPE)
for line in proc.stdout:
  (key, _, value) = line.partition("=")
  os.environ[key] = value
proc.communicate()

pprint.pprint(dict(os.environ))

Certifique-se de lidar com os erros caso o bash falhe source init_env, ou o próprio bash falhe ao executar, ou o subprocesso falhe ao executar o bash, ou quaisquer outros erros.

o env -ino início da linha de comando cria um ambiente limpo. isso significa que você só obterá as variáveis ​​de ambiente de init_env. se desejar o ambiente de sistema herdado, omita env -i.

Leia a documentação sobre o subprocesso para mais detalhes.

Nota: isso irá capturar apenas variáveis ​​definidas com a exportinstrução, pois envimprime apenas variáveis ​​exportadas.

Aproveitar.

Observe que a documentação do Python diz que se você deseja manipular o ambiente, deve manipular os.environdiretamente em vez de usar os.putenv(). Eu considero isso um bug, mas estou divagando.

Usando picles:

import os, pickle
# For clarity, I moved this string out of the command
source = 'source init_env'
dump = '/usr/bin/python -c "import os,pickle;print pickle.dumps(os.environ)"'
penv = os.popen('%s && %s' %(source,dump))
env = pickle.loads(penv.read())
os.environ = env

Atualizada:

Isso usa json, subprocess, e usa explicitamente / bin / bash (para suporte ubuntu):

import os, subprocess as sp, json
source = 'source init_env'
dump = '/usr/bin/python -c "import os, json;print json.dumps(dict(os.environ))"'
pipe = sp.Popen(['/bin/bash', '-c', '%s && %s' %(source,dump)], stdout=sp.PIPE)
env = json.loads(pipe.stdout.read())
os.environ = env

Em vez de ter sua fonte de script Python como o script bash, seria mais simples e mais elegante ter uma fonte de script wrapper init_enve então executar seu script Python com o ambiente modificado.

#!/bin/bash
source init_env
/run/python/script.py

Atualizado a resposta de @lesmana para Python 3. Observe o uso de env -ique evita que variáveis ​​de ambiente estranhas sejam definidas / redefinidas (potencialmente incorretamente devido à falta de manipulação de variáveis ​​env multilinha).

import os, subprocess
if os.path.isfile("init_env"):
    command = 'env -i sh -c "source init_env && env"'
    for line in subprocess.getoutput(command).split("\n"):
        key, value = line.split("=")
        os.environ[key]= value

Exemplo de envolvimento da excelente resposta de Brian em uma função:

import json
import subprocess

# returns a dictionary of the environment variables resulting from sourcing a file
def env_from_sourcing(file_to_source_path, include_unexported_variables=False):
    source = '%ssource %s' % ("set -a && " if include_unexported_variables else "", file_to_source_path)
    dump = '/usr/bin/python -c "import os, json; print json.dumps(dict(os.environ))"'
    pipe = subprocess.Popen(['/bin/bash', '-c', '%s && %s' % (source, dump)], stdout=subprocess.PIPE)
    return json.loads(pipe.stdout.read())

Estou usando esta função de utilitário para ler credenciais aws e arquivos .env do docker com include_unexported_variables=True.