Basic Structure of Flask Application

Introduction

In this article, we will learn about the enriched parts of a Flask application. The initially and most imperative decision that we will ever make for our project is how can organize it. We should ask ourselves following questions;

What the best Flask project structure is?
What will our project need?
Is it changed from other project’s we’ve done already?
How can we have one single project structure that will make sure our project will not have a problem?
How can that project at the same time will likewise permit us to develop and keep emergent?

Description

Altogether Flask applications need to create an application instance.
The web server clearances all requests it obtains from clients to this object.
Those are for controlling and using a protocol called Web Server Gateway Interface (WSGI).
The application instance is created as an object of class Flask.
That is commonly created as follows:

from flask import Flask
app = Flask(__name__)

The first necessary argument to the Flask class constructor is the name of the main module or package of the application.
For best applications, Python’s __name__ variable is the right value.
Flask practices this argument to regulate the root path of the application.
Therefore that it far along may find resource files relative to the location of the application.

Routes and View Functions

Clients for example web browsers send requests to the web server.
That in sequence sends them to the Flask application instance.
The application instance requires to identify what code needs to run for each URL requested.
Therefore it saves a mapping of URLs to Python functions.
The relationship between a URL and the function that grips it is named a route.
The most suitable method to define a route in a Flask application is via the app.route decorator.
That is unprotected by the application instance.
That registers the decorated function as a route.
The following illustration demonstrates how a route is stated using this decorator:

@app.route('/')
def index():
return '<h1>Hello World!</h1>'

The preceding illustration registers the function index () by way of the handler for the application’s root URL.
Navigating to http://www.example.com on our browser would trigger index () to run on the server if this application were set up on a server related with the www.example.com domain name.
The return value of this function the client receives is known as the response.
The response is the document that is showed to the user if the client is a web browser.
Functions corresponding index () are named view functions.
A response returned with a view function may be a simple string with HTML content. It may also take extra difficult forms.
Some URLs for services have variable sections. For instance, the URL for our Facebook profile page is http://www.facebook.com/<our-name>.
Therefore our username is part of it.
Flask supports these types of URLs by a special syntax in the route decorator.
The below example describes a route that has a vibrant name component.

@app.route('/user/<name>')
def user(name):
return '<h1>Hello, %s!</h1>' % name

The part bounded in angle brackets is the dynamic part.
Consequently any URLs matches the static portions will be mapped to this route.
Flask sends the forceful component as an argument when the view function is raised.
This argument is used to make a personalized greeting as a response in the prior example view function.
The active components in routes are strings by default.
On the other hand may also be defined with a type.
For instance, route /user/<int:id> will match only URLs that have an integer in the id active segment.
Flask provisions type’s int, float, and path for routes.
The path type similarly indicates a string.
That consider slashes as part of the forceful component.

Server Startup

The application instance has a run method.
That presents Flask’s integrated development web server.

if __name__ == '__main__':
app.run(debug=True)

The __name__ == ‘__main__’ Python idiom is used to make sure that the development web server is started only when the script is performed openly.
It is expected that the parent script will launch a different server when the script is imported by another script.
Therefore, the app.run() call is missed.
The server goes into a loop.
That waits for requests and services them when starts up.
This loop continues up to the application is stopped.
For instance by hitting Ctrl-C.
There are many option arguments that may be given to app.run() to configure the mode of operation of the web server.
It is suitable to allow debug mode during development.
That between other things activates the debugger and the reloader.
This is completed by passing the argument debug set to True.

A Complete Application

We have learnt about the different parts of a Flask web application up till now.
Currently, we will write those parts.
The complete hello.py application script is associated with three parts defined prior joint in a single file.
The application is shown in the following example.

Example: hello.py: A complete Flask application

from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return '<h1>Hello World!</h1>'
if __name__ == '__main__':
app.run(debug=True)

Make assure the earlier created virtual environment is activated to run the application and has Flask installed.
At the present open the web browser and type http:// 127.0.0.1:5000/ in the address bar.
Below figure displays the web browser after linking to the application.

At that time launch the application with the following command:

(venv) $ python hello.py
* Running on http://127.0.0.1:5000/
* Restarting with reloader

The application will not recognize how to handle it if we type any other URL.
That will return an error code 404 to the browser.
That is used to error that we get when navigate to a web page that does not exist.