Google+
4elements web design & consultancy

Shineyrock

web design & consultancy
Shineyrock web design & consultancy

Shineyrock

  1. web design and consultancy

blog

  1. Home
  2. blog
  3. read
  4. Building RESTful APIs With Flask: An ORM With SQLAlchemy
  • like 3 14

    Building RESTful APIs With Flask: An ORM With SQLAlchemy

    1. June 2016
    2. Daily
    3. read 813

    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 <a href="https://localhost:5000/api/product">http://localhost:5000/api/product</a>.

    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 = requests.get('http://127.0.0.1:5000/api/product')
>>> 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:

    add products using Postmanadd products using Postmanadd 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 (e.g. GET or POST) and the methods which will act as preprocessors or postprocessors on the specified request are listed.

    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+.

    Photo

    martijn broeders

    founder/ strategic creative at shineyrock web design & consultancy
    e-mail: .(JavaScript must be enabled to view this email address)
    phone: 434 210 0245
    3
    Add a comment...
    4elements
    Comments

By - category

By - date

Copyright © 1999 - 2026 Shineyrock web design and consultancy, All Rights Reserved / Terms of Conditions / Sitemap: XML, HTML, Images, Mobile, News