Header Ads Widget

Ticker

6/recent/ticker-posts

Cómo crear una API a partir de un conjunto de datos usando Python y Flask



Los conjuntos de datos son los componentes básicos de una API, el genoma a partir del cual crecerán y evolucionarán sus proyectos de desarrollo. Los conjuntos de datos son el corazón de algunas de las disciplinas digitales más avanzadas, desde la inteligencia artificial hasta la visión por computadora y el aprendizaje automático. Teniendo en cuenta el poder y el potencial del aprendizaje automático para todo, desde las pequeñas empresas hasta la ciencia, la necesidad de conjuntos de datos confiables y de calidad solo aumentará.

Poder convertir un conjunto de datos en una API también permite crear sus propias API personalizadas, ya sea para uso interno o para compartir con usuarios finales. Le permite interactuar con sus datos sin procesar de una manera más práctica.

Le mostraremos cómo crear una API web básica utilizando Python ,  SQLite y Flask , un marco web popular. Vamos a crear un catálogo de libros básico como ejemplo de cómo una API REST construida con Python puede producir resultados granulares de una API y luego servirlos a diferentes puntos finales de API. En este caso, publicaremos el título, la fecha de publicación y la primera oración de un libro a través de nuestra API.

Comenzaremos construyendo un servidor Flask básico y alojando una página de inicio. Luego, le mostraremos cómo enrutar sus datos a diferentes puntos finales de API.

Instalar matraz

Flask es un marco web, lo que significa que está diseñado específicamente para hacer que la creación de aplicaciones web con Python sea simple e intuitiva. Comenzaremos cargando Flask e importando algunas funciones básicas en nuestro programa Python.

Antes de comenzar, debe crear una nueva carpeta para su proyecto en su directorio de programación. Hemos llamado a nuestro "apitest", pero puede nombrar su carpeta como desee.

Una vez que haya creado la carpeta de su proyecto, navegue a ese directorio usando Terminal o el IDE que prefiera. Una vez que esté allí, escriba:

Pip install flask

Una vez que esté cargado, cree un archivo vacío con el editor de texto que elija. Usaremos Notepad ++ ya que le permite guardar archivos usando la extensión de archivo que desee. Titula tu archivo vacío app.pyy guárdalo.

Ahora vamos a crear un servidor Flask barebones. En app.py, ingrese lo siguiente:

import flask

app = flask.Flask(__name__)
app.config["DEBUG"] = True

@app.route('/', methods=['GET'])
def home():
    return "Distant Reading Archive: This site is a prototype API for distant reading of science fiction novels."

app.run()

Esto simplemente crea una instancia de Flask y enruta los resultados a una página de inicio. Guarde el archivo y luego escriba lo siguiente en la línea de comando:

Python app.py

Esto devuelve el Distant Reading Archive: This site is a prototype API for distant reading of science fiction novels.resultado " a una página de inicio en .http://127.0.0.1:5000/

Eso es lo básico de cómo funciona Flask. Debería darle una indicación de lo simple e intuitivo que es crear un servicio web usando Flask.

Qué está haciendo Flask

Flask traduce las funciones web a un formato que Python puede entender. En este caso, Flask define una función llamada Homey la enruta al /punto final de la API. Esto es lo que se conoce como enrutamiento de aplicaciones.

La parte de enrutamiento de la aplicación de nuestro código es:

@app.route('/', methods=['GET'])

El /es donde los resultados se encaminan a y la methodsvariable de lo que es tipos de comandos son capaces de ser utilizados en ese punto final. Solo GETusaremos comandos por el bien de este tutorial, pero también podría usar POSTmétodos si quisiera poder agregar datos a ese punto final.

En cuanto a nuestro código preliminar, los import Flaskcomandos introducen Flask en nuestro programa. El app = flask.Flask(__name__)crea una aplicación Flask, que ejecutaremos al final para entregar nuestros resultados. El app.config["DEBUG"] = Truecomando ejecuta su programa en modo de depuración, por lo que no tendrá que restablecer el servidor Flask cada vez que cambie una línea de código. Finalmente, la app.run()función simplemente ejecuta la aplicación.

Creando la API

Ahora que nuestro servidor Flask está en funcionamiento, es hora de crear nuestra API. Configuraremos nuestros datos como una serie de diccionarios de Python, que combinan listas de claves y valores. Los diccionarios de Python tienen el siguiente formato:

{
'Key' : 'value' , 'Key': 'value' }

Ahora agreguemos un poco de datos de prueba a nuestra aplicación para ver un ejemplo de cómo funciona. Elimine el código anterior app.pyy reemplácelo con el siguiente código:

import flask
from flask import request, jsonify app = flask.Flask(__name__) app.config["DEBUG"] = True

Y esto creará algunos datos de prueba para nuestro catálogo en forma de una lista de diccionarios:

books = [
{'id': 0, 'title': 'A Fire Upon the Deep', 'author': 'Vernor Vinge', 'first_sentence': 'The coldsleep itself was dreamless.', 'year_published': '1992'}, {'id': 1, 'title': 'The Ones Who Walk Away From Omelas', 'author': 'Ursula K. Le Guin', 'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.', 'published': '1973'}, {'id': 2, 'title': 'Dhalgren', 'author': 'Samuel R. Delany', 'first_sentence': 'to wound the autumnal city.', 'published': '1975'} ] @app.route('/', methods=['GET']) def home(): return ''Distant Reading Archive: A prototype API for distant reading of science fiction novels.''

Una ruta para devolver todas las entradas disponibles en nuestro catálogo:

@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
    return jsonify(books)

app.run()

Guárdelo y ejecute el programa. Navegue a http://127.0.0.1:5000/api/v1/resources/books/all para ver los datos de prueba devueltos al api/v1/resources/books/allpunto final.

Debería ver los tres libros de nuestros datos de prueba devueltos con formato JSON .

Filtrar los resultados

Ahora debería tener una idea del enrutamiento de aplicaciones y trabajar con diccionarios y datos JSON en Python. Sin embargo, hasta ahora, solo lo hemos logrado para que la lista completa se envíe a un punto final. Hay muchas circunstancias en las que querría segmentar los resultados en diferentes puntos finales de API . Aprendamos a hacer eso.

import flask
from flask import request, jsonify

app = flask.Flask(__name__)
app.config["DEBUG"] = True

Esto creará algunos datos de prueba para nuestro catálogo en forma de una lista de diccionarios:

books = [
{'id': 0, 'title': 'A Fire Upon the Deep', 'author': 'Vernor Vinge', 'first_sentence': 'The coldsleep itself was dreamless.', 'year_published': '1992'}, {'id': 1, 'title': 'The Ones Who Walk Away From Omelas', 'author': 'Ursula K. Le Guin', 'first_sentence': 'With a clamor of bells that set the swallows soaring, the Festival of Summer came to the city Omelas, bright-towered by the sea.', 'published': '1973'}, {'id': 2, 'title': 'Dhalgren', 'author': 'Samuel R. Delany', 'first_sentence': 'to wound the autumnal city.', 'published': '1975'} ] @app.route('/', methods=['GET']) def home(): return ''Distant Reading Archive: A prototype API for distant reading of science fiction novels.'' @app.route('/api/v1/resources/books/all', methods=['GET']) def api_all(): return jsonify(books) @app.route('/api/v1/resources/books', methods=['GET']) def api_id(): # Check if an ID was provided as part of the URL. # If ID is provided, assign it to a variable. # If no ID is provided, display an error in the browser. if 'id' in request.args: id = int(request.args['id']) else: return "Error: No id field provided. Please specify an id." # Create an empty list for our results results = [] # Loop through the data and match results that fit the requested ID. # IDs are unique, but other fields might return many results for book in books: if book['id'] == id: results.append(book) # Use the jsonify function from Flask to convert our list of # Python dictionaries to the JSON format. return jsonify(results) app.run()

Guarde el archivo y ejecute el programa nuevamente. Una vez que su servidor esté funcionando, investigue los siguientes enlaces:

  • http://127.0.0.1:5000/api/v1/resources/books?id=0
  • http://127.0.0.1:5000/api/v1/resources/books?id=1
  • http://127.0.0.1:5000/api/v1/resources/books?id=2

En este nuevo código, creamos una nueva función, la llamamos api_idy la asignamos al punto final de la API api/v1/resources/booksEstán sucediendo dos cosas dentro de esta función. El primero agrega un parámetro de consulta a los datos, que se ingresa después de la URL con un ?calificador. Esto busca una ID particular en nuestros datos y la devuelve a un punto final en particular.

La segunda parte agrega algo de código para que nuestra API repita los datos y los agrega a la lista que se devuelve al usuario. Luego, los resultados se devuelven en formato JSON.

Agregar una base de datos a una API

Ahora debería tener una API funcional pero limitada. Sin embargo, una API no será tan útil si tiene que ingresar diccionarios de Python a mano. Uno de los puntos de la creación de una API es hacer que los datos sean más fáciles de analizar y trabajar. Importar un archivo de base de datos a su programa lo hace fácil de implementar.

Usaremos SQLite para conectarnos a una base de datos. SQLite trabaja con .dbarchivos. Usaremos esta base de datos de libros para este ejemplo. Descargue el archivo y muévalo al directorio raíz de su proyecto.

Ingrese el siguiente código en su editor de texto:

import flask
from flask import request, jsonify
import sqlite3

app = flask.Flask(__name__)
app.config["DEBUG"] = True

def dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d[col[0]] = row[idx]
    return d

@app.route('/', methods=['GET'])
def home():
    return '''Distant Reading Archive: A prototype API for distant reading of science fiction novels.'''

@app.route('/api/v1/resources/books/all', methods=['GET'])
def api_all():
    conn = sqlite3.connect('books.db')
    conn.row_factory = dict_factory
    cur = conn.cursor()
    all_books = cur.execute('SELECT * FROM books;').fetchall()

    return jsonify(all_books)

@app.errorhandler(404)
def page_not_found(e):
    return "404. The resource could not be found.", 404

@app.route('/api/v1/resources/books', methods=['GET'])
def api_filter():
    query_parameters = request.args

    id = query_parameters.get('id')
    published = query_parameters.get('published')
    author = query_parameters.get('author')

    query = "SELECT * FROM books WHERE"
    to_filter = []

    if id:
        query += ' id=? AND'
        to_filter.append(id)
    if published:
        query += ' published=? AND'
        to_filter.append(published)
    if author:
        query += ' author=? AND'
        to_filter.append(author)
    if not (id or published or author):
        return page_not_found(404)

    query = query[:-4] + ';'

    conn = sqlite3.connect('books.db')
    conn.row_factory = dict_factory
    cur = conn.cursor()

    results = cur.execute(query, to_filter).fetchall()

    return jsonify(results)

app.run()

Guarde el resultado como api_final.pyNavegue a los siguientes puntos finales para ver su nueva base de datos y función de filtrado en acción:

  • http://127.0.0.1:5000/api/v1/resources/books/all
  • http://127.0.0.1:5000/api/v1/resources/books?author=Connie+Willis
  • http://127.0.0.1:5000/api/v1/resources/books?author=Connie+Willis&published=1993
  • http://127.0.0.1:5000/api/v1/resources/books?published=2010

Echemos un vistazo más profundo a lo que está sucediendo tanto con nuestra base de datos como con la API que hemos creado a partir de ella.

Comprender las bases de datos y las API

Para este ejercicio, usamos SQLite, aunque hay muchos formatos de base de datos entre los que puede elegir. En SQLite, los datos se almacenan en tablas, que almacenan datos en columnas y filas.

La base de datos que estamos usando es una recopilación de todos los ganadores de los premios Hugo. Tiene cinco columnas: idpublishedauthortitle, y first sentenceEl primer código que permite a nuestro programa interactuar con la base de datos es:

def api_all():
    conn = sqlite3.connect('books.db')
    conn.row_factory = dict_factory
    cur = conn.cursor()
    all_books = cur.execute('SELECT * FROM books;').fetchall()

    return jsonify(all_books)

Esto crea una función llamada api_all():Primero, la función se conecta a la base de datos usando el sqlite3.connectcomando. La variable en () carga el archivo .db y los datos resultantes se conectan a la variable 'conn'.

El conn.row_factorycomando le dice a la función de conexión que use la dict_factoryvariable que definimos, que convierte los datos recuperados de la base de datos como diccionarios en lugar de listas. El curobjeto es un objeto que se mueve a través de la base de datos y recopila todos los datos. Finalmente, el cur.executemétodo recupera todos los datos pertinentes *, de la bookstabla en la base de datos.

Los últimos bits de código son para cuando ocurren errores, devolviendo errores 404 cuando una consulta no está incluida en la base de datos. La última parte es una versión mejorada de la api_idfunción que creamos anteriormente. Permite que el filtro de usuario final por idpublishedauthor.

La función comienza definiendo los parámetros de consulta:

query_parameters = request.args

Luego encadena las consultas admitidas a la variable apropiada.

id = query_parameters.get('id')
published = query_parameters.get('published') author = query_parameters.get('author'

A continuación, la función traduce el código Python a un formato que SQL puede entender.

query = "SELECT * FROM books WHERE"
to_filter = []

Finalmente, si idpublishedauthorse utilizó como consulta, los resultados se añaden a la lista.

if id:
query += ' id=? AND' to_filter.append(id) if published: query += ' published=? AND' to_filter.append(published) if author: query += ' author=? AND' to_filter.append(author)

Si el usuario no ha utilizado ninguna de estas consultas, será redirigido a una página 404.

Luego, los resultados se emparejan con las variables apropiadas, igual que antes.

conn = sqlite3.connect('books.db')
conn.row_factory = dict_factory cur = conn.cursor() results = cur.execute(query, to_filter).fetchall()

Finalmente, esos resultados se devuelven en formato JSON gracias al siguiente código:

return jsonify(results)

Creación de una API con Flask: pensamientos finales

Le mostramos cómo crear una API básica basada en web usando Python, Flask y SQLite. Estos conceptos y el código que hemos compartido son universales y flexibles, por lo que puede aplicar estos principios para crear sus propias API. Puede modificar las hojas de estilo a su gusto, haciendo que su aplicación web se lea como desee. También puede personalizar la pantalla, lo que significa que puede hacer que sus conjuntos de datos sean tan atractivos como desee para el usuario final previsto.

Las posibilidades son infinitas una vez que pueda diseñar y crear sus propios conjuntos de datos y API. Incluso podría ser una fuente de ingresos para su empresa o marca, una vez que tenga los datos correctos.

Publicar un comentario

0 Comentarios