Emulazione della "sorgente" di Bash in Python

Ho uno script che assomiglia a questo:

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

Ogni volta che compilo eseguo 'source init_env' (dove init_env è lo script sopra) per impostare alcune variabili.

Per fare lo stesso in Python avevo questo codice in esecuzione,

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)

Ma poi qualcuno ha deciso che sarebbe stato carino aggiungere una riga come la seguente al init_envfile:

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

Ovviamente il mio script Python è andato in pezzi. Potrei modificare lo script Python per gestire questa riga, ma poi si interromperà più tardi quando qualcuno presenterà una nuova funzionalità da utilizzare nel init_envfile.

La domanda è se esiste un modo semplice per eseguire un comando Bash e lasciarlo modificare il mio os.environ?

Il problema con il tuo approccio è che stai cercando di interpretare gli script bash. Per prima cosa provi a interpretare l'istruzione export. Quindi noti che le persone usano l'espansione variabile. Successivamente le persone inseriranno i condizionali nei loro file o elaboreranno le sostituzioni. Alla fine avrai un interprete di script bash in piena regola con un miliardo di bug. Non farlo.

Lascia che Bash interpreti il ​​file per te e poi raccogli i risultati.

Puoi farlo in questo modo:

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

Assicurati di gestire gli errori nel caso in cui bash fallisca source init_env, o bash stesso non venga eseguito, o il sottoprocesso non riesca a eseguire bash, o qualsiasi altro errore.

l' env -iall'inizio della riga di comando crea un ambiente pulito. ciò significa che otterrai solo le variabili d'ambiente da init_env. se si desidera l'ambiente di sistema ereditato, omettere env -i.

Leggi la documentazione sul sottoprocesso per maggiori dettagli.

Nota: questo catturerà solo le variabili impostate con l' exportistruzione, poiché envstampa solo le variabili esportate.

Godere.

Nota che la documentazione di Python dice che se vuoi manipolare l'ambiente dovresti manipolare os.environdirettamente invece di usare os.putenv(). Lo considero un bug, ma sto divagando.

Usando il sottaceto:

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

Aggiornato:

Questo utilizza json, sottoprocesso e utilizza esplicitamente / bin / bash (per il supporto di 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

Piuttosto che avere il codice sorgente dello script Python dallo script bash, sarebbe più semplice ed elegante avere un codice sorgente dello script wrapper init_enve quindi eseguire lo script Python con l'ambiente modificato.

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

Aggiornata la risposta di @ lesmana per Python 3. Si noti il ​​cui uso env -iimpedisce che variabili di ambiente estranee vengano impostate / ripristinate (potenzialmente erroneamente data la mancanza di gestione per variabili env multilinea).

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

Esempio di avvolgimento dell'eccellente risposta di @ Brian in una funzione:

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

Sto usando questa funzione di utilità per leggere le credenziali aws e i file Docker .env con estensione include_unexported_variables=True.