Menu

Modello di pallone, modulo, visualizzazione e reindirizzamento con esempi

  • Principale
  • Altro
  • Modello di pallone, modulo, visualizzazione e reindirizzamento con esempi

flask template form

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega cosa sono modello Flask, modulo, visualizzazione, risposta e reindirizzamento con esempi pratici:

In generale, Templating viene utilizzato nella programmazione, per riutilizzare una porzione di testo con dati diversi. Per quanto riguarda lo sviluppo Web, i designer utilizzano modelli per visualizzare i dati in una forma leggibile e attraente per i lettori umani.

Un modello di progettazione generalmente implica l'uso di un linguaggio a causa delle complessità poste dall'interazione umana.

=> Dai un'occhiata alla guida per principianti della boccetta qui

Modelli, visualizzazioni e moduli di boccetta

Cosa imparerai:

introduzione

Flask utilizza un motore di modelli chiamato Jinja2, che mostra il comportamento di un'applicazione in base al livello di interazione dell'utente. Un modello Jinja utilizza variabili, espressioni e tag.

Le variabili e le espressioni vengono sostituite con valori durante il runtime prima del rendering della pagina nel browser. I tag Jinja aiutano nella scrittura della logica e delle istruzioni di controllo nel modello Flask.

Vista boccetta

La nozione di visualizzazione Flask deriva da un modello di progettazione di applicazioni Web prevalente chiamato Model-View-Controller. Una vista è uno dei tre elementi interconnessi in questo paradigma, dove si occupa della logica dell'applicazione. La vista si occupa della presentazione delle informazioni all'Utente.

Nel nostro tutorial precedente, abbiamo progettato una vista creando una sottoclasse della classe BaseView del Flask-Appbuilder. Nella parte successiva di questo tutorial, estenderemo il nostro ultimo esempio e presenteremo i modi in cui le viste possono essere personalizzate.

Modello di boccetta

Cominciamo e scriviamo il nostro primo modello. Crea un file chiamato hello.html nella directory dei modelli.

Scrivi il codice seguente in quel file e salvalo.

Hello World!, from Software Testing Help.

{% for item in greetings %} {% if 'Morning' in item %}

{{item}}

{% else %}

{{item}}

{% endif %} {% endfor %}

Modello per loop

Nel modello Flask sopra, abbiamo usato un ciclo for per iterare sugli elementi dell'elenco. Nel nostro controller o gestore, abbiamo passato un elenco con i valori dei saluti al modello. All'interno del modello, accediamo a ciascun elemento utilizzando la sintassi {{item}}.

Modello se blocco

Inoltre, prendi nota dell'uso di un'istruzione if. Qui, testiamo l'elemento per Mattina e lo rendiamo in grassetto e in corsivo.

Ora andiamo avanti per saperne di più sui concetti di Flask Forms.

Forme di fiasche

Uno degli aspetti più cruciali della creazione di modelli è prendere input dagli utenti e scrivere la logica di backend basata su quell'input. Creiamo un modulo.

Usiamo Flask-Appbuilder SimpleFormView per rendere il nostro modulo. Tuttavia, creiamo prima un modulo. Oltre alla creazione di un modulo, dobbiamo usare il comando flask fab create-admin per creare un utente amministratore.

Pertanto, utilizzare il comando prima di avviare il server di sviluppo in modo che le viste e i moduli creati successivamente possano essere convalidati con un utente connesso. Accediamo con l'utente amministratore e continuiamo a verificare che le visualizzazioni create siano visibili nel menu come mostrato negli screenshot.

Crea amministratore

Usa il comando seguente per creare un utente amministratore.

flask fab create-admin

Accedi con le credenziali di amministratore

  • Fare clic su Accedi dopo essere passati a http: // localhost: 8080.
Accedi come amministratore
Accedi come amministratore
  • Accedi con le credenziali di amministratore, create nella sezione precedente.
Fare clic su Accedi
Fare clic su Accedi
  • Fare clic sulla categoria I miei moduli per accedere alle visualizzazioni.
Fare clic sul menu
Fare clic sul menu

Nota: Sarai in grado di eseguire l'ultimo passaggio solo dopo aver aggiunto le visualizzazioni al menu predefinito mostrato nella barra di navigazione.

Andiamo avanti e creiamo alcune visualizzazioni basate su form.

Crea un file chiamato forms.py nella directory dell'app e scrivici il codice seguente.

from wtforms import Form, StringField from wtforms.validators import DataRequired from flask_appbuilder.fieldwidgets import BS3TextFieldWidget from flask_appbuilder.forms import DynamicForm class GreetingsForm(DynamicForm): greeting1 = StringField(('Morning'), description = ('Your morning Greeting'), validators = (DataRequired()), widget = BS3TextFieldWidget()) greeting2 = StringField(('Afternoon'), description = ('Your Afternoon Greeting'), validators = (DataRequired()), widget = BS3TextFieldWidget()) greeting3 = StringField(('Evening'), description = ('Your Evening Greeting'), widget = BS3TextFieldWidget()) greeting4 = StringField(('Night'), description = ('Your Night Greeting'), widget = BS3TextFieldWidget())

Abbiamo creato un modulo basato su DynamicForm di Flask-Appbuilder. Ci sono quattro campi di testo. Estendiamo il nostro esempio di saluto. Dei quattro campi, due sono obbligatori e due sono opzionali perché, per i primi due saluti, abbiamo menzionato i valori per i validatori.

Ora creiamo una vista per questo modulo. Scrivi le seguenti righe di codice nel file views.py.

from flask import render_template, flash from flask_appbuilder import SimpleFormView from app.forms import GreetingsForm class GreetingsView(SimpleFormView): form = GreetingsForm form_title = 'This is a Greetings form' message = 'Your Greetings are submitted' def form_get(self, form): form.greeting1.data = 'Your Morning Greeting' form.greeting2.data = 'Your Afternoon Greeting' form.greeting3.data = 'Your Evening Greeting' form.greeting4.data = 'Your Night Greeting' def form_post(self, form): flash(self.message, 'info') greetings = ( form.greeting1.data, form.greeting2.data, form.greeting3.data, form.greeting4.data, ) session('greetings')=greetings return redirect(url_for('HelloWorld.hello_greetings2'))

Nella nostra visione sopra, abbiamo due metodi chiamati form_get e form_post per popolare i valori predefiniti nei campi dei moduli e leggere i valori inseriti una volta che il modulo è stato inviato dal browser, rispettivamente.

Il GreetingsView visualizza il modulo, come mostrato nell'immagine sottostante.

Modulo di saluti

Facciamo anche uso di un oggetto di sessione Flask per memorizzare i valori del campo in form_post in modo da poter accedere allo stesso nella nuova vista corrispondente che stiamo per scrivere.

Modifichiamo ora la classe HelloWorld e aggiungiamo un altro metodo per visualizzare i saluti. Lo chiameremo hello_greetings2.

class HelloWorld(BaseView): ## other methods @expose('/greetings2') def hello_greetings2(self): greetings = session('greetings') return render_template('hello.html', greetings=greetings)

In questa visualizzazione, leggiamo i valori dall'oggetto sessione e utilizziamo il modello di rendering Flask per visualizzare tali valori nell'HTML rivolto all'utente. Nota che hello_greetings2 è un modo alternativo per ottenere la stessa funzionalità simile a hello_greetings.

L'unica differenza è che usando hello_greetings2, stiamo mostrando i valori che vengono inseriti dall'utente, e in hello_greetings non abbiamo preso alcun input dall'utente e li abbiamo codificati durante la scrittura della vista mappata sul rispettivo percorso.

Risposta del pallone

È abbastanza raro trovare l'uso esplicito della risposta Flask nel codice. La classe Response in Flask è solo una sottoclasse della classe Response della classe Response di Werkzueg, che a sua volta sottoclasse la sua classe ResponseBase.

L'oggetto Flask Response è formato internamente da Flask ogni volta che viene chiamata un'istruzione return o un metodo come render_template.

Inoltre, possiamo personalizzare il codice di risposta e il tipo di contenuto se necessario come parte dell'istruzione return nelle nostre viste, come mostrato nella vista HelloWorld modificata di seguito.

class HelloWorld(BaseView): ## other methods @expose('/greetings2') def hello_greetings2(self): greetings = session('greetings') return render_template('hello.json', greetings=greetings), 201, {'Content-Type' : 'application/json'

L'uso diretto della classe Response di Flask può essere coperto in un caso d'uso quando trasmettiamo in streaming il contenuto invece di restituire l'intero contenuto in una volta a causa dei vincoli della dimensione del file e della larghezza di banda della rete.

Abbiamo mostrato di seguito un esempio di streaming del contenuto da un CSV di grandi dimensioni.

from flask import Response @app.route('https://cdn.softwaretestinghelp.com/largefile.csv') def send_large_csv(): '''A controller to stream the content of a large csv file''' def gen(): for row in iter_all_rows(): yield ','.join(row) + ' ' return Response(gen(), mimetype='text/csv')

Flask Redirect

Non è sempre possibile per un'applicazione pre-definire la risposta in base alle diverse richieste del client.

Usiamo Flask Redirect, in scenari, in cui è possibile servire il contenuto che può essere soddisfatto dalle altre visualizzazioni o posizioni in risposta a una richiesta. Usiamo Flask Redirect insieme ad abort con i codici di ritorno HTTP standard.

Per esempio, nel codice seguente, abbiamo utilizzato Redirect con codice HTTP 301 e interrotto con 401.

from flask import Flask, redirect, url_for, request, abort app = Flask(__name__) @app.route('/') def index(): return render_template('log_in.html') # Log In template @app.route('/login',methods = ('POST', 'GET')) def login(): if request.method == 'POST': if request.form('username') == 'admin' : # if user is admin return redirect(url_for('success')), 301 else: abort(401) # stop processing else: return redirect(url_for('index')) # redirect to another view

Inoltre, controlla in GreetingsView dove abbiamo utilizzato Flask redirect e url_for per reindirizzare internamente una richiesta a una vista diversa memorizzando i valori dei saluti nell'oggetto sessione. Il reindirizzamento Flask restituisce sempre un oggetto risposta, con il codice di stato predefinito o givens in un'altra posizione nell'applicazione.

Flask Debugtoolbar

Abbiamo già introdotto il debugger interattivo di Flask nel nostro ultimo tutorial. In questo tutorial, facciamo un ulteriore passaggio per semplificare il debug dell'applicazione Flask. Una volta installata, la barra degli strumenti di debug di Flask viene visualizzata come una sovrapposizione sull'applicazione Flask.

Installa la barra degli strumenti di debug di Flask.

pip install flask-debugtoolbar

Per attivare la debugtoolbar, apri il file __init__.py nel nostro progetto e modifica il codice aggiungendo le seguenti righe di codice.

from flask_debugtoolbar import DebugToolbarExtension app.debug = True toolbar = DebugToolbarExtension(app)

Si noti che la barra degli strumenti di debug di Flask è abilitata solo in modalità di debug. Una volta abilitato, quando ricarichi l'applicazione, osserverai due cose.

# 1) La barra degli strumenti di debug viene visualizzata sul lato destro del browser. Fare clic ed espanderlo per vedere le varie funzionalità fornite dalla barra degli strumenti.

Attivazione della barra degli strumenti di debug
Attivazione della barra degli strumenti di debug

#Due) Ogni volta che una nuova richiesta POST viene inviata all'applicazione, viene intercettata dalla barra degli strumenti in modo da poter ispezionare le variabili e gli altri parametri relativi al debug dell'applicazione.

Intercetta la barra degli strumenti di debug
Intercetta la barra degli strumenti di debug

Questa intercettazione predefinita può essere disabilitata con la configurazione seguente.

app.config('DEBUG_TB_INTERCEPT_REDIRECTS') = False Risultati pytest
Debug delle variabili della barra degli strumenti

Ora scriviamo alcuni test per testare le nostre visualizzazioni per le funzionalità aggiuntive che abbiamo introdotto nell'applicazione di esempio.

sql domande di intervista di base e risposte pdf

Prima di procedere con il test, disabilitare il debug come mostrato di seguito in __init__.py. In alternativa, puoi commentare la riga sottostante.

app.debug = False

Test delle visualizzazioni dell'applicazione Flask

Dobbiamo organizzare il codice di test per renderlo più gestibile. Crea un file chiamato conftest.py nella directory principale e sposta le righe sotto indicate da test_hello.py a questo file.

from app import appbuilder import pytest @pytest.fixture def client(): ''' A pytest fixture for test client ''' appbuilder.app.config('TESTING') = True with appbuilder.app.test_client() as client: yield client

i dispositivi pytest vengono caricati da pytest in fase di esecuzione. Questi dispositivi sono disponibili e condivisi con tutti i test. La definizione di un conftest.py nel percorso radice di qualsiasi progetto è considerata una best practice perché pytest può riconoscere tutti i moduli nel progetto senza specificare un PYTHONPATH esplicito.

Aggiungi un altro test per il file test_hello. Di seguito viene fornito un test di esempio. Chiamiamo il metodo get dell'oggetto client e affermiamo il valore atteso nei dati di risposta memorizzati nei rispettivi dati.

Allo stesso modo, puoi scrivere più test che puntano a varie visualizzazioni. Scriveremo più test nei tutorial successivi.

def test_greetings(client): ''' A test method to test view hello_greetings''' resp = client.get('/hello/greetings', follow_redirects=True) assert b'Good Morning' in resp.data

Esegui i test utilizzando il comando seguente dalla directory principale del progetto.

pytest -v

L'esecuzione del test produce i risultati del test nella console, come mostrato di seguito:

Fallimento in pytest
Risultati pytest

Non ci sono ancora fallimenti. Progettiamo un altro test, come indicato di seguito.

def test_greetings2(client): ''' A test method to test view hello_greetings2 ''' resp = client.get('/hello/greetings2', follow_redirects=True) assert b'Good Morning' in resp.data

Questo test fallirà poiché non abbiamo definito alcun attributo di messaggio nella classe HelloWorld nel file views.py.

Dopo aver eseguito i test utilizzando pytest -v, i risultati simili all'immagine mostrata di seguito verranno visualizzati sulla console.

Fallimento in pytest

La sezione seguente spiega i passaggi che è necessario eseguire durante l'esecuzione dei test in una piattaforma CI / CD. Usiamo Git Actions per lo stesso progetto.

CI / CD con azioni Git

Ora salviamo tutte le modifiche nei file e creiamo un commit dando il messaggio per questo tutorial. Dopo aver eseguito il commit sul repository locale, estraiamo le modifiche dall'origine remota con il flag –rebase per vedere se ci sono conflitti con le nuove modifiche sul telecomando. Ribasiamo per mantenere la storia coerente.

Utilizzare il comando seguente per estrarre e unire le modifiche dall'origine remota. Tuttavia, salva le modifiche prima di estrarle dal telecomando.

git pull origin master --rebase

Ora controlla il ramo master locale e unisci al ramo tutorial-2. Una volta che l'unione ha esito positivo, pubblica le modifiche nel master dell'origine. Questa azione richiamerà le build sulle piattaforme di destinazione. Stiamo testando questo codice su Python3.7 e Python 3.8 su Ubuntu più recente.

Conclusione

In questo tutorial, abbiamo visto come funzionano i modelli nel framework Flask. Abbiamo delineato i passaggi per la creazione e il rendering di modelli di pallone con valori definiti dall'utente utilizzando variabili ed espressioni.

Abbiamo anche visto esempi di una vista predefinita BaseView del plug-in Flask Appbuilder. Questa vista può essere facilmente sottoclasse dagli sviluppatori di Flask per creare visualizzazioni personalizzate.

I concetti trattati finora aiutano i lettori a creare rapidamente siti Web statici e dinamici utilizzando Flask senza un database back-end. Spiegheremo come leggere e scrivere dati da e verso i database con ModelView nel prossimo tutorial quando esamineremo il concetto di utilizzo dei database con Flask.

=> Leggere attraverso la serie di formazione Easy Flask

Lettura consigliata

^