avalanche

valanga è un framework web Python costruito sulla cima di webapp2 & nbsp;. Utilizza Jinja2 come un modello di sistema di default e non include qualsiasi strato di persistenza.
obiettivi Avalanche (o perché un altro framework web?)
Avalanche fuoco di disegno sulla verificabilità e riusabilità.
Naturalmente Avalanche non fa miracoli. Testabilità e riutilizzabilità in ultima analisi dipende dal codice dell'applicazione. Ma il quadro ha un ruolo importante sulla costituzione strada giusta.
Gli obiettivi sono presentati qui di seguito, si spera dopo aver letto il progetto e tutorial sarà chiaro a voi come si ottengono questi obiettivi.
Testability
Avalanche è stato progettato in modo che rende possibile (più facile per voi) a scrivere buoni unità di test per il vostro codice. Che non è solo la rende facile da scrivere dei test. Un'unità-test dovrebbe:
- Dare un messaggio di errore chiaro quando non riesce
- Riuscire solo se la funzione in prova è rotto, non su ogni cambiamento del codice
- Essere veloce
Riusabilità
Per lo più ogni quadro sostiene che riusabilità è uno dei loro obiettivi di progettazione. Qui "riutilizzabilità" indica il codice sorgente riusabilità.
Molti quadri forniscono alcuni meccanismi per sotto-applicazioni riutilizzabili / plugable tuttavia, non è sempre facile da riutilizzare questi codice sorgente delle applicazioni in caso di necessità di configurare / modificarlo. Applicazioni plugable è anche una caratteristica molto importante, ma fin d'ora Avalanche non ha il supporto per questo.
Non dovrebbe essere solo possibile scrivere codice riutilizzabile, il codice dovrebbe essere riutilizzabile la prima volta che si scrive. Non si dovrebbe essere consigliato di scrivere il codice in un modo, e che poi devono modificarlo per renderlo riutilizzabile. Cioè si oppone a dire "Usa vista (handler) funzioni". E poi ... "e se si desidera che le opinioni siano riutilizzabili convertire in vista basati su classi!".
Progetto Dettagli
- Sito web / docs
- Questo è un progetto open-source (licenza MIT) scritto in python.
- Scarica da Cheese Shop
- Project management (bug tracker, richieste di funzionalità e codice sorgente) su bitbucket.
- Domande e risposte su gruppo Google.
Avalanche design
Avvertimento
Avalanche è sui primi stadi di sviluppo (alpha). L'API potrebbe cambiare in futuro e non vi è alcuna garanzia che manterrà la compatibilità.
oltre MVC (Model-View-Controller)
MVC è uno schema architetturale software creato con l'obiettivo di isolare "logica dominio" dall'interfaccia utente. Questa separazione di preoccupazione consente la creazione di una migliore codice dell'applicazione. Questo modello è stato molto efficace per molti quadri desktop e quindi servito come riferimento per la creazione di web-quadri. Il problema è che questa architettura non può essere mappato direttamente al modo in cui le applicazioni web-lavoro.
Anche i cosiddetti quadri MVC non sono realmente MVC. Quindi cerchiamo di mantenere solo l'obiettivo del MVC. Che è quello di scrivere codice pulito, riutilizzabile e verificabile.
applicazioni web
In sostanza tutto un web-application fare è quello di ricevere una richiesta HTTP, processi e generare una risposta HTTP.
& Nbsp; + ------------------ +
Richiesta HTTP ------> | applicazioni web + -----> risposta HTTP
& Nbsp; + ------------------ +
Invio e ricezione di HTTP è gestita da un server web. Diamo uno sguardo più da vicino quello che fa l'applicazione web:
& Nbsp; + ------ + + ------- +
Richiesta HTTP ----> | router | -----> | handler | ----> risposta HTTP
& Nbsp; + ------ + + ------- +
Il router verificherà l'URL della richiesta e inviare a un gestore di richieste che creerà la risposta. Avalanche usa il router webapp2.
stili di richiesta movimentatori
Ci sono principalmente 3 stili di gestori delle richieste.
- Una singola funzione
- Un metodo di classe
- Una classe
Avalanche (e webapp2) utilizza il terzo stile, una classe. Utilizzando una classe come richiesta handler adatta meglio i nostri obiettivi perché offre una maggiore flessibilità, più facile da modificare / estendere e riutilizzare parti del gestore.
elaborazione della richiesta del gestore
L'elaborazione richiesta handler può essere diviso in 3 fasi:
& Nbsp; + ----------------- + + ----------------- + + --------- - +
richiedere ----> | convertitore param | ---- param oggetti ----> | builder contesto | --- contesto -----> | renderer | ----> risposta
& Nbsp; + ----------------- + + ----------------- + + --------- - +
Converter 1. param - ottenere parametri di richiesta HTTP
& Nbsp; HTTP è un protocollo di testo, l'applicazione in genere ottenere alcuni parametri della richiesta e convertire i valori di stringa in alcuni tipi di dati nativi. Questi parametri sono presi dal percorso URI, URI di query, post-dati, biscotti, etc.
2. contesto builder - elaborazione
& Nbsp; Il contesto è un termine usato per rappresentare i dati che verrà utilizzato da un renderer.
& Nbsp; Questa elaborazione è la logica dell'applicazione. Sarà spesso accedere a una strato di persistenza (a volte chiamato Model), ma questo è del tutto fino al codice dell'applicazione e il quadro non ha alcun ruolo in questo.
& Nbsp; Una pagina web è spesso composto da più elementi in modo a volte ha senso dividere il lavoro in più di una "costruttore di contesto".
3. renderer - generare l'output
& Nbsp; Il renderer convertirà il risultato della trasformazione in testo per la risposta HTTP. Questa fase può essere saltato se la risposta è un reindirizzamento HTTP. Il renderer in genere utilizzare un sistema di template per generare il codice HTML o convertire i dati JSON.
Su valanga si dovrebbe scrivere il codice per le 3 fasi del gestore separatamente e lasciare che il quadro incollare le varie parti.
. Passare al tutorial per vedere come sembra

Requisiti :

• Python