environment-variables - permanently - set environment variable ubuntu

Python-modifica temporalmente el entorno del proceso actual

Question

Utilizo el siguiente código para modificar temporalmente las variables de entorno.

@contextmanager
def _setenv(**mapping):
    """``with`` context to temporarily modify the environment variables"""
    backup_values = {}
    backup_remove = set()
    for key, value in mapping.items():
        if key in os.environ:
            backup_values[key] = os.environ[key]
        else:
            backup_remove.add(key)
        os.environ[key] = value

    try:
        yield
    finally:
        # restore old environment
        for k, v in backup_values.items():
            os.environ[k] = v
        for k in backup_remove:
            del os.environ[k]

Esto with contexto se utiliza principalmente en casos de prueba. Por ejemplo,

def test_myapp_respects_this_envvar():
    with _setenv(MYAPP_PLUGINS_DIR=''testsandbox/plugins''):
        myapp.plugins.register()
        [...]

Mi pregunta: ¿hay una manera simple / elegante de escribir _setenv ? Pensé en hacer realmente backup = os.environ.copy() y luego os.environ = backup .. pero no estoy seguro si eso afectaría el comportamiento del programa (por ejemplo: si se hace referencia a os.environ en otra parte del intérprete de Python) .

Answer 1

Estaba buscando hacer lo mismo, pero para la prueba de unidad, aquí está cómo lo he hecho usando la función unittest.mock.patch :

def test_function_with_different_env_variable():
    with mock.patch.dict(''os.environ'', {''hello'': ''world''}, clear=True):
        self.assertEqual(os.environ.get(''hello''), ''world'')
        self.assertEqual(len(os.environ), 1)

Básicamente, usando unittest.mock.patch.dict con clear=True , estamos creando os.environ como un os.environ que contiene únicamente {''hello'': ''world''} .

• La eliminación de clear=True permitirá al os.environ original y agregar / reemplazar el par clave / valor especificado dentro de {''hello'': ''world''} .

• Al eliminar {''hello'': ''world''} solo se creará un diccionario vacío, os.envrion lo tanto, os.envrion estará vacío dentro de with .

Answer 2

Para pruebas unitarias prefiero usar una función de decorador con parámetros opcionales. De esta manera puedo usar los valores de entorno modificados para una función de prueba completa. El decorador a continuación también restaura los valores del entorno original en caso de que la función genere una excepción:

import os

def patch_environ(new_environ=None, clear_orig=False):
    if not new_environ:
        new_environ = dict()

    def actual_decorator(func):
        from functools import wraps

        @wraps(func)
        def wrapper(*args, **kwargs):
            original_env = dict(os.environ)

            if clear_orig:
                os.environ.clear()

            os.environ.update(new_environ)
            try:
                result = func(*args, **kwargs)
            except:
                raise
            finally: # restore even if Exception was raised
                os.environ = original_env

            return result

        return wrapper

    return actual_decorator

Uso en pruebas unitarias:

class Something:
    @staticmethod
    def print_home():
        home = os.environ.get(''HOME'', ''unknown'')
        print("HOME = {0}".format(home))


class SomethingTest(unittest.TestCase):
    @patch_environ({''HOME'': ''/tmp/test''})
    def test_environ_based_something(self):
        Something.print_home() # prints: HOME = /tmp/test

unittest.main()

Answer 3

Te sugiero la siguiente implementación:

import contextlib
import os


@contextlib.contextmanager
def set_env(**environ):
    """
    Temporarily set the process environment variables.

    >>> with set_env(PLUGINS_DIR=u''test/plugins''):
    ...   "PLUGINS_DIR" in os.environ
    True

    >>> "PLUGINS_DIR" in os.environ
    False

    :type environ: dict[str, unicode]
    :param environ: Environment variables to set
    """
    old_environ = dict(os.environ)
    os.environ.update(environ)
    try:
        yield
    finally:
        os.environ.clear()
        os.environ.update(old_environ)

EDIT: implementación más avanzada

El administrador de contexto a continuación se puede usar para agregar / eliminar / actualizar sus variables de entorno:

import contextlib
import os


@contextlib.contextmanager
def modified_environ(*remove, **update):
    """
    Temporarily updates the ``os.environ`` dictionary in-place.

    The ``os.environ`` dictionary is updated in-place so that the modification
    is sure to work in all situations.

    :param remove: Environment variables to remove.
    :param update: Dictionary of environment variables and values to add/update.
    """
    env = os.environ
    update = update or {}
    remove = remove or []

    # List of environment variables being updated or removed.
    stomped = (set(update.keys()) | set(remove)) & set(env.keys())
    # Environment variables and values to restore on exit.
    update_after = {k: env[k] for k in stomped}
    # Environment variables and values to remove on exit.
    remove_after = frozenset(k for k in update if k not in env)

    try:
        env.update(update)
        [env.pop(k, None) for k in remove]
        yield
    finally:
        env.update(update_after)
        [env.pop(k) for k in remove_after]

Ejemplos de uso:

>>> with modified_environ(''HOME'', LD_LIBRARY_PATH=''/my/path/to/lib''):
...     home = os.environ.get(''HOME'')
...     path = os.environ.get("LD_LIBRARY_PATH")
>>> home is None
True
>>> path
''/my/path/to/lib''

>>> home = os.environ.get(''HOME'')
>>> path = os.environ.get("LD_LIBRARY_PATH")
>>> home is None
False
>>> path is None
True

EDIT2

Una demostración de este administrador de contexto está disponible en GitHub .

Answer 4

Usando el gist aquí, puede guardar / restaurar variables de entorno y local, alcance global: https://gist.github.com/earonesty/ac0617a5672ae1a41be1eaf316dd63e4

import os
from varlib import vartemp, envtemp

x = 3
y = 4

with vartemp({''x'':93,''y'':94}):
   print(x)
   print(y)
print(x)
print(y)

with envtemp({''foo'':''bar''}):
    print(os.getenv(''foo''))

print(os.getenv(''foo''))

Esto produce:

93
94
3
4
bar
None

Answer 5

_environ = dict(os.environ)  # or os.environ.copy()
try:

    ...

finally:
    os.environ.clear()
    os.environ.update(_environ)