Develop Reference

Env. Variables do not set FLASK_APP - Windows Error [duplicate]

I want to know the correct way to start a flask application. The docs show two different commands:
$ flask -a sample run
and
$ python3.4 sample.py
produce the same result and run the application correctly.
What is the difference between the two and which should be used to run a Flask application?

The flask command is a CLI for interacting with Flask apps. The docs describe how to use CLI commands and add custom commands. The flask run command is the preferred way to start the development server.
Never use this command to deploy publicly, use a production WSGI server such as Gunicorn, uWSGI, Waitress, or mod_wsgi.
As of Flask 2.2, use the --app option to point the command at your app. It can point to an import name or file name. It will automatically detect an app instance or an app factory called create_app. Use the --debug option to run in debug mode with the debugger and reloader.
$ flask --app sample --debug run
Prior to Flask 2.2, the FLASK_APP and FLASK_ENV=development environment variables were used instead. FLASK_APP and FLASK_DEBUG=1 can still be used in place of the CLI options above.
$ export FLASK_APP=sample
$ export FLASK_ENV=development
$ flask run
On Windows CMD, use set instead of export.
> set FLASK_APP=sample
For PowerShell, use $env:.
> $env:FLASK_APP = "sample"
The python sample.py command runs a Python file and sets __name__ == "__main__". If the main block calls app.run(), it will run the development server. If you use an app factory, you could also instantiate an app instance at this point.
if __name__ == "__main__":
app = create_app()
app.run(debug=True)
Both these commands ultimately start the Werkzeug development server, which as the name implies starts a simple HTTP server that should only be used during development. You should prefer using the flask run command over the app.run().

Latest documentation has the following example assuming you want to run hello.py(using .py file extension is optional):
Unix, Linux, macOS, etc.:
$ export FLASK_APP=hello
$ flask run
Windows:
> set FLASK_APP=hello
> flask run

you just need to run this command
python app.py
(app.py is your desire flask file)
but make sure your .py file has the following flask settings(related to port and host)
from flask import Flask, request
from flask_restful import Resource, Api
import sys
import os
app = Flask(__name__)
api = Api(app)
port = 5100
if sys.argv.__len__() > 1:
port = sys.argv[1]
print("Api running on port : {} ".format(port))
class topic_tags(Resource):
def get(self):
return {'hello': 'world world'}
api.add_resource(topic_tags, '/')
if __name__ == '__main__':
app.run(host="0.0.0.0", port=port)

The very simples automatic way without exporting anything is using python app.py see the example here
from flask import (
Flask,
jsonify
)
# Function that create the app
def create_app(test_config=None ):
# create and configure the app
app = Flask(__name__)
# Simple route
#app.route('/')
def hello_world():
return jsonify({
"status": "success",
"message": "Hello World!"
})
return app # do not forget to return the app
APP = create_app()
if __name__ == '__main__':
# APP.run(host='0.0.0.0', port=5000, debug=True)
APP.run(debug=True)

For Linux/Unix/MacOS :-
export FLASK_APP = sample.py
flask run
For Windows :-
python sample.py
OR
set FLASK_APP = sample.py
flask run

You can also run a flask application this way while being explicit about activating the DEBUG mode.
FLASK_APP=app.py FLASK_DEBUG=true flask run

Is there a way to run flask in debug mode using the `flask run` command without setting environment variables?

I'm trying to run a flask application in debug mode (or at least a mode where it will reload after changing the files).
I'm aware of export FLASK_ENV=development, however I am working on a university online development environment, and I lose the environment variables every time the site reloads, which while not the end of the world, is slightly annoying, and I'd rather avoid having to keep typing it (lazy I know).
If I include the following, and run using python3 main.py, debug mode is activated, however when using flask run, debug remains off.
if __name__ == "__main__":
app.run(debug=True)
However, as I understand it, using the flask run command is the preferred way to launch the app, not using python app.py.
I've found ideas such as including the following, however none of these have activated debug mode, so I'm wondering whether it is even possible:
app.config['ENV'] = 'development'
app.config['DEBUG'] = True
app.config['TESTING'] = True
I've simplified my code to the following to see if it was an error in my original piece, but it doesn't seem to be:
from flask import Flask
app = Flask(__name__)
app.config['ENV'] = 'development'
app.config['DEBUG'] = True
app.config['TESTING'] = True
#app.route('/')
def home():
return '<h1>debugging!</h1>'
if __name__ == "__main__":
app.run(debug=True)

In short, there does not seem to be a way of using flask run how I want without assigning environment variables, however using a .flaskenv file will allow environment variables to be loaded at run time.
The .flaskenv file for example could include the following ENVs among others to be loaded:
FLASK_APP=main:app
FLASK_ENV=development
FLASK_DEBUG=1
Note - this does require python-dotenv to be installed to use.
All credit to #cizario who answered here with some more detail:
https://stackoverflow.com/a/64623193/12368419

Well, when it's Flask 2.2 or later, you can just do
flask --debug run
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on http://127.0.0.1:5000
Press CTRL+C to quit
* Restarting with stat
* Debugger is active!
* Debugger PIN: 560-342-853

Error launching Flask app with error "Failed to find Flask application"

I'm new to Flask. To launch the flask app, I did python -m flask run but I repeatedly get the error:
Failed to find Flask application or factory in module "app". Use "FLASK_APP=app:name to specify one.
I am using a virtualenv on a Windows 10 machine
from flask import Flask
app = Flask(__name__)
#app.route('/')
def index():
return "Hello, World!"
if __name__ == '__main__':
app.run(debug=True)
I expected a web server to start and to be able to navigate to localhost http://127.0.0.1:5000/ where I could view Hello, World! on my browser, but that never happened.

Instead of just "flask" use FLASK_APP=theflaskapp.py, like what Marco suggested:
env FLASK_APP=theflaskapp.py python -m flask run
This should fix it, if not, make sure you are executing the command to run the script in the same directory as it. You should also check if the problem is in flask or not by running "python theflaskapp.py" (In the same directory as the flask app still) and see if it works at all.

Reproducing the problem, and fixing it
Hello, I have reproduced the problem
This is the error code:
Error: Failed to find Flask application or factory in module
"src.app". Use "FLASK_APP=src.app:name to specify one.
Steps of reproducing the error:
Create a file called app.py
inside app.py put this code:
from flask import Flask
def create_app():
app = Flask("abc")
#app.route('/')
def hello_world():
return 'Hello, World!'
Or let the file be empty, like this:
# This is an empty file
# There is no flask application here
Inside CLI run these commands:
export FLASK_APP=app.py
flask run
watch the error appear on the screen
Solution 1 :
make the function return the app
Clearly create a variable called app and make it equal to the return value of the function, like this:
from flask import Flask
def create_app():
app = Flask(__name__)
#app.route('/')
def hello_world():
return 'Hello, World!'
return app
app = create_app()
Solution 2: Get the app outside of the function:
from flask import Flask
app = Flask("abc")
#app.route('/')
def hello_world():
return 'Hello, World!'

solution for flask Error: Could not locate a Flask application. You did not provide the "FLASK_APP" environment variable, and a "wsgi.py" or "app.py" module was not found in the current directory.
on windows when you tried set FLASKAPP=appname.py if your using PowerShell and if get the above error try this 👇👇
$env:FLASK_APP = "filename"
$env:FLASK_ENV = "development"
Flask run
try it if your having trouble launching the flask app.

You need to specify what file you want to work with. Try this.
For Windows:
set FLASK_APP=app.py
python -m flask run
For Mac OS and Linux:
export FLASK_APP=app.py
python -m flask run

I had a similar problem. It seems to work fine from the command prompt with python app.py. However, it would fail to launch with VS Code Debug.
The trick was to add:
server = app.server
before calling the app.run_server() portion

super simple in my case, and almost stupid...I had forgotten to save the file (CTRL+S), and I got exactly the same error. Once I saved the file, it worked directly!

Instead of providing a super straightforward "try this" suggestion, I'd recommend going straight to the flask source code to where this exception gets thrown, and reverse engineer from there. https://github.com/pallets/flask/blob/main/src/flask/cli.py#L78-L82
You can open this in your editor by going to the site-packages/flask/cli.py file and setting breakpoints around where this error gets thrown, and poke around from there.

Another working option is executing this command instead of flask run :
flask run --host=0.0.0.0
I had the same issue and I tried all the mentioned answers here but couldn't work finally this did the trick.

I'm getting the same error. The problem is you have to set the environment variable FLASK_APP in current project.
However, I have easiest way to solve this problem. Instead of using flask run command you can use python app.py.
"app.py" is your application entry point.

The simplest way to run your app without getting any issue is to create the app then run python app.py
from flask import (
Flask,
jsonify
)
# Function that create the app
def create_app(test_config=None ):
# create and configure the app
app = Flask(__name__)
# Simple route
#app.route('/')
def hello_world():
return jsonify({
"status": "success",
"message": "Hello World!"
})
return app # do not foget to return the app
APP = create_app()
if __name__ == '__main__':
# APP.run(host='0.0.0.0', port=5000, debug=True)
APP.run(debug=True)

On venv and my Windows10 only this syntax works:
set FLASK_APP=name_of_file:name_of_var_app
If file is application.py and 'app = Flask(__name__)',
run:
set FLASK_APP=application:app

You should change the name of the file, I have the same problem. So, I changed the name of the app file and It works for me. At first my app file name is 'socket.py' and I change it to 'app.py'.

My problem was that the python file didn't have execute permissions:
chmod a+x app.py

Similar issue! I was running the code in vs code. Installed python extension and after selecting a different python interpreter( in my case 3.10.5 64 bit), got a play button on the top right corner of my vs code interface.
That solved the issue for me.

In my case was a very simple issue, the activate.bat file was setup as Macintosh (CR) I changed to Windows (CR LF) and that worked for me.
Explanation: In windows OS, for the instruction to take effect, for example [set FLASK_ENV = development] a strong carriage return is needed, such as the (CR LF), that is what I could verify in my case. You can try to run the SET instruction in the console, cmd, and check if the FLASK settings are reflected. I understand that it is more a problem of the configuration of the environment and not of the application itself.

Try removing the spaces from this line of code, this is what fixed it for me when I had this error:
app=Flask(__name__)

Flask at first run: Do not use the development server in a production environment

I installed the Flask plugin in PyCharm Community Edition and I just have this simple code in my flask app:
from flask import Flask
app = Flask(__name__)
#app.route('/')
def index():
return '<h1>Hello!</h1>'
if __name__ == "__main__":
app.run(debug=True)
And I get this message:
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead
* Restarting with stat
* Debugger is active!
* Debugger PIN: 123-456-789
* Running on http://127.0.0.1:5000/
Why am I getting this error when I run Flask?
A previous version of the message read "Do not use the development server in a production environment."

For deploying an application to production, one option is to use Waitress, a production WSGI server.
Here is an example of using waitress in the code.
from flask import Flask
app = Flask(__name__)
#app.route("/")
def index():
return "<h1>Hello!</h1>"
if __name__ == "__main__":
from waitress import serve
serve(app, host="0.0.0.0", port=8080)
Running the application:
$ python hello.py
Waitress also provides a command line utility waitress-serve. To use that, you can modify the code to the following:
from flask import Flask
app = Flask(__name__)
#app.route("/")
def index():
return "<h1>Hello!</h1>"
def create_app():
return app
Then we can use waitress-serve as the following:
waitress-serve --port=8080 --call hello:create_app
And BTW, 8080 is the default port.
To validate the deployment, open a separate window:
% curl localhost:8080
<h1>Hello!</h1>%
Or directly in your browser http://localhost:8080/.
Other alternatives to deploy your app include Gunicorn and uWSGI. For more details, please refer to the flask deploy doc.

As of Flask 2.2, the development server always shows this warning, it is not possible to disable it. The development server is not intended for use in production. It is not designed to be particularly efficient, stable, or secure. Use a production WSGI server instead. See the deployment docs from Flask for more information.
That warning is just a warning though, it's not an error preventing your app from running. If your app isn't working, there's something else wrong with your code.
That warning applies to the development server, not Flask itself. The Flask framework is appropriate for any type of application and deployment.

To avoid these messsages, inside the CLI (Command Line Interface), run these commands.
export FLASK_APP=app.py
export FLASK_ENV=development
export FLASK_DEBUG=0
flask run

If for some people (like me earlier) the above answers don't work, I think the following answer would work (for Mac users I think)
Enter the following commands to do flask run
$ export FLASK_APP=hello.py
$ export FLASK_ENV=development
$ flask run
Alternatively you can do the following (I haven't tried this but one resource online talks about it)
$ export FLASK_APP=hello.py
$ python -m flask run
source: For more

Try gevent:
from flask import Flask
from gevent.pywsgi import WSGIServer
app = Flask(__name__)
#app.route('/api', methods=['GET'])
def index():
return "Hello, World!"
if __name__ == '__main__':
# Debug/Development
# app.run(debug=True, host="0.0.0.0", port="5000")
# Production
http_server = WSGIServer(('', 5000), app)
http_server.serve_forever()
Note: Install gevent using pip install gevent

This worked for me on windows:
$env:FLASK_APP="flask_project.py"
$env:FLASK_ENV="development"
flask run
flask_project.py is on the same path as my virtual environment.

flask.cli.NoAppException: The file/path provided (new_app.py) does not appear to exist

I keep getting this error flask.cli.NoAppException: The file/path provided (new_app.py) does not appear to exist. Please verify the path is correct. If app is not on PYTHONPATH, ensure the extension is .py it goes away after I restart the Flask server.
I am running flask run in the correct directory where my app is. This just started happening after working for 2 weeks. I've read that it could be due to an import error, but I am not finding any modules that are not installed on my virutalenv.
from flask import Flask
app = Flask(__name__)
app.debug=True

Most likely you haven't set the FLASK_APP environment variable.
To run the application you can either use the flask command or
python’s -m switch with Flask. Before you can do that you need to tell
your terminal the application to work with by exporting the FLASK_APP
environment variable:
$ export FLASK_APP=hello.py
$ flask run * Running on http://127.0.0.1:5000/
If you are on Windows you need to use set
instead of export.
Alternatively you can use python -m flask:
$ export FLASK_APP=hello.py
$ python -m flask run * Running on http://127.0.0.1:5000/
EDIT
If you have FLASK_APP set then try adding this to new_app.py
app.run(debug=True, port=8800)
Or if you're on Windows:
if __name__ == '__main__':
app.run(debug=True, port=8800)
And then just execute the app with python new_app.py.