Creating a Flask application in PyCharm Create a basic Flask project as described in Creating a Flask Project to start prototyping the application. Select Flask in the New Project dialog. In the Location field, provide the path to the project location and type the MeteoMaster as the project name. PyCharm supports Flask framework development. You can easily create a new Flask project by creating new project through welcome screen. You can set the project’s location and the virtual environment and choose a template language and where the templates will be located. You can run a project by using Run - Run ‘’.
Flask project in intended for productive development of the Flask applications. PyCharm takes care of creating the specific directory structure, and settings.
To create a Flask project, follow these steps
From the main menu, choose File | New Project..., or click the New Project button in the Welcome screen. New Project dialog opens.
In the New Project dialog, do the following:
Specify project type Flask.
Specify project location.
Next, click to expand the Python Interpreter node, and select the new environment or previously configured interpreter, by clicking the corresponding radio-button.
The following steps depend on your choice:
New environment using: if this option has been selected, choose the tool to be used to create a virtual environment. To do that, click the list and choose Virtualenv, Pipenv, or Conda.
Next, specify the Location and Base interpreter of the new virtual environment. If necessary, click the Inherit global site-packages and Make available to all projects check boxes.
When configuring the base interpreter, you need to specify the path to the Python executable. If PyCharm detects no Python on your machine, it provides two options: to download the latest Python versions from python.org or to specify a path to the Python executable (in case of non-standard installation).
Previously configured interpreter: if this option has been selected, choose the desired interpreter from the list, or (if the desired interpreter is not found), click and choose the interpreter. See Configure a Python interpreter for details.
When PyCharm stops supporting any of the outdated Python versions, the corresponding Python interpreter is marked as unsupported.
Click (More Settings ), and specify the following:
From the Template language list, select the language to be used.
- In the Templates folder field, specify the directory where the templates will be stored, and where they will be loaded from. You can specify the name of the directory that doesn't yet exist; in this case, the directory will be created.
Click Create.
PyCharm creates an application and produces specific directory structure, which you can explore in the Project tool window. Besides that, PyCharm creates a stub Python script with the name app.py, which provides a simple 'Hello, World!' example.
Which Pycharm Should I Download
You can run the created application by pressing Shift+F10 Preview the run results.
Note that the application was run with the following Flask specific variables:
FLASK_APP=app.py– Defines an entry point of the Flask application - the target instance of theFlaskclass. When extending your Flask application and adding more modules and files, you might need to pass some non-defaultFLASK_APPvalues. You can pass a module name, a path to the target Python file, or any combination of modules, scripts, andFlaskclass instances, for example,FLASK_APP=access_management.access:app2, where:access_management– the module nameaccess– the target file in the moduleapp2– theFlaskclass instance inaccess.
For more information about the
FLASK_APPvariable, refer to Flask CLI documentation.FLASK_ENV=development– Sets one of possible environments.FLASK_DEBUG=0– Controls the built-in Flask debug mode. With this mode enabledFLASK_DEBUG=1, the development server will be automatically reloaded on any code change enabling continuous debugging. For more information about Flask debugger, refer to Flask Debug Mode.
You can change Flask specific variables by editing the corresponding parameters of the Flask Server Run/Debug configuration.
When you've enabled Flask support in your project, the Python console starts acting as a Flask console. Use code completion to enter and execute Flask-specific commands.
Installing Flask installs the flask script, a Click command lineinterface, in your virtualenv. Executed from the terminal, this script givesaccess to built-in, extension, and application-defined commands. The --helpoption will give more information about any commands and options.
Application Discovery¶
The flask command is installed by Flask, not your application; it must betold where to find your application in order to use it. The FLASK_APPenvironment variable is used to specify how to load the application.
Unix Bash (Linux, Mac, etc.):
Windows CMD:
Windows PowerShell:
While FLASK_APP supports a variety of options for specifying yourapplication, most use cases should be simple. Here are the typical values:
The file wsgi.py is imported, automatically detecting an app(app). This provides an easy way to create an app from a factory withextra arguments.
FLASK_APP=helloThe name is imported, automatically detecting an app (app) or factory(create_app).
FLASK_APP has three parts: an optional path that sets the current workingdirectory, a Python file or dotted import path, and an optional variablename of the instance or factory. If the name is a factory, it can optionallybe followed by arguments in parentheses. The following values demonstrate theseparts:
FLASK_APP=src/helloSets the current working directory to src then imports hello.
FLASK_APP=hello.webImports the path hello.web.
FLASK_APP=hello:app2Uses the app2 Flask instance in hello.
FLASK_APP='hello:create_app('dev')'The create_app factory in hello is called with the string 'dev'as the argument.
If FLASK_APP is not set, the command will try to import “app” or“wsgi” (as a “.py” file, or package) and try to detect an applicationinstance or factory.
Within the given import, the command looks for an application instance namedapp or application, then any application instance. If no instance isfound, the command looks for a factory function named create_app ormake_app that returns an instance.
When calling an application factory, if the factory takes an argument namedscript_info, then the ScriptInfo instance is passed as akeyword argument. If the application factory takes only one argument and noparentheses follow the factory name, the ScriptInfo instanceis passed as a positional argument. If parentheses follow the factory name,their contents are parsed as Python literals and passes as arguments to thefunction. This means that strings must still be in quotes.
Run the Development Server¶
The run command will start the development server. Itreplaces the Flask.run() method in most cases.
Warning
Do not use this command to run your application in production.Only use the development server during development. The development serveris provided for convenience, but is not designed to be particularly secure,stable, or efficient. See Deployment Options for how to run in production.
Open a Shell¶
To explore the data in your application, you can start an interactive Pythonshell with the shell command. An applicationcontext will be active, and the app instance will be imported.
Use shell_context_processor() to add other automatic imports.
Environments¶
Changelog
The environment in which the Flask app runs is set by theFLASK_ENV environment variable. If not set it defaults toproduction. The other recognized environment is development.Flask and extensions may choose to enable behaviors based on theenvironment.
If the env is set to development, the flask command will enabledebug mode and flaskrun will enable the interactive debugger andreloader.
Watch Extra Files with the Reloader¶
When using development mode, the reloader will trigger whenever yourPython code or imported modules change. The reloader can watchadditional files with the --extra-files option, or theFLASK_RUN_EXTRA_FILES environment variable. Multiple paths areseparated with :, or ; on Windows.
Debug Mode¶
Debug mode will be enabled when FLASK_ENV is development,as described above. If you want to control debug mode separately, useFLASK_DEBUG. The value 1 enables it, 0 disables it.
Environment Variables From dotenv¶
Rather than setting FLASK_APP each time you open a new terminal, you canuse Flask’s dotenv support to set environment variables automatically.
If python-dotenv is installed, running the flask command will setenvironment variables defined in the files .env and .flaskenv.This can be used to avoid having to set FLASK_APP manually every time youopen a new terminal, and to set configuration using environment variablessimilar to how some deployment services work.
Variables set on the command line are used over those set in .env,which are used over those set in .flaskenv. .flaskenv should beused for public variables, such as FLASK_APP, while .env should notbe committed to your repository so that it can set private variables.
Directories are scanned upwards from the directory you call flaskfrom to locate the files. The current working directory will be set to thelocation of the file, with the assumption that that is the top level projectdirectory.
The files are only loaded by the flask command or callingrun(). If you would like to load these files when running inproduction, you should call load_dotenv() manually.
Setting Command Options¶
Click is configured to load default values for command options fromenvironment variables. The variables use the patternFLASK_COMMAND_OPTION. For example, to set the port for the runcommand, instead of flaskrun--port8000:
These can be added to the .flaskenv file just like FLASK_APP tocontrol default command options.
Disable dotenv¶
The flask command will show a message if it detects dotenv files butpython-dotenv is not installed.
You can tell Flask not to load dotenv files even when python-dotenv isinstalled by setting the FLASK_SKIP_DOTENV environment variable.This can be useful if you want to load them manually, or if you’re usinga project runner that loads them already. Keep in mind that theenvironment variables must be set before the app loads or it won’tconfigure as expected.
Environment Variables From virtualenv¶
If you do not want to install dotenv support, you can still set environmentvariables by adding them to the end of the virtualenv’s activatescript. Activating the virtualenv will set the variables.
Unix Bash, venv/bin/activate:
Windows CMD, venvScriptsactivate.bat:
It is preferred to use dotenv support over this, since .flaskenv can becommitted to the repository so that it works automatically wherever the projectis checked out.
Custom Commands¶
The flask command is implemented using Click. See that project’sdocumentation for full information about writing commands.
This example adds the command create-user that takes the argumentname.
This example adds the same command, but as usercreate, a command in agroup. This is useful if you want to organize multiple related commands.
See Testing CLI Commands for an overview of how to test your customcommands.
Registering Commands with Blueprints¶
If your application uses blueprints, you can optionally register CLIcommands directly onto them. When your blueprint is registered onto yourapplication, the associated commands will be available to the flaskcommand. By default, those commands will be nested in a group matchingthe name of the blueprint.
You can alter the group name by specifying the cli_group parameterwhen creating the Blueprint object, or later withapp.register_blueprint(bp,cli_group='...').The following are equivalent:
Specifying cli_group=None will remove the nesting and merge thecommands directly to the application’s level:
Application Context¶
Commands added using the Flask app’s clicommand() decorator will be executed with an applicationcontext pushed, so your command and extensions have access to the app and itsconfiguration. If you create a command using the Click command()decorator instead of the Flask decorator, you can usewith_appcontext() to get the same behavior.
If you’re sure a command doesn’t need the context, you can disable it:
Plugins¶
Flask will automatically load commands specified in the flask.commandsentry point. This is useful for extensions that want to add commands whenthey are installed. Entry points are specified in setup.py
Inside flask_my_extension/commands.py you can then export a Clickobject:
Once that package is installed in the same virtualenv as your Flask project,you can run flaskmy-command to invoke the command.
Custom Scripts¶
When you are using the app factory pattern, it may be more convenient to defineyour own Click script. Instead of using FLASK_APP and letting Flask loadyour application, you can create your own Click object and export it as aconsole script entry point.
Create an instance of FlaskGroup and pass it the factory:
Define the entry point in setup.py:
Install the application in the virtualenv in editable mode and the customscript is available. Note that you don’t need to set FLASK_APP.
Errors in Custom Scripts
When using a custom script, if you introduce an error in yourmodule-level code, the reloader will fail because it can no longerload the entry point.
The flask command, being separate from your code, does not havethis issue and is recommended in most cases.
PyCharm Integration¶
PyCharm Professional provides a special Flask run configuration. Forthe Community Edition, we need to configure it to call the flaskrunCLI command with the correct environment variables. These instructionsshould be similar for any other IDE you might want to use.
In PyCharm, with your project open, click on Run from the menu bar andgo to Edit Configurations. You’ll be greeted by a screen similar tothis:
There’s quite a few options to change, but once we’ve done it for onecommand, we can easily copy the entire configuration and make a singletweak to give us access to other commands, including any custom ones youmay implement yourself.
Click the + (Add New Configuration) button and select Python. Givethe configuration a name such as “flask run”. For the flaskruncommand, check “Single instance only” since you can’t run the servermore than once at the same time.
Select Module name from the dropdown (A) then input flask.
The Parameters field (B) is set to the CLI command to execute(with any arguments). In this example we use run, which will runthe development server.
You can skip this next step if you’re using Environment Variables From dotenv. We need toadd an environment variable (C) to identify our application. Clickon the browse button and add an entry with FLASK_APP on the left andthe Python import or file on the right (hello for example). Add anentry with FLASK_ENV and set it to development.
Next we need to set the working directory (D) to be the folder whereour application resides.
Pycharm Community Flask Run
If you have installed your project as a package in your virtualenv, youmay untick the PYTHONPATH options (E). This will more accuratelymatch how you deploy the app later.
Click Apply to save the configuration, or OK to save and close thewindow. Select the configuration in the main PyCharm window and clickthe play button next to it to run the server.
Pycharm Community Flask
Now that we have a configuration which runs flaskrun from withinPyCharm, we can copy that configuration and alter the Script argumentto run a different CLI command, e.g. flaskshell.