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 --help
option will give more information about any commands and options.On Linux, it is possible to create 2 separate files: test and Test, while on Mac these filenames would actually refer to the same underlying file. This can lead to problems where an app works correctly on a Mac (where the file contents are shared) but fails when run in Linux in production (where the file contents are distinct). When the.bashprofile or.zsh file is created you are ready to enter your alias commands. So here I am using the alias ‘l’ to alias the command ‘ls -lah’ alias l='ls -lah' In nano ‘control+o’ to write the file out and ‘control+x’ to exit the file. Refresh the shell environment by entering the command below: source /.bash.
Even if you are running it from bash, it is still running from an AppleScript context. I don't know the exact mechanisms of where this firewall is, but it causes the operating system to consider your script to be 3rd party code. Apple isn't going to allow your app to find out this information. Before you do, remember to always run brew update and brew doctor to make sure your system is still ready to brew. To upgrade your existing packages, run brew upgrade. If you installed the full Xcode package, remember that when you update it via the Mac App Store, you might also need to update the Command Line Tools via Xcode's Preferences. When you include the line “#!/bin/bash” at the very top of your script, the system knows that you want to use bash as an interpreter for your script. Thus, you can run the hello.sh script directly now without preceding it with bash.
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_APP
environment 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=hello
The 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/hello
Sets the current working directory to
src
then imports hello
.FLASK_APP=hello.web
Imports the path
hello.web
.FLASK_APP=hello:app2
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 named
app
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 named
script_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
Mac Bash Script
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¶
Windows 10 Bash Script
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 the
FLASK_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.Mac sleep timer app. 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
flask
from 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 pattern
FLASK_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
activate
script. 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
flask
command. 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
cli
command()
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.commands
entry 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. How to uninstall an app on a mac mini. 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
flaskrun
CLI 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
flaskrun
command, 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.
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.
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
.