Menu

Esercitazione sull'API Flask con esempio | Flask estensibile con API

  • Principale
  • Altro
  • Esercitazione sull'API Flask con esempio | Flask estensibile con API

flask api tutorial with example extending flask with apis

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial sull'API Flask spiega le estensioni Flask popolari come Flask twitter Oembedder, Flask API e Flask RESTful con esempi:

Il framework Flask ha un numero piuttosto abbondante di estensioni. Queste estensioni sono abbastanza utili e facili da sviluppare. Sappiamo che il framework Flask è molto Pythonic e ha un set minimo di API ed è molto flessibile, motivo per cui la comunità di Flask ha creato così tante estensioni per molte attività specifiche.

Come parte della serie di esercitazioni Flask, questa esercitazione contiene un esempio di alcune estensioni Flask. Discuteremo le seguenti estensioni.

  1. Flask twitter Oembedder
  2. API Flask
  3. Boccetta RESTful

=> Visita qui per imparare Flask da zero

Esercitazione sull

Sebbene abbiamo discusso molte estensioni come parte dei nostri tutorial precedenti, questo tutorial spiega di più con la prospettiva di esaminare i componenti di un'estensione Flask.

Cosa imparerai:

Che cos'è un'estensione del pallone

Un'estensione flask è un modulo Python installabile o un pacchetto che implementa funzionalità aggiuntive per un'applicazione Flask. Un'estensione Flask può essere semplice come quella che aggiunge il supporto per l'utilizzo di un'API esterna come Twitter per incorporare un tweet in una pagina web.

In alternativa, un'estensione Flask potrebbe essere un nuovo framework come Flask API o Flask-RESTful per creare app che seguono uno schema architettonico o un paradigma di sviluppo.

Flask twitter Oembedder

In questa sezione, prendiamo l'esempio di un semplice progetto open source esistente da Qui

Clona questo progetto nella tua macchina locale e installalo usando pip con l'aiuto del comando indicato di seguito.

# in an activated virtual environment pip install -e flask_twitter_oembedder/

Questa estensione aiuta a incorporare un Tweet con l'aiuto di un tag modello Jinja2. Tuttavia, per utilizzare questa estensione, dovrai richiedere un account sviluppatore su Twitter. Una volta ottenuto un account sviluppatore, crea un'app e otterrai chiavi e segreti per utilizzare l'API di Twitter.

download gratuito del miglior software di hacking per computer al mondo

Una volta che hai le chiavi e i segreti, conservali in un luogo sicuro in modo che l'applicazione possa accedervi. Li abbiamo mantenuti nelle variabili di ambiente e li abbiamo aggiunti alla configurazione dell'app Flask, come mostrato di seguito. La nostra app demo mantiene i valori di configurazione nel file config.py.

# Twitter details import os TWITTER_ACCESS_TOKEN = os.environ.get('TWITTER_ACCESS_TOKEN', None) TWITTER_TOKEN_SECRET = os.environ.get('TWITTER_TOKEN_SECRET', None) TWITTER_CONSUMER_KEY = os.environ.get('TWITTER_CONSUMER_KEY', None) TWITTER_CONSUMER_SECRET = os.environ.get('TWITTER_CONSUMER_SECRET', None)

Otteniamo i valori delle variabili richieste dalle variabili d'ambiente. Se il valore corrispondente non è presente nella variabile di ambiente, viene memorizzato come Nessuno.

Dopo aver aggiunto le righe precedenti nel file di configurazione, vai al file __init__.py dell'applicazione Flask e inizializzalo modificandolo, come mostrato di seguito.

from flask_caching import Cache from flask_twitter_oembedder import TwitterOEmbedder cache = Cache(app, config={'CACHE_TYPE': 'simple'}) twitter_oembedder = TwitterOEmbedder(app, cache)

Queste righe inizializzeranno l'estensione Flask. Ora possiamo modificare hello.html sotto i modelli e aggiungere il tag indicato di seguito come mostrato di seguito.

{{ oembed_tweet('1277228221394587649') }}

Abbiamo aggiunto questo tag prima del ciclo for nel modello esistente. Quella cifra molto lunga è l'id del tweet. Otteniamo questo ID dall'URL del Tweet dopo aver twittato. Dopo aver salvato il file modello, andiamo all'endpoint / ciao / saluti e riceviamo i risultati, come mostrato nell'immagine sottostante.

Incorpora Tweet in HTML
Incorpora Tweet in HTML

Boccetta RESTful

La nostra applicazione di esempio RESTful Flask è quella che rispetta i vincoli dell'architettura REST. Tuttavia, non è come un protocollo e gli sviluppatori sono flessibili durante l'implementazione delle funzionalità, seguendo i vincoli REST.

Si prega di leggere di più sui vincoli dell'architettura REST Qui .

Le moderne applicazioni Web consentono ai client di richiedere le risorse su endpoint stabili e di facile lettura in modo senza stato.

Esempio di boccetta RESTful

Implementiamo alcune funzionalità in modo RESTful anche nella nostra applicazione di esempio RESTful Flask.

Abbiamo un modo per archiviare e fornire dati relativi ad album e brani. Implementiamo un'API utilizzando l'estensione RESTful Flask.

Innanzitutto, installa Flask RESTful utilizzando il comando seguente.

pip install flask-restful

Per una facile manutenzione e comprensione, creiamo un file chiamato api.py all'interno della directory dell'app e menzioniamo le seguenti righe di codice in esso. Per ora, considera le API simili a Flask Views.

Stiamo per implementare funzionalità corrispondenti ai verbi HTTP per rispondere quando il client invia una richiesta all'endpoint del server dell'applicazione.

from flask import request from flask_restful import Resource, reqparse, abort, Api from . import app api = Api(app, prefix='/myapi/v1') def abort_if_song_doesnt_exist(song_name): if song_name not in SONGS: abort(404, message='Song {} doesn't exist'.format(song_name)) parser = reqparse.RequestParser() parser.add_argument('title') parser.add_argument('singer') SONGS = { 'Song1': { 'title': 'Past Life', 'singer': 'Selena Gomez' } } class Songs(Resource): def get(self): return {'songs': SONGS} def post(self): args = parser.parse_args(strict=True) song_name = int(max(SONGS.keys()).lstrip('Song')) + 1 song_name = 'Song%d' % song_name SONGS(song_name) = {'title': args('title'), 'singer': args('singer')} return { song_name:SONGS(song_name) }, 201 api.add_resource(Songs, '/songs') class Song(Resource): def get(self, song_name): abort_if_song_doesnt_exist(song_name) return { song_name: SONGS(song_name) } def delete(self, song_name): abort_if_song_doesnt_exist(song_name) del SONGS(song_name) return '', 204 def put(self, song_name): args = parser.parse_args(strict=True) abort_if_song_doesnt_exist(song_name) SONGS(song_name) = {'title': args('title'), 'singer': args('singer')} return { song_name: SONGS(song_name) }, 201 api.add_resource(Song, '/songs/')

Abbiamo creato due risorse chiamate Songs e Song creando una sottoclasse Resource abstract class di Flask-RESTful. La classe chiamata Songs ha due metodi get e post corrispondenti ai due verbi HTTP; GET e POST, rispettivamente.

La risorsa Songs serve tutti i brani all'endpoint registrato quando il Cliente lo richiede e aggiunge un brano all'elenco dei brani esistenti quando i dati vengono pubblicati nello stesso endpoint.

Allo stesso modo, nel caso della classe Song, HTTP GET, DELETE e PUT vengono implementati utilizzando i metodi get, delete e put. Il metodo get invia una risposta con la canzone richiesta come JSON, il metodo delete rimuove una canzone da SONGS e il metodo put aggiorna una canzone esistente in SONGS.

Ora aggiungiamo queste risorse alla nostra applicazione di esempio inizializzandole nel file __init__.py nella cartella dell'app.

from . import api

Installiamo curl e proviamo le funzionalità sugli endpoint dichiarati.

sudo apt -y install curl

Ottieni tutte le canzoni

curl -k https://localhost:8080/api/v1/songs

Otteniamo la risposta, come mostrato di seguito.

{ 'songs': { 'Song1': { 'title': 'Past Life', 'singer': 'Selena Gomez' } } }

Ora usiamo il comando indicato di seguito per aggiungere una canzone.

curl -k -d 'title=Summer Days&singer=Martin Garrix' https://localhost:8080/api/v1/songs

Otteniamo la risposta dalla nostra API, come mostrato di seguito.

domande e risposte per interviste esperte per esperti
{ 'Song2': { 'title': 'Summer Days', 'singer': 'Martin Garrix2' } }

Ora di nuovo, se interroghiamo l'elenco delle canzoni come abbiamo fatto nel comando precedente, e otterremo entrambe le canzoni nella risposta.

{ 'songs': { 'Song1': { 'title': 'Past Life', 'singer': 'Selena Gomez' }, 'Song2': { 'title': 'Summer Days', 'singer': 'Martin Garrix2' } } }

Allo stesso modo, HTTP DELETE e PUT funzionano come previsto. Aggiungiamo alcuni test per la versione v1 di questa API semplice che abbiamo creato.

def test_myapi_v1_songs(client): resp = client.get('/api/v1/songs/') #import pdb;pdb.set_trace() assert 200 == resp.status_code def test_myapi_v1_add_song(client): ''' The application can store the same data multiple times''' data = { 'title': 'Summer Days', 'singer': 'Martin Garrix' } resp = client.post( '/api/v1/songs/', data=data ) assert 201 == resp.status_code

Ora esegui questi test dalla riga di comando, come mostrato di seguito.

pytest app/tests/test_api.py

Allo stesso modo, possiamo scrivere test per altri metodi per una maggiore copertura.

Una cosa importante da annotare è che le canzoni che abbiamo aggiunto persistono come parte del singolo processo in cui è in esecuzione il server di sviluppo. Significa che tutti i nuovi dati andranno persi non appena il processo si arresta.

Inoltre, il compito di creare la versione v1 dell'API sembra ridondante ed è diverso dal modo in cui salvavamo i dati nell'applicazione con l'aiuto di moduli e viste.

Di solito, l'implementazione dell'API RESTful richiede l'acquisizione di dati dai client, il marshalling tra le estremità client e server e persistenza con l'aiuto dei modelli di database che abbiamo creato.

Inoltre, gli endpoint sono protetti per input non intenzionali e predisposti.

Pertanto, raccomandiamo che gli esempi sopra riportati siano solo per l'apprendimento dei concetti e dei vincoli dell'architettura REST utilizzando metodi HTTP. Ricorda che questo è solo uno dei tanti modi in cui i servizi web, in generale, vengono creati. Inoltre, ci sono molti modi in cui l'architettura REST può essere implementata.

Incoraggiamo i lettori a esplorare ulteriormente come REST può avere diversi formati di file e metodi personalizzati utilizzando altri protocolli e non solo JSON e HTTP. Solo per dare un'idea di un utilizzo in produzione, forniamo l'esempio di seguito.

Usiamo un BaseApi di Flask-Appbuilder per implementare funzionalità simili sotto endpoint diversi. Apri il file api.py e aggiornalo con il codice indicato di seguito.

APIs using appbuilder from flask_appbuilder.api import BaseApi, expose from . import appbuilder class SongsApi(BaseApi): resource_name = 'songs' @expose('/', methods=('POST', 'GET')) def songs(self): if request.method == 'GET': return self.response(200, songs=SONGS) else: args = parser.parse_args(strict=True) song_name = int(max(SONGS.keys()).lstrip('Song')) + 1 song_name = 'Song%d' % song_name SONGS(song_name) = {'title': args('title'), 'singer': args('singer')} return self.response(201, song=SONGS(song_name)) appbuilder.add_api(SongsApi) class SongApi(BaseApi): resource_name = 'songs' @expose('/', methods=('GET', 'DELETE', 'PUT')) def song(self, song_name): if request.method == 'GET': abort_if_song_doesnt_exist(song_name) return self.response(200, song_name=SONGS(song_name) ) elif request.method == 'DELETE': abort_if_song_doesnt_exist(song_name) del SONGS(song_name) return self.response(204, message='OK') elif request.method == 'PUT': args = parser.parse_args(strict=True) abort_if_song_doesnt_exist(song_name) SONGS(song_name) = {'title': args('title'), 'singer': args('singer')} return self.response(201, song_name=SONGS(song_name)) else: self.response_404() appbuilder.add_api(SongApi)

Ora aggiungiamo altri test per testare gli endpoint creati utilizzando Flask-Appbuilder. Eseguiremo questi test usando PyTest.

def test_v1_songs(client): resp = client.get('/api/v1/songs/', follow_redirects=True) #import pdb;pdb.set_trace() assert 200 == resp.status_code def test_v1_add_song(client): ''' The application can store the same data multiple times''' # Get the existing number of songs resp = client.get('/api/v1/songs/', follow_redirects=True) data = { 'title': 'Summer Days', 'singer': 'Martin Garrix' } resp = client.post( '/api/v1/songs/', data=data, follow_redirects=True ) assert 201 == resp.status_code

Flask-Appbuilder aiuta anche a fornire l'interfaccia utente di Swagger per elencare e provare l'API pubblicata. Apri config.py e aggiornalo con la configurazione mostrata di seguito.

FAB_API_SWAGGER_UI=True

Ora vai a https: // localhost: 8080 / swaggerview / v1 e sarai in grado di vedere la vista Swagger come mostrato di seguito.

songsapi
Vista spavalda dell'API

Ora creiamo le API per i modelli di database esistenti che abbiamo. Dobbiamo usare ModelApi di Flask-Appbuilder.

Aggiorna il file api.py con le seguenti righe di codice.

from flask_appbuilder.models.sqla.interface import SQLAInterface from flask_appbuilder.api import ModelRestApi from .models import Song as SongModel class MySongModelApi(ModelRestApi): resource_name = 'newsongs' datamodel = SQLAInterface(SongModel) appbuilder.add_api(MySongModelApi)

Dopo aver definito una classe basata su ModelRestApi, dobbiamo registrarla nuovamente con Flask-Appbuilder utilizzando il metodo add_api.

Ora vai all'interfaccia utente di Swagger come in precedenza e vedrai un riferimento API simile a quello mostrato di seguito.

Vista spavalda del modello API
Vista spavalda del modello API

Puoi provare l'API dalla vista Swagger o inviando il curl agli endpoint come in precedenza.

API Flask

L'API Flask è un framework abbastanza simile al framework REST di Django. È possibile accedere alla documentazione dell'API Flask Qui . È il sostituto immediato del framework Flask.

Possiamo scegliere uno qualsiasi degli esempi sopra indicati per implementare le funzionalità basate sull'API REST di Flask nella nostra applicazione.

Ora eseguiamo il commit della sorgente e pubblichiamo le modifiche al repository di origine utilizzando Git. Non appena ci impegniamo per l'origine con il nome del ramo e inviamo una richiesta pull, gli unit test si attiveranno automaticamente sotto le azioni Git come parte dei controlli della richiesta pull.

Bottle RestPlus

Flask RestPlus è un'altra estensione Flask che aiuta nella creazione dell'API REST utilizzando Flask. Questo progetto è stato biforcato in un'altra estensione chiamata Flask-RESTX e non è più mantenuto.

Questo progetto ha una buona raccolta di decoratori per descrivere le API ed espone la sua documentazione usando Swagger. Puoi controllare i dettagli di questo progetto Qui .

Domande frequenti

D # 1) Come si crea un'API REST con Flask?

Risposta: Possiamo utilizzare il framework Flask con altre estensioni Flask come Flask-RESTful, Flask API, Flask RESTX, Connexion, ecc. Per creare applicazioni Web basate su API REST. La maggior parte delle estensioni funziona con le altre funzionalità integrate del framework Flask e qualsiasi altra libreria / ORM esistente.

D # 2) Che cos'è un esempio di API REST?

Risposta: In questo tutorial viene fornita un'applicazione di esempio che implementa l'API RESTFul. Flask-RESTful è stato utilizzato per creare l'applicazione di esempio. Leggi la sezione di esempio RESTful di Flask in questo tutorial.

D # 3) A cosa serve l'API RESTful?

Risposta: Un'interfaccia di programmazione dell'applicazione che generalmente utilizza richieste HTTP e ha metodi di backend corrispondenti per verbi HTTP come GET, POST, PUT, ecc. Per consentire la comunicazione tra client e server è chiamata API RESTful.

passando l'array al metodo in java

Tale applicazione segue i principi e i vincoli dell'architettura REST per implementare le sue funzionalità.

Conclusione

Abbiamo coperto i concetti delle estensioni Flask con l'aiuto di tre estensioni, come Flask-twitter-oembedder, Flask API e Flask-RESTful.

Con l'aiuto di Flask-twitter-oembedder, abbiamo coperto anche i concetti dell'API di Twitter. In generale, abbiamo incluso anche l'idea di implementare un servizio web RESTful, che segue i principi e i vincoli dell'architettura REST.

Nel nostro prossimo tutorial, tratteremo il confronto tra Django e il framework Flask per aiutare i nostri lettori a comprendere i punti di forza e di debolezza di entrambi i framework. Aiuterà anche nella scelta di un framework rispetto all'altro in base ai requisiti particolari del progetto.

=> Esplora la serie Simple Flask Training qui

Lettura consigliata

^