Cómo construir una API JSON con Python

La especificación de la API JSON es una forma poderosa de habilitar la comunicación entre el cliente y el servidor. Especifica la estructura de las solicitudes y respuestas enviadas entre los dos, utilizando el formato JSON.

Como formato de datos, JSON tiene las ventajas de ser ligero y legible. Esto hace que sea muy fácil trabajar con él de forma rápida y productiva. La especificación está diseñada para minimizar el número de solicitudes y la cantidad de datos que se deben enviar entre el cliente y el servidor.

Aquí, puede aprender a crear una API JSON básica usando Python y Flask. Luego, el resto del artículo le mostrará cómo probar algunas de las características que ofrece la especificación de la API JSON.

Flask es una biblioteca de Python que proporciona un 'micro-marco' para el desarrollo web. Es ideal para un desarrollo rápido, ya que viene con una funcionalidad básica simple pero extensible.

A continuación se muestra un ejemplo realmente básico de cómo enviar una respuesta tipo JSON usando Flask:

from flask import Flask app = Flask(__name__) @app.route('/') def example(): return '{"name":"Bob"}' if __name__ == '__main__': app.run()

Este artículo utilizará dos complementos para Flask:

  • Flask-REST-JSONAPI ayudará a desarrollar una API que siga de cerca la especificación de la API JSON.
  • Flask-SQLAlchemy usará SQLAlchemy para hacer que la creación e interacción con una base de datos simple sea muy sencilla.

El panorama

El objetivo final es crear una API que permita la interacción del lado del cliente con una base de datos subyacente. Habrá un par de capas entre la base de datos y el cliente: una capa de abstracción de datos y una capa de administrador de recursos.

Aquí hay una descripción general de los pasos involucrados:

  1. Definir una base de datos usando Flask-SQLAlchemy
  2. Cree una abstracción de datos con Marshmallow-JSONAPI
  3. Cree administradores de recursos con Flask-REST-JSONAPI
  4. Cree puntos finales de URL e inicie el servidor con Flask

Este ejemplo utilizará un esquema simple que describe a los artistas modernos y sus relaciones con diferentes obras de arte.

Instalar todo

Antes de comenzar, deberá configurar el proyecto. Esto implica crear un espacio de trabajo y un entorno virtual, instalar los módulos necesarios y crear los archivos de base de datos y Python principales para el proyecto.

Desde la línea de comandos, cree un nuevo directorio y navegue dentro.

$ mkdir flask-jsonapi-demo $ cd flask-jsonapi-demo/

Es una buena práctica crear entornos virtuales para cada uno de sus proyectos de Python. Puede omitir este paso, pero se recomienda encarecidamente.

$ python -m venv .venv $ source .venv/bin/activate 

Una vez que su entorno virtual ha sido creado y activado, puede instalar los módulos necesarios para este proyecto.

$ pip install flask-rest-jsonapi flask-sqlalchemy

Todo lo que necesitará se instalará como requisitos para estas dos extensiones. Esto incluye el propio Flask y SQLAlchemy.

El siguiente paso es crear un archivo y una base de datos Python para el proyecto.

$ touch application.py artists.db

Crea el esquema de la base de datos

Aquí, comenzará a modificar application.pypara definir y crear el esquema de base de datos para el proyecto.

Abra application.pyen su editor de texto preferido. Comience importando algunos módulos. Para mayor claridad, los módulos se importarán sobre la marcha.

A continuación, cree un objeto llamado appcomo instancia de la clase Flask.

Después de eso, use SQLAlchemy para conectarse al archivo de base de datos que creó. El paso final es definir y crear una tabla llamada artists.

from flask import Flask from flask_sqlalchemy import SQLAlchemy # Create a new Flask application app = Flask(__name__) # Set up SQLAlchemy app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////artists.db' db = SQLAlchemy(app) # Define a class for the Artist table class Artist(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) birth_year = db.Column(db.Integer) genre = db.Column(db.String) # Create the table db.create_all()

Creando una capa de abstracción

El siguiente paso utiliza el módulo Marshmallow-JSONAPI para crear una abstracción lógica de datos sobre las tablas recién definidas.

La razón para crear esta capa de abstracción es simple. Le brinda más control sobre cómo se exponen sus datos subyacentes a través de la API. Piense en esta capa como una lente a través de la cual el cliente API puede ver los datos subyacentes con claridad y solo los bits que necesitan ver.

En el siguiente código, la capa de abstracción de datos se define como una clase que hereda de la Schemaclase Marshmallow-JSONAPI . Proporcionará acceso a través de la API tanto a registros únicos como a registros múltiples de la tabla de artistas.

Dentro de este bloque, la Metaclase define algunos metadatos. Específicamente, el nombre del punto final de la URL para interactuar con registros individuales será artist_one, donde cada artista será identificado por un parámetro de URL . El nombre del punto final para interactuar con muchos registros será artist_many.

Los atributos restantes definidos se relacionan con las columnas de la tabla de artistas. Aquí, puede controlar aún más cómo se expone cada uno a través de la API.

Por ejemplo, al realizar solicitudes POST para agregar nuevos artistas a la base de datos, puede asegurarse de que el namecampo sea obligatorio configurando required=True.

Y si por alguna razón no desea birth_yearque se devuelva el campo al realizar solicitudes GET, puede especificarlo configurando load_only=True.

from marshmallow_jsonapi.flask import Schema from marshmallow_jsonapi import fields # Create data abstraction layer class ArtistSchema(Schema): class Meta: type_ = 'artist' self_view = 'artist_one' self_view_kwargs = {'id': ''} self_view_many = 'artist_many' id = fields.Integer() name = fields.Str(required=True) birth_year = fields.Integer(load_only=True) genre = fields.Str() 

Cree administradores de recursos y puntos finales de URL

La pieza final del rompecabezas es crear un administrador de recursos y el punto final correspondiente para cada una de las rutas / artistas y / artistas / id.

Cada administrador de recursos se define como una clase que hereda de las clases Flask-REST-JSONAPI ResourceListy ResourceDetail.

Aquí toman dos atributos. schemase usa para indicar la capa de abstracción de datos que usa el administrador de recursos e data_layerindica la sesión y el modelo de datos que se usará para la capa de datos.

A continuación, defina apicomo una instancia de la Apiclase Flask-REST-JSONAPI y cree las rutas para la API con api.route(). Este método toma tres argumentos: la clase de capa de abstracción de datos, el nombre del punto final y la ruta URL.

The last step is to write a main loop to launch the app in debug mode when the script is run directly. Debug mode is great for development, but it is not suitable for running in production.

# Create resource managers and endpoints from flask_rest_jsonapi import Api, ResourceDetail, ResourceList class ArtistMany(ResourceList): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} class ArtistOne(ResourceDetail): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} api = Api(app) api.route(ArtistMany, 'artist_many', '/artists') api.route(ArtistOne, 'artist_one', '/artists/') # main loop to run app in debug mode if __name__ == '__main__': app.run(debug=True)

Make GET and POST requests

Now you can start using the API to make HTTP requests. This could be from a web browser, or from a command line tool like curl, or from within another program (e.g., a Python script using the Requests library).

To launch the server, run the application.py script with:

$ python application.py

In your browser, navigate to //localhost:5000/artists.  You will see a JSON output of all the records in the database so far. Except, there are none.

To start adding records to the database, you can make a POST request. One way of doing this is from the command line using curl. Alternatively, you could use a tool like Insomnia, or perhaps code up a simple HTML user interface that posts data using a form.

With curl, from the command line:

curl -i -X POST -H 'Content-Type: application/json' -d '{"data":{"type":"artist", "attributes":{"name":"Salvador Dali", "birth_year":1904, "genre":"Surrealism"}}}' //localhost:5000/artists

Now if you navigate to //localhost:5000/artists, you will see the record you just added. If you were to add more records, they would all show here as well, as this URL path calls the artists_many endpoint.

To view just a single artist by their id number, you can navigate to the relevant URL. For example, to see the first artist, try //localhost:5000/artists/1.

Filtering and sorting

One of the neat features of the JSON API specification is the ability to return the response in more useful ways by defining some parameters in the URL. For instance, you can sort the results according to a chosen field, or filter based on some criteria.

Flask-REST-JSONAPI comes with this built in.

To sort artists in order of birth year, just navigate to //localhost:5000/artists?sort=birth_year. In a web application, this would save you from needing to sort results on the client side, which could be costly in terms of performance and therefore impact the user experience.

Filtering is also easy. You append to the URL the criteria you wish to filter on, contained in square brackets. There are three pieces of information to include:

  • "name" - the field you are filtering by (e.g., birth_year)
  • "op" - the filter operation ("equal to", "greater than", "less than" etc.)
  • "val" - the value to filter against (e.g., 1900)

For example, the URL below retrieves artists whose birth year is greater than 1900:

//localhost:5000/artists?filter=[{"name":"birth_year","op":"gt","val":1900}]

This functionality makes it much easier to retrieve only relevant information when calling the API. This is valuable for improving performance, especially when retrieving potentially large volumes of data over a slow connection.

Pagination

Another feature of the JSON API specification that aids performance is pagination. This is when large responses are sent over several "pages", rather than all in one go. You can control the page size and the number of the page you request in the URL.

So, for example, you could receive 100 results over 10 pages instead of loading all 100 in one go. The first page would contain results 1-10, the second page would contain results 11-20, and so on.

To specify the number of results you want to receive per page, you can add the parameter ?page[size]=X to the URL, where X is the number of results. Flask-REST-JSONAPI uses 30 as the default page size.

To request a given page number, you can add the parameter ?page[number]=X, where is the page number. You can combine both parameters as shown below:

//localhost:5000/artists?page[size]=2&page[number]=2

This URL sets the page size to two results per page, and asks for the second page of results. This would return the third and fourth results from the overall response.

Relationships

Almost always, data in one table will be related to data stored in another. For instance, if you have a table of artists, chances are you might also want a table of artworks. Each artwork is related to the artist who created it.

The JSON API specification allows you to work with relational data easily, and the Flask-REST-JSONAPI lets you take advantage of this. Here, this will be demonstrated by adding an artworks table to the database, and including relationships between artist and artwork.

To implement the artworks example, it will be necessary to make a few changes to the code in application.py.

First, make a couple of extra imports, then create a new table which relates each artwork to an artist:

from marshmallow_jsonapi.flask import Relationship from flask_rest_jsonapi import ResourceRelationship # Define the Artwork table class Artwork(db.Model): id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String) artist_id = db.Column(db.Integer, db.ForeignKey('artist.id')) artist = db.relationship('Artist', backref=db.backref('artworks'))

Next, rewrite the abstraction layer:

# Create data abstraction class ArtistSchema(Schema): class Meta: type_ = 'artist' self_view = 'artist_one' self_view_kwargs = {'id': ''} self_view_many = 'artist_many' id = fields.Integer() name = fields.Str(required=True) birth_year = fields.Integer(load_only=True) genre = fields.Str() artworks = Relationship(self_view = 'artist_artworks', self_view_kwargs = {'id': ''}, related_view = 'artwork_many', many = True, schema = 'ArtworkSchema', type_ = 'artwork') class ArtworkSchema(Schema): class Meta: type_ = 'artwork' self_view = 'artwork_one' self_view_kwargs = {'id': ''} self_view_many = 'artwork_many' id = fields.Integer() title = fields.Str(required=True) artist_id = fields.Integer(required=True) 

This defines an abstraction layer for the artwork table, and adds a relationship between artist and artwork to the ArtistSchema class.

Next, define new resource managers for accessing artworks many at once and one at a time, and also for accessing the relationships between artist and artwork.

class ArtworkMany(ResourceList): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtworkOne(ResourceDetail): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtistArtwork(ResourceRelationship): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist}

Finally, add some new endpoints:

api.route(ArtworkOne, 'artwork_one', '/artworks/') api.route(ArtworkMany, 'artwork_many', '/artworks') api.route(ArtistArtwork, 'artist_artworks', '/artists//relationships/artworks')

Run application.py and trying posting some data from the command line via curl:

curl -i -X POST -H 'Content-Type: application/json' -d '{"data":{"type":"artwork", "attributes":{"title":"The Persistance of Memory", "artist_id":1}}}' //localhost:5000/artworks

This will create an artwork related to the artist with id=1.

In the browser, navigate to //localhost:5000/artists/1/relationships/artworks. This should show the artworks related to the artist with id=1. This saves you from writing a more complex URL with parameters to filter artworks by their artist_id field. You can quickly list all the relationships between a given artist and their artworks.

Another feature is the ability to include related results in the response to calling the artists_one endpoint:

//localhost:5000/artists/1?include=artworks

This will return the usual response for the artists endpoint, and also results for each of that artist's artworks.

Sparse Fields

One last feature worth mentioning - sparse fields. When working with large data resources with many complex relationships, the response sizes can blow up real fast. It is helpful to only retrieve the fields you are interested in.

The JSON API specification lets you do this by adding a fields parameter to the URL. For example URL below gets the response for a given artist and their related artworks. However, instead of returning all the fields for the given artwork, it returns only the title.

//localhost:5000/artists/1?include=artworks&fields[artwork]=title

This is again very helpful for improving performance, especially over slow connections. As a general rule, you should only make requests to and from the server with the minimal amount of data required.

Final remarks

The JSON API specification is a very useful framework for sending data between server and client in a clean, flexible format. This article has provided an overview of what you can do with it, with a worked example in Python using the Flask-REST-JSONAPI library.

So what will you do next? There are many possibilities. The example in this article has been a simple proof-of-concept, with just two tables and a single relationship between them. You can develop an application as sophisticated as you like, and create a powerful API to interact with it using all the tools provided here.

Thanks for reading, and keep coding in Python!