DEV Community: nandamtejas

Implementing Flask application using Object Oriented Programming (OOP's) [PART-2]

nandamtejas — Sun, 05 Dec 2021 16:33:09 +0000

Please click here to check my first part [part-1] of this blog

In previous section we have discussed about

About web Framework
About Flask framework
HTTP methods used in Flask framework
A minimal Flask application
A new approach using OOP's with Flask Framework

Now we are going to discuss further deep going into the concept

In the previous part we have discussed about the Flask framework which can be worked using classes and object, but not quitely.
We have just created a FlaskAppWrapper class which takes the flask app and allows us to add the endpoints and routing.

The FlaskAppWrapper class make sure functionality of add_endpoint method which is used to routing the method with appropriate endpoint given as an arguments passed to it.

In this section we are going to discuss about

Routing
Dynamic Routing
EndpointHandler class
How EndpointHandler class helps in routing

Routing

App routing is used to map the specific URL with the associated function that is intended to perform some task.
The associated function is called handler in our case.

The add_endpoint method add the new endpoint for a given handler should be a callable function executed when you invoke the url with a given endpoint should be callable type rather you pass any arguments to it or not uses add_url_rule(<url_rule>, <endpoint>, <view_function>) which we have discussed before in the previous section which is used to perform routing for flask application.

Here,

<url_rule> is the endpoint
<endpoint> is the endpoint name which rather is the name of the handler and
<view_function> is the associated function, rather say handler which is executed when we call the URL with the registered endpoint.

If you pass any arguments to that callable handler, you have the request.view_args method which should be imported from the flask module which will will store the arguments.

Dynamic routing

Here we use a concept of Dynamic routing. Flask provides the functionality of the dynamic routing.
It is the process of getting dynamic data(variable names) in the URL and then using it.
In Flask you can have use following converters to convert dynamic input from the URL.

string
int
float
path ( It is simple a string but also accepts shashles in the URL)
uuid

Dynamic URL's in Flask play an important role in the ability to create unique URL's that aren't hard-coded into our application.

EndpointHandler class

To pass the arguments, we have to create another class name EndpointHandler which is responsible for executing the handler according to the endpoint.

class EndpointHandler(object):

    def __init__(self, action):
        self.action = action 

    def __call__(self, *args, **kwargs):
        response = self.action(*args, **kwargs)
        return response

Let's save in handler.py file.

In the above code we have created EndpointHandler class where the instance of that class is callable. Callable in the sense that instance of the class act's similar to the function. The __call__ method makes the instance callable and executes what inside the __call__ method.

Here in the class EndpointHandler takes the action which will be the any function or any method from class.

Let's test with any built-in function in python.
There are so many built-in function in python such as print, list, len etc..

Let's try with print as an argument of an instance of the class.

handler = EndpointHandler(print)
handler("Hello world")

The output will be like this

C:\>python handler.py
Hello world

That means print function is an action of handler which is an instance of a class and it is callable and prints anything we pass as an arguments. That means that handler instance has the functionality of the print function and acts as the same function we passed into it.

We have to check whether it works on user defined function.

Let's take an example of the function called action shown below.

def action(a,b):
    """
    This action is an example function which takes the two parameter a and b of Integer type and returns the sum of a and b
    """
    return a + b

Now Let's make an instance of the class name handler and pass the action function as arguments in class.

handler = EndpointHandler(action)
result = handler(5, 6)
print(result)

You will get the output as the sum of 5 and 6 which is 11. That means we have concluded that the EndpointHandler class is the callable class which takes the associative function which is stored in the action parameter, performs the same functionality with the action.

How `EndpointHandler class` will help in `Routing` in `flask`?

We have the EndpointHandler class which we have discussed in the previous part of the blog is shown below, the only change is we are going to pass the endpoint of EndpointHandler

class FlaskAppWrapper(object):

    def __init__(self, app, **configs):
        self.app = app
        self.configs(**configs)

    def configs(self, **configs):
        for config, value in configs:
            self.app.config[config.upper()] = value

    def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET'], *args, **kwargs):
        self.app.add_url_rule(endpoint, endpoint_name, EndpointHandler(handler), methods=methods, *args, **kwargs)

    def run(self, **kwargs):
        self.app.run(**kwargs)

There are some changes should be done in EndpointHandler class when you are working in flask shown below.

from flask import request, make_response

class EndpointHandler(object):

    def __init__(self, action):
        self.action = action 

    def __call__(self, *args, **kwargs):
        response = self.action(*args, **request.view_args)
        return make_response(response)

where,

request.view_args A dict of view arguments that matched the request. If an exception happened when matching, this will be None.
make_response Convert the return value from a view function to an instance of response_class.

Now, We have to test our FlaskAppWrapper with a new function called action and we are going to pass name argument to it

def action(name):
    """
    This function takes `name` argument and returns `Hello name`.
    """
    return "Hello " + name

Now we are going to define the flask app and we are going to register the action function.

flask_app = Flask(__name__)
app = FlaskAppWrapper(flask_app)

# register the action function to app

app.add_endpoint('/action/<string:name>', 'action', action)

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

The whole code looks like

from flask import Flask, request, make_response

class EndpointHandler(object):

    def __init__(self, action):
        self.action = action 

    def __call__(self, *args, **kwargs):
        response = self.action(*args, **request.view_args)
        return make_response(response)

class FlaskAppWrapper(object):

    def __init__(self, app, **configs):
        self.app = app
        self.configs(**configs)

    def configs(self, **configs):
        for config, value in configs:
            self.app.config[config.upper()] = value

    def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET'], *args, **kwargs):
        self.app.add_url_rule(endpoint, endpoint_name, EndpointHandler(handler), methods=methods, *args, **kwargs)

    def run(self, **kwargs):
        self.app.run(**kwargs)

def action(name):
    """
    This function takes `name` argument and returns `Hello <name>`.
    """
    return "Hello " + name

flask_app = Flask(__name__)
app = FlaskAppWrapper(flask_app)

# register the action function to app

app.add_endpoint('/action/<string:name>', 'action', action)

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

The code above shown works like this

Firstly, I have imported some requirements from Flask framework.
We have created the EndpointHandler class which is responsible for managing to pass the extra arguments or parameters to be passed when an action is invoked.
Then we have worked with the FlaskAppWrapper class and we have discussed about it in the previous part and we made some changes which is menctioned in the above discussion.
To test the FlaskAppWrapper class we have defined the action function which takes the name as the parameter and returns the string as Hello <name>.
We have defined the flask_app as the instance of the Flask class and this flask_app instance is given to our FlaskAppWrapper class and this instance is stored in app.
We have registered the action function to the app instance using the add_endpoint method by giving the appropriate endpoint to the action function. In this case /action/<string:name> is the endpoint for the action function that means, when we invoked the Flask app url with the endpoint above executes the action function which we have registered and we are going to see in the output section.
We are going to run the file using app.run() method and we see the output

We save the above code as example6.py and run using the command

C://> python example6.py

And then we are going to click on the url shown below.

We are heading over to http://127.0.0.1:5000/action/Tejas in any search engines (I'm using Google) and we get the output as shown below

We have observed that after heading to the url above, You get the output as Hello Tejas and Tejas is the name I have passed over the action function.

We will check with other name say Subash.
Head over to http://127.0.0.1:5000/action/Subash the output is as shown below

A broad example

Now we will test our application by adding many actions to our FlaskAppWrapper class.

The whole code looks like

from flask import Flask, request, make_response

class EndpointHandler(object):

    def __init__(self, action):
        self.action = action 

    def __call__(self, *args, **kwargs):
        response = self.action(*args, **request.view_args)
        return make_response(response)

class FlaskAppWrapper(object):

    def __init__(self, app, **configs):
        self.app = app
        self.configs(**configs)

    def configs(self, **configs):
        for config, value in configs:
            self.app.config[config.upper()] = value

    def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET'], *args, **kwargs):
        self.app.add_url_rule(endpoint, endpoint_name, EndpointHandler(handler), methods=methods, *args, **kwargs)

    def run(self, **kwargs):
        self.app.run(**kwargs)

def action1(name):
    """
    This function takes `name` argument and returns `Hello name`.
    """
    return "Hello " + name

def action2():
    """
    This function returns "Action2 invoked"
    """

    return "Action2 invoked"

def action3(number):
    """
    This function returns the cube of the number 
    """
    return "Cube of {0} is {1}".format(number, number**3)



flask_app = Flask(__name__)
app = FlaskAppWrapper(flask_app)

# register all action functions to app

app.add_endpoint('/action1/<string:name>', 'action1', action1)
app.add_endpoint('/action2/', 'action2', action2)
app.add_endpoint('/action3/<int:number>', 'action3', action3)

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

From above code, we have registered the 3 action functions to our app.

action1 takes the name parameter from the endpoint and returns Hello <name>.
action2 returns Action2 invoked.
action3 takes the number parameter from the endpoint and returns the cube of the number.

After running the above code we get the output shown below

Heading over http://127.0.0.1:5000/action1/Tejas We get the output as shown below

Heading over http://127.0.0.1:5000/action2/ we get the output as

Heading over http://127.0.0.1:5000/action3/10 we get the output as

Same url, different endpoints and different functions are invoked and executed.

We are going to declare that any number of actions can be registered in our app and I conclude that the FlaskAppWrapper class works as good as the Flask application and this is the approach I have researched.

Summary

We have discussed in this part about

Routing and Dynamic Routing in Flask
Handling the flask endpoint using EndpointHandler class
Discussed and made some changes in the FlaskAppWrapper class.
Tested the updated code with the concept of Dynamic routing.

Implementing Flask application using Object Oriented Programming (OOP's) [Part-1]

nandamtejas — Fri, 05 Nov 2021 09:09:25 +0000

Content

Introduction to Flask Framework
Why Flask framework?
HTTP methods used in Flask
A Minimal application of Flask
A new approach using OOP's concept with Flask

Introduction to Flask Framework

Flask is a micro web framework written in Python.
It is classified as a microframework because it does not require particular tools or libraries.
It has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions.
Flask supports extensions that can add application features as if they were implemented in Flask itself.
Extensions exist for object-relational mappers, form validation, upload handling, various open authentication technologies and several common framework related tools.
Applications that use the Flask framework include Pinterest and LinkedIn.

Why Flask framework?

Web apps are developed to generate the content based on retrieved data that changed on the basis of the user's interaction with the browser. The server is responsible for querying, creating, updating and also deleting data. This makes the web applications slower and slower and more complicated to deploy than static websites for simple applications. There are two primary coding environments for the whole web app ecosystem. This article will give an overview of the Python Flask Framework and Its best practices.

Client-Side Scripting

The code executed on the user’s browser visible to anyone who has access to the system, generating the first results.

Server-Side Scripting

This type of code is run on the backend on a web server. To enable developers to design, build, maintain, host web apps over the internet, a web framework necessary.

What is web framework?

A web framework is the architecture containing tools, libraries and functionalities suitable to build and maintain massive web projects using fast and efficient approach.

To create the server-side web application, we need to use the server-side programming language.

python is one of the server-side language which is the home to numerous such frameworks i.e; Django and Flask.

We choose to work with Flask framework because it is suited due to

Built-in development server, fast debugger.
Integrated support for unit testing.
RESTful request dispatching.
Support for secure cookies.
Lightweight and modular design allows for a flexible framework.

HTTP methods used in Flask

Request

To process incoming data in Flask, you need to use the request object, including mime-type, IP address, and data. HEAD: Un-encrypted data sent to server w/o response.

GET

Sends data to the server requesting a response body.

POST

Read form inputs and register a user, send HTML data to the server are methods handled by the route. Flask attaches methods to each route so that different view functions can handle different request methods to the same URL.

Response

Flask invokes a view function. It has to return a response value to the client. HTTP requires it to be more than a string response, a status code.

Informational – 1xx
Successful – 2xx
Redirection – 3xx
Client Error – 4xx
Server Error – 5xx

A Minimal application of Flask

As we know that the Flask framework is one of the python's framework which concentrates on the field of WEB development either in Backend or Full stack WEB development.



from flask import Flask

app = Flask(__name__)

@app.route('/', methods=['GET'])
def index():
    return "Hello World!"

if __name__ == "__main__":
    app.run()

As we can see from the above code snippet,

First we have imported the Flask
Next we have created the instance of the class as app
We then use the route() decorator to tell the Flask what url should trigger our function
The function returns the message that we wanted to display in the user's browser.
We then save the above code as hello.py and run the application using the command python hello.py. This launches a very simple builtin server, which is good enough for testing.

Now head over to http://127.0.0.1:5000/, and you should see your hello world greeting.

From the above code snippet, we have used the route method to tell the Flask what url should trigger the function. Well there is another method of triggering the url's using add_url_rule() method.
Flask code snippet using add_url_rule() method



from flask import Flask

app = Flask(__name__)

def hello_world():
    return "<p>Hello, World!</p>"

# The hello_world function is triggered at endpoint '/'
app.add_url_rule('/', view_func=hello_world)

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

The above code snippet is slightly different from the 1st one, Here we didn't use the decorator instead we have used the add_url_rule method which works the same.
Now head over to http://127.0.0.1:5000/, and you should see your hello world greeting.

A new approach using OOP's concept with Flask

Flask application using the classes
Sounds Interesting!!

Flask using Classes and Objects?

Let's see how can we approach this!

Consider the small function which returns the Hello world as an action



def action():
    """ This function returns the Hello world """
    return "Hello world!"

The above function returns Hello World, That need to be called by url

Let us do one thing, We just create the Flask app wrapper class which wraps the functionality of the Flask app



class FlaskAppWrapper(object):

    def __init__(self, app, **configs):
        self.app = app
        self.configs(**configs)

    def configs(self, **configs):
        for config, value in configs:
            self.app.config[config.upper()] = value

    def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET'], *args, **kwargs):
        self.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods, *args, **kwargs)

    def run(self, **kwargs):
        self.app.run(**kwargs)

In the above class FlaskAppWrapper, mainly there are 3 methods, i.e; configs, add_endpoint and run

- configs adds all the configurations of the flask app
- add_endpoint adds the endpoint url and the handler function to tell the Flask app to trigger the handler function
- run which runs the Flask app

Now we have to initialize the FlaskAppWrapper as an app and add the action function to the flask app.



from flask import Flask

flask_app = Flask(__name__)

app = FlaskAppWrapper(flask_app)

def action():
    """ Function which is triggered in flask app """
    return "Hello World"

# Add endpoint for the action function
app.add_endpoint('/action', 'action', action, methods=['GET'])
if __name__ == "__main__":
    app.run(debug=True)

Now we save the above code as class_hello.py and run the above code by using the command python class_hello.py and check the output.

After heading over to the url http://127.0.0.1:5000/action , we get to see Hello world in the display of the browser. That means the flask app using the classes method is working. But still we have to make changes in our code.

So the whole code looks like



from flask import Flask

class FlaskAppWrapper(object):

    def __init__(self, app, **configs):
        self.app = app
        self.configs(**configs)

    def configs(self, **configs):
        for config, value in configs:
            self.app.config[config.upper()] = value

    def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET'], *args, **kwargs):
        self.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods, *args, **kwargs)

    def run(self, **kwargs):
        self.app.run(**kwargs)

flask_app = Flask(__name__)

app = FlaskAppWrapper(flask_app)

def action():
    """ Function which is triggered in flask app """
    return "Hello World"

# Add endpoint for the action function
app.add_endpoint('/action', 'action', action, methods=['GET'])
if __name__ == "__main__":
    app.run(debug=True)

You can see the output below.

So Why using classes and objects?

This is the good question you may get, we can use only functions and it works well by using functions. But why using classes?

The answer is I don't know!

There are some problems which can be approached by one or many methods.

In our case using classes to define the endpoints for the web application in Flask, reduces the number of functions to be used for the same endpoint. These functions can be wrapped up in a single object by creating classes and giving a common endpoint for that class makes all the methods in that class to be executed in that method.

This is the 1st part of my current blog.
The second part will be released soon.

Hope you all like this!!

Summary

We have discussed about

Web framework
Flask framework
HTTP methods
minimal application of Flask
Flask using classes

Link to my second blog.

DEV Community: nandamtejas

Implementing Flask application using Object Oriented Programming (OOP's) [PART-2]

Routing

Dynamic routing

EndpointHandler class

How EndpointHandler class will help in Routing in flask?

A broad example

Summary

Implementing Flask application using Object Oriented Programming (OOP's) [Part-1]

Content

Introduction to Flask Framework

Why Flask framework?

Client-Side Scripting

Server-Side Scripting

What is web framework?

HTTP methods used in Flask

Request

GET

POST

Response

A Minimal application of Flask

A new approach using OOP's concept with Flask

So Why using classes and objects?

Summary

How `EndpointHandler class` will help in `Routing` in `flask`?