Meny

Flask API-handledning med exempel | Utöka flaskan med API: er

  • Huvud
  • Övrig
  • Flask API-handledning med exempel | Utöka flaskan med API: er

flask api tutorial with example extending flask with apis

Prova Vårt Instrument För Att Eliminera Problem

Denna Flask API-handledning förklarar populära Flask-tillägg som Flask twitter Oembedder, Flask API och Flask RESTful med exempel:

Flask-ramverket har ett ganska stort antal tillägg. Dessa tillägg är ganska användbara och är lätta att utveckla. Vi vet att Flask-ramverket är mycket pythoniskt och har ett minimalt antal API: er och är mycket flexibelt, varför Flask-communityn har skapat så många tillägg för många specifika uppgifter.

Som en del av handledningsserien Flask har den här självstudien ett exempel på några Flask-tillägg. Vi kommer att diskutera följande tillägg.

  1. Flask twitter Oembedder
  2. Flask API
  3. Kolv VILA

=> Besök här för att lära dig kolven från grunden

Flask API-handledning

Även om vi har diskuterat många tillägg som en del av våra tidigare självstudier, förklarar denna handledning mer med perspektivet att undersöka komponenterna i en flaskförlängning.

Vad du kommer att lära dig:

Vad är en kolvförlängning

En flaskförlängning är en installerbar Python-modul eller ett paket som implementerar ytterligare funktionalitet i en Flask-applikation. En flaskförlängning kan vara så enkel som den som ger stöd för att konsumera ett externt API som Twitter för att bädda in en tweet på en webbsida.

Eller en Flask-tillägg kan vara ett nytt ramverk som Flask API eller Flask-RESTful för att bygga appar som följer ett arkitektoniskt mönster eller ett utvecklingsparadigm.

Flask twitter Oembedder

I det här avsnittet tar vi exemplet på ett befintligt enkelt projekt med öppen källkod från här

Klona detta projekt i din lokala maskin och installera det med pip med hjälp av kommandot nedan.

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

Denna förlängning hjälper till att bädda in en Tweet med hjälp av en Jinja2-malltagg. För att kunna använda detta tillägg måste du dock ansöka om ett utvecklarkonto på Twitter. När du har fått ett utvecklarkonto skapar du en app så får du nycklar och hemligheter för att konsumera Twitters API.

vr som fungerar med xbox one

När du har nycklarna och hemligheterna, förvara dem på en säker plats så att applikationen kan komma åt dem. Vi har behållit dem i miljövariablerna och har lagt till Flask-appkonfigurationen, som visas nedan. Vår demo-app behåller konfigurationsvärdena i filen 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)

Vi får värdena på de nödvändiga variablerna från miljövariablerna. Om motsvarande värde inte finns i miljövariabeln lagras det som Ingen.

När du har lagt till ovanstående rader i konfigurationsfilen, gå till flaskans applikation __init__.py och initialisera den genom att ändra den, som visas nedan.

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

Dessa rader initialiserar Flask-tillägget. Nu kan vi ändra hello.html under mallar och lägga till taggen nedan som visas nedan.

{{ oembed_tweet('1277228221394587649') }}

Vi lade till den här taggen före for-slingan i den befintliga mallen. Den väldigt långa siffran är tweet-id. Vi får detta id från Tweet URL efter tweeting. Efter att ha sparat mallfilen navigerar vi till slutpunkten / hej / hälsningar och får resultaten, som visas i bilden nedan.

Bädda in Tweet i HTML
Bädda in Tweet i HTML

Kolv VILA

Vårt exempel på applikationen Flask RESTful är den som respekterar begränsningarna för REST-arkitekturen. Det är dock inte som ett protokoll, och utvecklarna är flexibla när de implementerar funktioner och följer REST-begränsningarna.

Läs mer om begränsningarna för REST-arkitekturen här .

Moderna webbapplikationer gör det möjligt för klienter att begära resurser på lättlästa och stabila slutpunkter på ett statslöst sätt.

Flask RESTful Exempel

Låt oss implementera några funktioner på ett RESTful sätt i vårt exempel på applikationen Flask RESTful.

Vi har ett sätt att lagra och servera data relaterade till album och låtar. Låt oss implementera ett API med Flask RESTful-tillägg.

Installera först Flask RESTful med kommandot nedan.

pip install flask-restful

För enkelt underhåll och förståelse, låt oss skapa en fil som heter api.py i appkatalogen och nämna följande kodrader i den. För närvarande överväga API: er som liknar Flask Views.

Vi kommer att implementera funktioner som motsvarar HTTP-verb för att svara när klienten skickar en begäran till serverns slutpunkt för applikationen.

öppna en xml-fil i Excel
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/')

Vi har skapat två resurser som heter Songs and Song genom att subklassa Resource abstract class av Flask-RESTful. Klassen som heter Songs har två metoder get and post som motsvarar de två HTTP-verben; GET respektive POST.

Songs-resursen serverar alla låtar till den registrerade slutpunkten när klienten begär det och lägger till en låt i listan över befintliga låtar när data publiceras vid samma slutpunkt.

På samma sätt, när det gäller klass Song, implementeras HTTP GET, DELETE och PUT med metoderna get, delete och put. Method get skickar ett svar med den begärda låten som JSON, metoden delete tar bort en låt från SONGS och put-metoden uppdaterar en befintlig låt i SONGS.

Låt oss nu lägga till dessa resurser i vårt exempelprogram genom att initialisera dem i filen __init__.py under appmappen.

from . import api

Låt oss installera curl och prova funktionerna på de angivna slutpunkterna.

sudo apt -y install curl

Få alla låtar

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

Vi får svaret, som visas nedan.

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

Låt oss nu använda kommandot nedan för att lägga till en låt.

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

Vi får svaret från vårt API, som visas nedan.

{ 'Song2': { 'title': 'Summer Days', 'singer': 'Martin Garrix2' } }

Nu igen, om vi frågar listan över låtar som vi gjorde i föregående kommando, och vi kommer att få båda låtarna i svaret.

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

På samma sätt fungerar HTTP DELETE och PUT som avsett. Låt oss lägga till några tester för version v1 av detta enkla API som vi har skapat.

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

Kör nu dessa tester från kommandoraden, som visas nedan.

pytest app/tests/test_api.py

På samma sätt kan vi skriva tester för andra metoder för mer täckning.

En viktig sak att notera är att låtarna som vi lagt till kvarstår som en del av den enda processen under vilken utvecklingsservern körs. Det betyder att alla nya data kommer att gå förlorade så snart processen stängs av.

Dessutom verkar uppgiften att skapa version v1 av API: et överflödig, och det är annorlunda än hur vi sparade data i applikationen med hjälp av formulär och vyer.

Vanligtvis kräver RESTful API-implementering att få data från klienterna, marshaling mellan klient- och serverändar och uthållighet med hjälp av databasmodeller som vi har skapat.

Dessutom är slutpunkterna säkrade för oavsiktliga och utformade ingångar.

Därför rekommenderar vi att ovanstående exempel endast är för att lära sig begreppen och begränsningarna för REST-arkitekturen med hjälp av HTTP-metoder. Kom ihåg att detta bara är ett av många sätt att webbtjänster genereras. Dessutom finns det många sätt på vilka REST-arkitekturen kan implementeras.

Vi uppmuntrar läsarna att utforska ytterligare hur REST kan ha olika filformat och anpassade metoder med andra protokoll och inte bara JSON och HTTP. Bara för att ge en glimt av en produktionsanvändning ger vi exemplet nedan.

Vi använder en Flask-Appbuilder BaseApi för att implementera liknande funktioner under olika slutpunkter. Öppna api.py-filen och uppdatera den med koden nedan.

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)

Låt oss nu lägga till några fler tester för att testa slutpunkterna som är byggda med Flask-Appbuilder. Vi kommer att köra dessa tester med 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 hjälper också till att tillhandahålla Swagger UI för att lista och prova publicerat API. Öppna config.py och uppdatera den med konfigurationen som visas nedan.

FAB_API_SWAGGER_UI=True

Navigera nu till https: // localhost: 8080 / swaggerview / v1 så kommer du att kunna se Swagger-vyn som visas nedan.

songsapi
Swagger vy av API

Låt oss nu skapa API: er för de befintliga databasmodeller som vi har. Vi måste använda ModelApi från Flask-Appbuilder.

Uppdatera api.py-filen med följande kodrader.

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)

Efter att ha definierat en klass baserad på ModelRestApi, måste vi igen registrera den hos Flask-Appbuilder med metoden add_api.

Navigera nu till Swagger UI som tidigare, och du kommer att se en API-referens som den som visas nedan.

Swagger View of Model Api
Swagger View of Model Api

Du kan prova API: et från Swagger-vyn eller genom att skicka curl till slutpunkterna som tidigare.

Flask API

Flask API är ett ramverk som liknar Django REST-ramverket. Du kan få åtkomst till Flask API-dokumentation här . Det är ersättningsstället för Flask-ramverket.

Vi kan välja något av ovanstående exempel för att implementera Flask REST API-drivna funktioner i vår applikation.

Låt oss nu begå källan och publicera ändringarna i ursprungsrepan med Git. Så snart vi förbinder oss till ursprunget med filialnamnet och skickar en pull-begäran, kommer enhetstesterna automatiskt att utlösas under Git Actions som en del av pull-begäran-kontrollerna.

Flask RestPlus

Flask RestPlus är ytterligare ett flasktillägg som hjälper till att skapa REST API med hjälp av Flask. Detta projekt har delats in i en annan förlängning som heter Flask-RESTX och underhålls inte längre.

Detta projekt har en bra samling dekoratörer för att beskriva API: erna och exponerar dess dokumentation med Swagger. Du kan kontrollera detaljerna i detta projekt här .

Vanliga frågor

F # 1) Hur skapar jag ett REST API med Flask?

Svar: Vi kan använda Flask-ramverket med andra Flask-tillägg som Flask-RESTful, Flask API, Flask RESTX, Connexion, etc. för att skapa REST API-baserade webbapplikationer. De flesta av tilläggen fungerar med de andra inbyggda funktionerna i Flask-ramverket och alla andra befintliga ORM / bibliotek.

F # 2) Vad är ett REST API-exempel?

Svar: Ett exempel på ett program som implementerar RESTFul API ges i den här självstudien. Flask-RESTful har använts för att skapa exempelapplikationen. Läs om avsnittet Flask RESTful i denna handledning.

F # 3) Vad är RESTful API för?

Svar: Ett applikationsprogrammeringsgränssnitt som vanligtvis använder HTTP-förfrågningar och har motsvarande backendmetoder för HTTP-verb som GET, POST, PUT, etc. för att tillåta kommunikation mellan klient och server kallas RESTful API.

bästa gratis systemrenare för Windows 10

En sådan applikation följer REST-arkitekturprinciper och begränsningar för att implementera dess funktioner.

Slutsats

Vi täckte begreppen Flask-tillägg med hjälp av tre tillägg, såsom Flask-twitter-oembedder, Flask API och Flask-RESTful.

Med hjälp av Flask-twitter-oembedder täckte vi också begreppen Twitter API. I allmänhet har vi också inkluderat idéerna om att implementera en RESTful-webbtjänst, som följer REST-arkitekturprinciperna och begränsningarna.

I vår nästa handledning kommer vi att täcka jämförelsen mellan Django och Flask framework för att hjälpa våra läsare att förstå styrkorna och svagheterna hos båda ramarna. Det hjälper också till att välja en ram mot den andra baserat på de specifika projektkraven.

=> Utforska The Simple Flask Training Series här

Rekommenderad läsning

^