Building RESTful APIs With Flask: An ORM With SQLAlchemy
source link: https://code.tutsplus.com/tutorials/building-restful-apis-with-flask-an-orm-with-sqlalchemy--cms-26706
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Building RESTful APIs With Flask: An ORM With SQLAlchemy
In the first part of this three-part tutorial series, we saw how to write RESTful APIs using Flask as the web framework. The previous approach provided a lot of flexibility but involved writing a lot of code that otherwise could have been avoided in more generic cases.
In this part, we will use a Flask extension, Flask-Restless, which simply generates RESTful APIs for database models defined with SQLAlchemy. I will take the same sample application as in the previous part to maintain context and continuity. The full source code for the previous project can be found in our GitHub repo.
Installing Dependencies
While continuing with the application from the first part, we need to install only one dependency:
pip install Flask
-
Restless
The Application
Flask-Restless
makes adding RESTful API interfaces to models written with SQLAlchemy a piece of cake. First, add the REST APIManager
from the flask.ext.restless
extension to the application configuration file.
Add the following lines to the flask_app/my_app/__init__.py file:
from
flask_restless
import
APIManager
manager
=
APIManager(app, flask_sqlalchemy_db
=
db)
Just adding the above couple of lines to the existing code should suffice. In the code above, we create the Flask-Restless API manager.
flask_app/my_app/product/views.py
This file comprises the bulk of the changes from the previous part. Below is the complete rewritten file.
from
my_app
import
db, app, manager
catalog
=
Blueprint(
'catalog'
, __name__)
@catalog
.route(
'/'
)
@catalog
.route(
'/home'
)
def
home():
return
"Welcome to the Catalog Home."
manager.create_api(Product, methods
=
[
'GET'
,
'POST'
])
It is pretty self-explanatory how the above code would work. We just imported the manager created in a previous file, and it is used to create an API for the Product model with the listed methods. We can add more methods like DELETE, PUT, and PATCH.
We don't need to create any views since Flask Restless will automatically generate them. The API endpoints specified above will be available at /api/<tablename> by default.
The API in Action
Let's test this application by creating some products and listing them. The endpoint created by this extension by default is http://localhost:5000/api/product
.
As I did in the last part of this tutorial series, I will test this using the requests
library via terminal.
>>>
import
requests
>>>
import
json
>>> res.json()
{
'total_pages'
: 0,
'objects'
: [],
'num_results'
: 0,
'page'
: 1}
>>> d = {
'name'
:
'Macbook Air'
,
'price'
: 2000}
>>> res = requests.post(
'http://127.0.0.1:5000/api/product'
, data=json.dumps(d), headers={
'Content-Type'
:
'application/json'
})
>>> res.json()
{
'price'
: 2000,
'id'
: 1,
'name'
:
'Macbook Air'
}
Here is how to add products using Postman:
How to Customize the API
It is convenient to have the RESTful APIs created automatically, but each application has some business logic that calls for customizations, validations, and clever/secure handling of requests.
Here, request preprocessors and postprocessors come to the rescue. As the names signify, methods designated as preprocessors run before processing the request, and methods designated as postprocessors run after processing the request. create_api()
is the place where they are defined as dictionaries of the request type (eg. GET or POST) and the methods as list which will act as preprocessors or postprocessors on the specified request.
Below is a template example:
manager.create_api(
Product,
methods
=
[
'GET'
,
'POST'
,
'DELETE'
],
preprocessors
=
{
'GET_SINGLE'
: [
'a_preprocessor_for_single_get'
],
'GET_MANY'
: [
'another_preprocessor_for_many_get'
],
'POST'
: [
'a_preprocessor_for_post'
]
},
postprocessors
=
{
'DELETE'
: [
'a_postprocessor_for_delete'
]
}
)
The GET, PUT, and PATCH methods have the flexibility of being fired for single as well as multiple records; therefore, they have two types each. In the code above, notice 'GET_SINGLE'
and 'GET_MANY'
for GET requests.
The preprocessors and postprocessors accept different parameters for each type of request and work without any return value. This is left for you to try on your own.
Conclusion
In this part of this tutorial series, we saw how to create a RESTful API using Flask by adding a couple of lines to an SQLAlchemy-based model.
In the next and last part of this series, I will cover how to create a RESTful API using another popular Flask extension, but this time, the API will be independent of the modeling tool used for the database.
This post has been updated with contributions from Esther Vaati. Esther is a software developer and writer for Envato Tuts+.
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK