Struttura di progetto per Google App Engine

Question

Ho iniziato un'applicazione di Google App Engine destra quando è uscito, per giocare con la tecnologia e il lavoro su un progetto di pet che avevo pensato per lungo tempo, ma non è mai andata in giro a partire.Il risultato è BowlSK.Tuttavia, come è cresciuto, e le caratteristiche che sono state aggiunte, è diventato davvero difficile mantenere le cose organizzate, soprattutto a causa del fatto che questo è il mio primo progetto di python, e non sapevo nulla fino a quando ho iniziato a lavorare.

Quello che ho:

• Livello principale contiene:
  • tutti .py file (non sapevo come fare pacchetti di lavoro)
  • tutti .modelli html per i principali pagine di livello
• Sottodirectory:
  • cartelle separate per i css, immagini, js, etc.
  • le cartelle che contengono .modelli html per subdirecty-tipo di url

Esempio:
http://www.bowlsk.com/ le mappe HomePage (pacchetto di default), modello "index.html"
http://www.bowlsk.com/games/view-series.html?series=7130 mappe per ViewSeriesPage (di nuovo, pacchetto di default), modello "games/view-series.html"

E ' brutto.Come faccio a ristrutturare?Ho avuto 2 idee:

• La Cartella principale contenente:appdef, indici, main.py?

  • Sottocartella per il codice.Questo doveva essere il mio primo pacchetto?
  • Sottocartella per i modelli.Cartella gerarchia che sarebbe partita pacchetto gerarchia
  • Singole sottocartelle per i css, immagini, js, etc.

• La Cartella principale contenente appdef, indici, main.py?

  • Sottocartella per codice + modelli.In questo modo ho la classe del gestore a destra accanto al modello, perché in questa fase, sono l'aggiunta di un sacco di funzioni, pertanto le modifiche a una media modifiche all'altro.Di nuovo, devo avere il nome di questa cartella sarà il primo nome del pacchetto per le mie lezioni?Mi piacerebbe che la cartella "src", ma non voglio che le mie classi "src.WhateverPage"

C'è una best practice?Con Django 1.0, all'orizzonte, c'è qualcosa che posso fare ora per migliorare la mia capacità di integrarsi con esso quando diventa ufficiale GAE motore di template?Vorrei semplicemente iniziare a provare queste cose, e vedendo che sembra migliore, ma pyDev di refactoring di supporto non sembra gestire il pacchetto si muove molto bene, quindi è probabile che non sia facile per ottenere tutto questo a lavorare di nuovo.

Answer 1

Primo, vorrei suggerire di avere uno sguardo a "Il rapido Sviluppo con Python, Django, e Google App Engine"

GvR descrive una generale/standard-layout di progetto a pagina 10 del suo presentazione.

Qui vi posto una versione leggermente modificata del layout/struttura dalla pagina.Mi sono molto seguire questo schema di me.Lei ha anche detto che hai avuto problemi con i pacchetti.Basta assicurarsi che ciascuna delle sottocartelle ha un __init__.py file.E ' ok se il suo vuoto.

File preimpostati

• Questi difficilmente variano tra i progetti
• app.yaml:diretto a tutti i non-statico richieste per main.py
• main.py:inizializzare app e inviare tutte le richieste

Progetto di lay-out

• statico/*:i file statici;servita direttamente da App Engine
• myapp/*.py:per la specifica applicazione del codice python
  • views.py, models.py, tests.py, __init__.py e più
• templates/*.html:modelli (o myapp/templates/*.html)

Ecco alcuni esempi di codice che può aiutare pure:

main.py

import wsgiref.handlers

from google.appengine.ext import webapp
from myapp.views import *

application = webapp.WSGIApplication([
  ('/', IndexHandler),
  ('/foo', FooHandler)
], debug=True)

def main():
  wsgiref.handlers.CGIHandler().run(application)

myapp/views.py

import os
import datetime
import logging
import time

from google.appengine.api import urlfetch
from google.appengine.ext.webapp import template
from google.appengine.api import users
from google.appengine.ext import webapp
from models import *

class IndexHandler(webapp.RequestHandler):
  def get(self):
    date = "foo"
    # Do some processing        
    template_values = {'data': data }
    path = os.path.join(os.path.dirname(__file__) + '/../templates/', 'main.html')
    self.response.out.write(template.render(path, template_values))

class FooHandler(webapp.RequestHandler):
  def get(self):
    #logging.debug("start of handler")

myapp/models.py

from google.appengine.ext import db

class SampleModel(db.Model):

Penso che questo layout funziona alla grande per la nuova e relativamente piccoli e medi progetti.Per i progetti più grandi suggerisco di rompere i punti di vista e modelli per avere i loro sub-cartelle con qualcosa come:

Progetto di lay-out

• statico/:i file statici;servita direttamente da App Engine
  • js/*.js
  • immagini/*.gif|png|jpg
  • css/*.css
• myapp/:app struttura
  • modelli/*.py
  • vista/*.py
  • test/*.py
  • templates/*.html:modelli

Answer 2

Il mio solito layout simile a questa:

• app.yaml
• indice.yaml
• request.py - contiene la base WSGI app
• lib
  • __init__.py - funzionalità comuni, tra cui un gestore di richieste di base di classe
• controller - contiene tutti i gestori.richiesta.yaml le importazioni di questi.
• modelli
  • tutti i modelli di django, utilizzato dal controller
• modello
  • tutti i tipi di classi del modello
• statico
  • i file statici (css, immagini, ecc).Mappata /statica delle app.yaml

Posso fornire esempi di ciò che la mia app.yaml, request.py lib/init.py, e il campione di controller simile, se questo non è chiaro.

Answer 3

Ho implementato una google app engine standard di oggi e di controllo su github.Questo è lungo le linee descritte da Nick Johnson sopra (che ha usato per lavorare per Google).

Segui questo link gae-standard

Answer 4

Io penso che la prima opzione è considerata la migliore pratica.E rendere il codice cartella il primo pacchetto.Rietveld progetto sviluppato da Guido van Rossum è un ottimo modello per imparare.Dai un'occhiata: http://code.google.com/p/rietveld

Per quanto riguarda Django 1.0, ti suggerisco di iniziare a utilizzare il Django tronco di codice invece di GAE costruito in django porta.Di nuovo, dare un'occhiata a come è fatto in Rietveld.

Answer 5

Mi piace webpy così ho adottato come template framework su Google App Engine.
Il mio pacchetto cartelle sono in genere organizzati come questo:

app.yaml
application.py
index.yaml
/app
   /config
   /controllers
   /db
   /lib
   /models
   /static
        /docs
        /images
        /javascripts
        /stylesheets
   test/
   utility/
   views/

Qui è un esempio.

Answer 6

Io non sono del tutto aggiornati sulle più recenti best practice, et cetera, quando si tratta di layout del codice, ma quando ho fatto il mio primo GAE applicazione, ho usato qualcosa lungo la tua seconda opzione, in cui il codice e i modelli sono accanto a vicenda.

C'erano due ragioni per questo, ha conservato il codice e il modello di interesse, e, in secondo luogo, ho avuto la struttura di directory layout di imitare quella del sito - il che lo rende (per me) un po ' troppo facile ricordare dove era tutto.