Pycharm: establezca la variable de entorno para ejecutar manage.py Tarea

Porque Pycharm no es el lanzamiento de un terminal, su entorno no será cargado. En resumen, cualquier programa GUI no heredarán las variables del SHELL. Ver este por razones (suponiendo un Mac).

Sin embargo, existen varias soluciones a este problema. Como @user3228589 publicado, puede configurar esto como una variable dentro de PyCharm. Esto tiene varios pros y contras. Yo, personalmente, no me gusta este método porque no es un single source. Para solucionar este problema, yo uso una pequeña función en la parte superior de mi settings.py archivo que busca la variable dentro de un local .env archivo. Puse todo de mi «privado» cosas allí. Yo también puede hacer referencia a esto en mi virtualenv.

Aquí es lo que parece.

— settings.py

def get_env_variable(var_name, default=False):
    """
    Get the environment variable or return exception
    :param var_name: Environment Variable to lookup
    """
    try:
        return os.environ[var_name]
    except KeyError:
        import StringIO
        import ConfigParser
        env_file = os.environ.get('PROJECT_ENV_FILE', SITE_ROOT + "/.env")
        try:
            config = StringIO.StringIO()
            config.write("[DATA]\n")
            config.write(open(env_file).read())
            config.seek(0, os.SEEK_SET)
            cp = ConfigParser.ConfigParser()
            cp.readfp(config)
            value = dict(cp.items('DATA'))[var_name.lower()]
            if value.startswith('"') and value.endswith('"'):
                value = value[1:-1]
            elif value.startswith("'") and value.endswith("'"):
                value = value[1:-1]
            os.environ.setdefault(var_name, value)
            return value
        except (KeyError, IOError):
            if default is not False:
                return default
            from django.core.exceptions import ImproperlyConfigured
            error_msg = "Either set the env variable '{var}' or place it in your " \
                        "{env_file} file as '{var} = VALUE'"
            raise ImproperlyConfigured(error_msg.format(var=var_name, env_file=env_file))

# Make this unique, and don't share it with anybody.
SECRET_KEY = get_env_variable('SECRET_KEY')

A continuación, el env archivo se parece a esto:

#!/bin/sh
#
# This should normally be placed in the ${SITE_ROOT}/.env
#
# DEPLOYMENT DO NOT MODIFY THESE..
SECRET_KEY='XXXSECRETKEY'

Y, finalmente, su virtualenv/bin/postactivate puede fuente de este archivo. Usted podría ir más allá y exportar las variables como se describe aquí si quieres, pero desde el archivo de configuración llama directamente a el .env, no hay realmente una necesidad.

Para establecer las variables de entorno en PyCharm hacer lo siguiente:

• Abra el menú ‘Archivo’
• Haga Clic En ‘Configuración’
• Haga clic en el signo ‘+’ al lado de ‘Consola’
• Haga Clic En La Consola De Python
• Haga clic en el botón ‘…’ junto a las variables de entorno
• Haga clic en el » + » para agregar variables de entorno

Mismo aquí, por alguna razón PyCharm no puede ver exportado env variables.
Por ahora me puse SECRET_KEY en PyCharm Run/Debug Configurations -> «variables de Entorno»

Otra opción que trabajó para mí:

1. Abrir un terminal
2. Activar el virtualenv del proyecto, que hará que los ganchos a ejecutar y establecer las variables de entorno
3. Lanzamiento PyCharm de esta línea de comandos.

Pycharm tendrá acceso a las variables de entorno. Probablemente a causa de algo que tiene que ver con la PyCharm proceso de ser un hijo de la concha.

Puede establecer el manage.py la tarea de las variables de entorno a través de:

Preferencias| Languages&Marcos| Django| Manage.py tareas

Configuración de la env variables a través de la run/debug/configuración de la consola no afectará a la construida en el pycharm del manage.py tarea.

En Pycharm manage.py tareas que se ejecutan en un proceso aislado que no tiene acceso a las variables de entorno (no es lo mismo Ejecutar/Depurar).

La solución más sencilla es hacer que el código de python conscientes de las variables de entorno mediante la lectura de su .env archivo directamente.

Echa un vistazo a: https://github.com/joke2k/django-environ

import environ

env = environ.Env.read_env() # reading .env file

SECRET_KEY = env('SECRET_KEY')

De esa manera se tiene una sola fuente de configuraciones, y menos ajustes en el IDE.

Espero que ayude,

Parafraseando @antero-ortiz respuesta, en lugar de utilizar el valor predeterminado de Mac, haga doble clic o de búsqueda de spotlight para el lanzamiento de PyCharm, puedes ejecutarlo directamente desde el terminal. Esto se hereda todas sus variables de entorno de su sesión de terminal para el PyCharm aplicación.

He aquí cómo puedo resolver este problema.

1. De su programa de terminal, ejecute el siguiente fragmento.
2. Validar que las cosas trabajado siguiendo las instrucciones para Editar su Run/Debug Configurations y,
   1. Clic en el ... junto a Environment variables
   2. A continuación, haga clic Show en la parte inferior derecha de la pantalla que aparece. Esto mostrará todos de las variables de entorno heredado por el proceso de Depuración.
   3. Encontrar su SECRET_KEY en esta lista. Si no lo hay, publicar un comentario en esta respuesta y podemos tratar de averiguar!
3. Es probable que necesite para el lanzamiento de PyCharm de esta manera cada vez que lo inicie.

Fragmento:

# This file would presumably export SECRET_KEY
source /path/to/env/file
# This is just a shortcut to finding out where you installed PyCharm
# If you used brew cask, it's probably in /opt/homebrew-cask/Caskroom/pycharm
open $(locate PyCharm.app | egrep 'PyCharm.app$')

Nota de lado

Incluyendo las variables de entorno en un archivo que después se source‘d es un patrón común para Django desarrollo, y la discusión de que la mejor práctica es mejor dejar de respuestas.

basa en @rh0dium increíble respuesta que he hecho de esta clase:

aquí está mi settings.py:

import os
class EnvironmentSettings():
"""Access to environment variables via system os or .env file for development
"""
def __init__(self, root_folder_path):
self._root_folder_path = root_folder_path
def __getitem__(self, key):
return self._get_env_variable(key)
def __setitem__(self, key, value):
raise InvalidOperationException('Environment Settings are read-only')
def __delitem__(self, key):
raise InvalidOperationException('Environment Settings are read-only')
def _get_env_variable(self, var_name, default=False):
"""
Get the environment variable or return exception
:param var_name: Environment Variable to lookup
"""
try:
return os.environ[var_name]
except KeyError:
from io import StringIO
from configparser import ConfigParser
env_file = os.environ.get('PROJECT_ENV_FILE', self._root_folder_path + "/.env")
try:
config = StringIO()
config.write("[DATA]\n")
config.write(open(env_file).read())
config.seek(0, os.SEEK_SET)
cp = ConfigParser()
cp.readfp(config)
value = dict(cp.items('DATA'))[var_name.lower()]
if value.startswith('"') and value.endswith('"'):
value = value[1:-1]
elif value.startswith("'") and value.endswith("'"):
value = value[1:-1]
os.environ.setdefault(var_name, value)
return value
except (KeyError, IOError):
if default is not False:
return default
error_msg = "Either set the env variable '{var}' or place it in your " \
"{env_file} file as '{var} = VALUE'"
raise ConfigurationError(error_msg.format(var=var_name, env_file=env_file))
class ConfigurationError(Exception):
pass
class InvalidOperationException(Exception):
pass

y dentro de mi runserver.py tengo este código de llamada:

from settings import EnvironmentSettings
root_folder_path = os.path.dirname(os.path.abspath(__file__))
env_settings = EnvironmentSettings(root_folder_path)
config_name = env_settings['APP_SETTINGS']

En PyCharm 2018 puede utilizar django manage.py las variables de entorno opción en la configuración

• Archivo
• Configuración
• Lenguaje y los Marcos de
• Django
• Variables de entorno

Usted puede ver en la imagen

La respuesta por @(nu everest) no me funciona. Lo que se describe en la pregunta que trabajó para mí. Usted puede configurar todas las variables de entorno en el Run/Debug Configurations de diálogo. Este es w.r.t PyCharm 2016.1 y también por https://www.jetbrains.com/help/pycharm/2016.1/run-debug-configuration-python.html?origin=old_help

Estoy tratando de esta configuración en la actualidad. Tengo una env.local archivo en mi raíz del proyecto. Mi manage.py se parece a esto:

#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings.local")
# Load environment variables from env.local, if option --load-env specified.
# Good for injecting environment into PyCharm run configurations for example and no need to
# manually load the env values for manage.py commands
if "--load-env" in sys.argv:
with open("env.local") as envfile:
for line in envfile:
if line.strip():
setting = line.strip().split("=", maxsplit=1)
os.environ.setdefault(setting[0], setting[1])
sys.argv.remove("--load-env")
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)

Entonces me acaba de pasar --load-env en el PyCharm de diálogo ejecutar y todas las variables de entorno se cargará en el momento de la ejecución.

Por favor, tenga en cuenta que la respuesta mencionado por «nu everest» funciona, pero usted no podrá ver la ficha de la Consola disponible a menos que crear un proyecto en pycharm. Como los archivos se pueden ejecutar sin necesidad de crear un proyecto en pycharm algunas personas puede ser confuso. Aunque también tenga en cuenta que se pierde la configuración para ejecutar-configuraciones que no pertenecen a un proyecto cuando pycharm es cerrado.

Aquí está mi manage.py archivo en caso de ayuda. Lee todas las variables .env archivo ubicado en el directorio raíz de mi proyecto.

Considero que un buen método es usar django-environ que le permiten leer las variables de entorno desde una .env archivo.

Uso

Instalar en primer lugar, django-environ

pip install django-environ

Segundo, crear un .env archivo en el mismo directorio de tu settings.py archivo.

$ cd project-settings-directory/
$ touch .env

Tercero, agregar las variables de entorno que desea utilizar para .env:

# .env file
DEBUG=on
SECRET_KEY=your-secret-key
DATABASE_URL=psql://urser:un-[email protected].0.0.1:8458/database
SQLITE_URL=sqlite:///my-local-sqlite.db

Cuarto, en el archivo de configuración, agregar lo siguiente justo después de que su importación de declaraciones:

# other import statements
import environ
# the followin line expects .env file to exist. Otherwise, an IOError exception will be raised.
env = environ.Env.read_env()

Quinto, cargar las variables de entorno:

DEBUG = env('DEBUG')
SECRET_KEY = env('SECRET_KEY')

Que es. Si desea más información acerca de por favor revise el docs.

Nota: esta configuración también le ayudará a establecer variables de entorno cuando se ejecuta un servidor de PyCharm.