Structure du projet pour Google App Engine

Question

J'ai commencé une application dans Google App Engine droit quand il est sorti, à jouer avec de la technologie et de travailler sur un petit projet que j'avais pensé depuis longtemps mais jamais eu l'occasion de le commencer. Le résultat est BowlSK. Cependant, comme il a grandi, et les fonctionnalités ont été ajoutées, c'est devenu vraiment difficile de garder les choses organisées, principalement en raison du fait que c'est mon premier projet de python, et je ne savais rien à ce sujet jusqu'à ce que j'ai commencé à travailler.

Ce que j'ai:

• Niveau principal contient:
  • tous les .py fichiers (il ne savait pas comment faire des paquets de travail)
  • tous les .modèles html pour les principales pages de niveau
• Les sous-répertoires:
  • des dossiers distincts pour les css, images, js, etc.
  • les dossiers qui les détiennent .modèles html pour subdirecty de type url

Exemple:
http://www.bowlsk.com/ cartes à la page d'Accueil (par défaut), modèle "index.html"
http://www.bowlsk.com/games/view-series.html?series=7130 cartes de ViewSeriesPage (encore une fois, package par défaut), modèle "games/view-series.html"

C'est méchant. Comment restructurer? J'ai eu 2 idées:

• Dossier principal contenant: appdef, index, main.py?

  • Sous-dossier pour code. Est-ce que avez à être mon premier paquet?
  • Sous-dossier pour les modèles. Hiérarchie de dossiers correspondent paquet hiérarchie
  • Les sous-dossiers individuels pour le css, images, js, etc.

• Dossier principal contenant appdef, index, main.py?

  • Sous-dossier pour code + modèles. De cette façon, j'ai la classe de gestionnaire droit à côté du modèle, car à ce stade, je vais ajouter beaucoup de fonctionnalités, de sorte que les modifications apportées à une moyenne de modifications à l'autre. Encore une fois, dois-je avoir ce nom de dossier être le premier nom de package pour mes cours? J'aimerais le dossier "src", mais je ne veux pas que ma classe soit "src.WhateverPage"

Est-il une meilleure pratique? Avec Django 1.0 sur l'horizon, il y a une chose que je peux faire maintenant pour améliorer ma capacité à intégrer avec elle quand il devient l'officiel GAE moteur de template? Je voudrais simplement commencer à essayer ces choses, et de voir ce qui semble mieux, mais pyDev de la prise en charge du refactoring ne semble pas gérer les déplacements des paquets très bien, donc il sera probablement une tâche non triviale pour obtenir tout cela fonctionne à nouveau.

Merci.

Answer 1

Tout d'abord, je vous suggère d'avoir un coup d'oeil au "Développement Rapide avec Python, Django, et Google App Engine"

GvR décrit un général/standard de présentation de projet à la page 10 de son diaporama.

Ici, je vais poster une version légèrement modifiée de la mise en page/la structure de la page. J'ai assez bien suivre ce modèle moi-même. Vous avez également mentionné que vous avez eu le problème avec les paquets. Juste assurez-vous que chacun de vos sous-dossiers a une __init__.py fichier. C'est ok si son vide.

Passe-partout de fichiers

• Ces difficilement varier entre les projets
• app.yaml: direct tous les non-statiques demandes de main.py
• main.py: initialiser l'application et de l'envoyer à toutes les demandes

Projet de mise en

• statique/*: les fichiers statiques; servi directement par App Engine
• myapp/*.py: spécifiques à l'application du code python
  • views.py, models.py, tests.py, __init__.py et plus
• templates/*.html: les modèles (ou myapp/templates/*.html)

Voici quelques exemples de code qui peut vous aider:

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):

Je pense que cette configuration fonctionne très bien pour les nouveaux et relativement petites et moyennes projets. Pour les grands projets je suggère d'en briser les vues et les modèles ont leur propre sous-dossiers avec quelque chose comme:

Projet de mise en

• statique/: fichiers statiques; servi directement par App Engine
  • js/*.js
  • images/*.gif|png|jpg
  • css/*.css
• myapp/: application de la structure
  • modèles/*.py
  • des vues/*.py
  • tests/*.py
  • templates/*.html: les modèles

Answer 2

Mon habituel de mise en page ressemble à quelque chose comme ceci:

• app.yaml
• index.yaml
• request.py - contient la base de WSGI app
• lib
  • __init__.py - commune de fonctionnalités, y compris un gestionnaire de requêtes de la classe de base
• contrôleurs - contient tous les gestionnaires. demande.yaml ces importations.
• modèles
  • tous les modèles django, utilisées par les contrôleurs
• modèle
  • toutes les classes du modèle du datastore
• statique
  • les fichiers statiques (css, images, etc). Mappé /statique par l'app.yaml

Je peux donner des exemples de ce que mon application.yaml, request.py, lib/init.py, et l'échantillon de contrôleurs de ressembler, si ce n'est pas clair.

Answer 3

J'ai implémenté un moteur de recherche google app aujourd'hui et l'ai vérifié sur github. Cela correspond aux lignes décrites par Nick Johnson ci-dessus (qui travaillait pour Google).

Suivez ce lien gae-boilerplate

Answer 4

Je pense que la première option est considérée comme la meilleure pratique. Et faites du dossier de code votre premier paquet. Le projet Rietveld développé par Guido van Rossum est un très bon modèle à apprendre. Regardez-le: http://code.google.com/p/rietveld

En ce qui concerne Dangjo 1.0, je vous suggère de commencer à utiliser le code de jonction Django au lieu du port intégré django GAE. Encore une fois, regardez comment ça se passe à Rietveld.

Answer 5

J'aime webpy donc je l'ai adopté comme framework de templates sur Google App Engine.
Les dossiers de mon paquet sont généralement organisés comme suit:

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

Voici un exemple.