Pycharm: set environment variable for run manage.py Task

Question

I have moved my SECRET_KEY value out of my settings file, and it gets set when I load my virtualenv. I can confirm the value is present from python manage.py shell.

When I run the Django Console, SECRET_KEY is missing, as it should. So in preferences, I go to Console>Django Console and load SECRET_KEY and the appropriate value. I go back into the Django Console, and SECRET_KEY is there.

As expected, I cannot yet run a manage.py Task because it has yet to find the SECRET_KEY. So I go into Run>Edit Configurations to add SECRET_KEY into Django server and Django Tests, and into the project server. Restart Pycharm, confirm keys.

When I run a manage.py Task, such as runserver, I still get KeyError: 'SECRET_KEY'.

Where do I put this key?

Secret keys in plain texts files, particularly as part of a shared repo somewhere, is a bad idea. — Cole, Feb 04 '14 at 13:11
[EnvFile](https://github.com/Ashald/EnvFile) is an extension that allows you to read environment variables from a file. That allows you to set the variables in a file without having to manage your code... — David Fraser, Apr 13 '16 at 16:07

score 43 · Accepted Answer · edited Nov 22 '17 at 08:51

Because Pycharm is not launching from a terminal, your environment will not be loaded. In short, any GUI program will not inherit the SHELL variables. See this for reasons (assuming a Mac).

However, there are several basic solutions to this problem. As @user3228589 posted, you can set this up as a variable within PyCharm. This has several pros and cons. I personally don't like this approach because it's not a single source. To fix this, I use a small function at the top of my settings.py file which looks up the variable inside a local .env file. I put all of my "private" stuff in there. I also can reference this in my virtualenv.

Here is what it looks like.

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

Then the env file looks like this:

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

And finally your virtualenv/bin/postactivate can source this file. You could go further and export the variables as described here if you'd like, but since settings file directly calls the .env, there isn't really a need.

thank you so much! this is really really helpful! i've encapsulated & generalized it for easy use (removed django exceptions since i'm using flask): http://stackoverflow.com/a/29546356/303114 — danfromisrael, Apr 09 '15 at 18:39
Refer to cvng's answer. He links the django-environ package (https://github.com/joke2k/django-environ) which serves exactly that functionality. — Kim, Nov 24 '16 at 13:08

score 41 · Answer 2 · answered Apr 06 '14 at 20:56

41

To set your environment variables in PyCharm do the following:

Open the 'File' menu
Click 'Settings'
Click the '+' sign next to 'Console'
Click Python Console
Click the '...' button next to environment variables
Click the '+' to add environment variables

answered Apr 06 '14 at 20:56

nu everest

9,589
12
71
90

1

Please, can you tell me, how I can read this environment variable from code? 'os.getenv' returns only whole-system variables. – dondublon Sep 07 '15 at 12:49
1

You want to do something like `os.environ.get("KEY")` – karuhanga Oct 29 '18 at 23:24
5

In my PyCharm 2019.1.3 the option is in File | Settings | Build, Execution, Deployment | Console | Python Console | Environment variables – PHPirate Jun 12 '19 at 08:40
This is the correct approach and must be the accepted answer. – greatvovan Dec 28 '20 at 20:29

score 26 · Answer 3 · answered Feb 25 '15 at 15:58

26

You can set the manage.py task environment variables via:

Preferences| Languages&Frameworks| Django| Manage.py tasks

Setting the env vars via the run/debug/console configuration won't affect the built in pycharm's manage.py task.

answered Feb 25 '15 at 15:58

OmriToptix

1,219
1
15
22

I was looking for that for 2 hours: there are 2 consoles options (see answers above) but yours it the right one. – Olivier Pons Jun 16 '22 at 14:35

score 22 · Answer 4 · answered May 21 '15 at 12:48

22

Another option that's worked for me:

Open a terminal
Activate the virtualenv of the project which will cause the hooks to run and set the environment variables
Launch PyCharm from this command line.

Pycharm will then have access to the environment variables. Likely because of something having to do with the PyCharm process being a child of the shell.

answered May 21 '15 at 12:48

Antero Ortiz

371
3
5

This is the correct approach IMO. I expanded upon it by providing my own answer. – Ben Jul 13 '16 at 21:21
This is a great solution - works very well, doesn’t require copying settings to multiple places - thanks! – Bill Feb 27 '20 at 17:35

score 15 · Answer 5 · answered Feb 06 '14 at 12:56

15

Same here, for some reason PyCharm cant see exported env vars. For now i set SECRET_KEY in PyCharm Run/Debug Configurations -> "Environment variables"

answered Feb 06 '14 at 12:56

ammonium

151
3

score 8 · Answer 6 · answered Aug 06 '16 at 19:46

In Pycharm manage.py tasks run in an isolated process that do not have access to your environment variables (not the same as Run/Debug).

The simplest solution is to make your python code aware of environment variables by reading them from your .env file directly.

Take a look at: https://github.com/joke2k/django-environ

import environ

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

SECRET_KEY = env('SECRET_KEY')

That way you have a single source of configurations, and less settings in the IDE.

Hope that helps,

Note that this package is called "python-environ" and not "environ" — Benedikt S. Vogler, Jan 14 '21 at 10:37

Martín De la Fuente · Answer 7 · 2020-12-12T21:03:57.970

When using PyCharm along with Django, there are multiple sections where you can set environment variables (EVs):

File > Settings > Languages and Frameworks > Django
- There's no purpose to set EVs here
File > Settings > Build, Execution, Deployment > Console > Python Console
- There's no purpose to set EVs here
File > Settings > Build, Execution, Deployment > Console > Django Console
- Set EVs here and they'll be accesible when using the PyCharm Python Console (which in a Django project opens a Django shell)
File > Settings > Tools > Terminal
- Set EVs here and they'll be accesible when using the PyCharm Terminal (i.e when running python manage.py commands in the terminal)
Run > Edit configurations > [Your Django run configuration]
- Set EVs here and they'll be accesible when using the PyCharm Run button

Tested on PyCharm 2020.2 using a virtual environment.

score 3 · Answer 8 · edited May 23 '17 at 12:34

To paraphrase @antero-ortiz's answer, instead of using the default Mac double-click or spotlight search to launch PyCharm, you can launch it directly from the terminal. This will inherit all of your environment variables from your terminal session to the PyCharm app.

Here's how I solve this issue.

From your terminal program, run the snippet below.
Validate that things worked by following the instructions to Edit your Run/Debug Configurations and,
1. Clicking the ... next to Environment variables
2. Then clicking Show at the bottom right of the screen that pops up. This will show all of the environment variables inherited by the Debug process.
3. Find your SECRET_KEY in this list. If it's not there, post a comment on this answer and we can try to figure it out!
You'll likely need to launch PyCharm this way every time you start it.

Snippet:

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

Side note

Including environment variables in a file that is then source'd is a common pattern for Django development, and the discussion of that best practice is best left out of answers.

score 1 · Answer 9 · answered Apr 09 '15 at 18:37

based on @rh0dium amazing answer i've made this class:

here's my 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

and inside my runserver.py i have this calling code:

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

score 1 · Answer 10 · answered Apr 09 '16 at 10:45

I'm trying this setup currently. I have an env.local file in my project root. My manage.py looks like this:

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

Then I just pass --load-env in the PyCharm run dialog and all the environment variables will be loaded in for the time of the run.

score 1 · Answer 11 · answered Feb 16 '19 at 11:57

1

In PyCharm 2018 you can use django manage.py environment variables option in settings

File
Settings
Language and Frameworks
Django
Environment variables

You can see in image

answered Feb 16 '19 at 11:57

alireza yazdandoost

634
7
11

lmiguelvargasf · Answer 12 · 2019-04-02T17:30:04.793

I consider that a good approach is to use django-environ which allow you to read environment variables from a .env file.

Usage

First, install django-environ

pip install django-environ

Second, create a .env file, in the same directory of your settings.py file.

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

Third, add the environment variables you want to use to .env:

# .env file
DEBUG=on
SECRET_KEY=your-secret-key
DATABASE_URL=psql://urser:un-githubbedpassword@127.0.0.1:8458/database
SQLITE_URL=sqlite:///my-local-sqlite.db

Fourth, in your settings file, add the following just after your import statements:

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

Fifth, load the environment variables:

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

That's it. If you want further information about please review the docs.

Note: this configuration will also help you to set environment variables when running a server from PyCharm.

score 0 · Answer 13 · answered Apr 09 '16 at 05:03

The answer by @(nu everest) did not work for me. Whatever you described in the question worked for me. You can set all environment variables in the Run/Debug Configurations dialog. This is w.r.t PyCharm 2016.1 and also as per https://www.jetbrains.com/help/pycharm/2016.1/run-debug-configuration-python.html?origin=old_help

score 0 · Answer 14 · answered Dec 17 '16 at 16:13

Please note that the answer mentioned by "nu everest" works but you will not see Console tab available unless you create a project in pycharm. As individual files can be run without creating a project in pycharm some people might be confused. Although you have also to note that settings are lost to run-configurations that do not belong to a project when pycharm is closed.

score 0 · Answer 15 · answered Jul 23 '18 at 05:02

0

Here is my manage.py file in case it helps. It reads all the variables from .env file located in root directory of my project.

answered Jul 23 '18 at 05:02

saran3h

12,353
4
42
54

score 0 · Answer 16 · edited Jun 20 '20 at 09:12

In PyCharm 2019+, the debug environment settings are described on their site here. I had similar issues, even with environment variables defined in the other parts of PyCharm (Console, Terminal, etc.)

Summary:

Top-right where your Django project name is (next to the "run" icon), click the drop-down arrow.

i. Note: If the project hasn't been configured for Django, you might not see it. There should be templates available to use in the next window, though.
"Edit Configurations..."
You'll see an "Environment variables" field apart from the console settings. That's the one you actually want to use if you're running the Django server via PyCharm's debugger.

Pycharm: set environment variable for run manage.py Task

16 Answers16

Side note

Usage

Linked

Related