web-dev-qa-db-fra.com

Pycharm: définir la variable d'environnement pour l'exécution de la tâche manage.py

J'ai déplacé ma valeur SECRET_KEY de mon fichier de paramètres et elle est définie lorsque je charge virtualenv. Je peux confirmer que la valeur est présente à partir de python manage.py Shell.

Lorsque j'exécute la console Django, SECRET_KEY est manquant, comme il se doit. Donc, dans les préférences, je vais à Console> Console Django et charge SECRET_KEY et la valeur appropriée. Je retourne dans la console Django et SECRET_KEY y est.

Comme prévu, je ne peux pas encore exécuter de tâche manage.py car il n'a pas encore trouvé le SECRET_KEY. Je vais donc dans Exécuter> Modifier les configurations pour ajouter SECRET_KEY au serveur Django et aux tests Django, ainsi qu’au serveur de projet. Redémarrez Pycharm, confirmez les clés.

Lorsque j'exécute une tâche manage.py, telle que runserver, j'ai toujours KeyError: 'SECRET_KEY'.

Où est-ce que je mets cette clé?

pythondjangopycharm
33
Cole

Puisque Pycharm ne se lance pas depuis un terminal, votre environnement ne sera pas chargé. En bref, aucun programme graphique n'héritera des variables du shell. Voir this pour des raisons (en supposant un Mac).

Cependant, il existe plusieurs solutions de base à ce problème. Comme @ user3228589 posted, vous pouvez le configurer en tant que variable dans PyCharm. Cela a plusieurs avantages et inconvénients. Personnellement, je n'aime pas cette approche car ce n'est pas un single source. Pour résoudre ce problème, j'utilise une petite fonction en haut de mon fichier settings.py qui recherche la variable dans un fichier .env local. J'ai mis tous mes trucs "privés" à l'intérieur. Je peux aussi faire référence à cela dans mon virtualenv.

Voici à quoi cela ressemble.

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

Ensuite, le fichier env ressemble à ceci:

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

Et enfin, votre virtualenv/bin/postactivate peut utiliser ce fichier. Vous pouvez aller plus loin et exporter les variables comme décrit ici si vous le souhaitez, mais comme le fichier de paramètres appelle directement le fichier .env, il n’est pas vraiment utile.

41
rh0dium

Pour définir vos variables d'environnement dans PyCharm, procédez comme suit:

  • Ouvrez le menu 'Fichier'
  • Cliquez sur 'Paramètres'
  • Cliquez sur le signe '+' à côté de 'Console'
  • Cliquez sur Console Python
  • Cliquez sur le bouton '...' en regard de variables d'environnement.
  • Cliquez sur le '+' pour ajouter des variables d'environnement
21
nu everest

Idem ici, pour une raison quelconque, PyCharm ne peut pas voir les env env exportés . Pour le moment, je règle SECRET_KEY dans les configurations Run/Debug de PyCharm -> "Variables d'environnement"

13
ammonium

Une autre option qui a fonctionné pour moi:

  1. Ouvrir un terminal
  2. Activer le virtualenv du projet qui provoquera l'exécution des points d'ancrage et définir les variables d'environnement
  3. Lancez PyCharm à partir de cette ligne de commande. 

Pycharm aura alors accès aux variables d'environnement. Probablement parce que le processus PyCharm est un enfant de Shell. 

11
Antero Ortiz

Vous pouvez définir les variables d'environnement de la tâche manage.py via:

Préférences | Langues et cadres | Django | Tâches de gestion.py

La définition des env env via la configuration run/debug/console n’affectera pas la tâche de gestion.py intégrée de pycharm.

11
OmriToptix

Dans Pycharm manage.py, les tâches sont exécutées dans un processus isolé qui n'a pas accès à vos variables d'environnement (différent de Run/Debug).

La solution la plus simple consiste à rendre votre code python conscient des variables d’environnement en les lisant directement dans votre fichier .env.

Jetez un oeil à: https://github.com/joke2k/Django-environ

import environ

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

SECRET_KEY = env('SECRET_KEY')

De cette façon, vous avez une source unique de configurations et moins de paramètres dans l'EDI.

J'espère que cela pourra aider,

7
cvng

Pour paraphraser la réponse @ antero-ortiz , au lieu d'utiliser le double-clic par défaut du Mac ou la recherche ciblée pour lancer PyCharm, vous pouvez le lancer directement à partir du terminal. Cela héritera de toutes vos variables d'environnement de votre session de terminal à l'application PyCharm.

Voici comment je résous ce problème.

  1. À partir de votre programme de terminal, exécutez l'extrait ci-dessous. 
  2. Validez que les choses ont fonctionné en suivant les instructions données à Éditez vos configurations Exécuter/Déboguer } and,
    1. En cliquant sur le ... à côté de Environment variables
    2. Cliquez ensuite sur Show en bas à droite de l’écran qui apparaît. Cela montrera all des variables d'environnement héritées par le processus de débogage.
    3. Trouvez votre SECRET_KEY dans cette liste. Si ce n'est pas là, postez un commentaire sur cette réponse et nous pouvons essayer de le comprendre!
  3. Vous aurez probablement besoin de lancer PyCharm de cette manière à chaque démarrage. 

Fragment:

# 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$')

Note de côté

L'inclusion de variables d'environnement dans un fichier qui est alors source 'd est un modèle courant pour le développement de Django, et la discussion de cette meilleure pratique est mieux laissée de côté des réponses.

2
Ben

basé sur @ rh0dium réponse étonnante j'ai fait cette classe:

voici mon 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

et à l'intérieur de mon runserver.py j'ai ce code d'appel:

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']
1
danfromisrael

Dans PyCharm 2018, vous pouvez utiliser l'option Variables d'environnement de Django manage.py dans les paramètres.

  • Fichier
  • Réglages
  • Langage et cadres
  • Django
  • Variables d'environnement

Vous pouvez voir dans l'image

1
alireza yazdandoost

J'essaie cette configuration actuellement. J'ai un fichier env.local à la racine de mon projet. Mon manage.py ressemble à ceci:

#!/usr/bin/env python
import os
import sys


if __== "__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)

Ensuite, je passe juste --load-env dans la boîte de dialogue Exécution PyCharm et toutes les variables d’environnement seront chargées pendant la durée de l’exécution.

0
jaywink

Veuillez noter que la réponse mentionnée par "nu everest" fonctionne mais vous ne verrez pas l'onglet Console disponible sauf si vous créez un projet dans pycharm. Étant donné que des fichiers individuels peuvent être exécutés sans créer de projet dans pycharm, certaines personnes peuvent être désorientées. Bien que vous deviez également noter que les paramètres sont perdus pour les configurations d'exécution n'appartenant pas à un projet lorsque pycharm est fermé.

0
Part

La réponse de @ (nu everest) n'a pas fonctionné pour moi. Tout ce que vous avez décrit dans la question a fonctionné pour moi. Vous pouvez définir toutes les variables d'environnement dans la boîte de dialogue Configurations Exécuter/Déboguer. C'est PyCharm 2016.1 et aussi/ https://www.jetbrains.com/help/pycharm/2016.1/run-debug-configuration-python.html?origin=old_help

0
Nitin

Voici mon fichier manage.py au cas où cela aiderait. Il lit toutes les variables du fichier .env situé dans le répertoire racine de mon projet.

 enter image description here

0
saran3h