Structure du projet pour Google App Engine

StackOverflow https://stackoverflow.com/questions/48458

  •  09-06-2019
  •  | 
  •  

Question

J'ai lancé une application dans Google App Engine dès sa sortie, pour jouer avec la technologie et travailler sur un projet favori auquel je pensais depuis longtemps mais que je n'avais jamais réussi à démarrer.Le résultat est BolSK.Cependant, à mesure qu'il s'est développé et que des fonctionnalités ont été ajoutées, il est devenu très difficile de garder les choses organisées - principalement à cause du fait qu'il s'agit de mon premier projet Python et que je n'en savais rien avant de commencer à travailler.

Ce que j'ai:

  • Le niveau principal contient :
    • tous les fichiers .py (je ne savais pas comment faire fonctionner les packages)
    • tous les modèles .html pour les pages de niveau principal
  • Sous-répertoires :
    • dossiers séparés pour CSS, images, js, etc.
    • dossiers contenant des modèles .html pour les URL de type sous-répertoire

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

C'est dégueulasse.Comment restructurer ?J'avais 2 idées :

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

    • Sous-dossier pour le code.Est-ce que cela doit être mon premier colis ?
    • Sous-dossier pour les modèles.La hiérarchie des dossiers correspondrait à la hiérarchie des packages
    • Sous-dossiers individuels pour CSS, images, js, etc.

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

    • Sous-dossier pour le code + les modèles.De cette façon, j'ai la classe de gestionnaire juste à côté du modèle, car à ce stade, j'ajoute de nombreuses fonctionnalités, donc les modifications apportées à l'une signifient des modifications à l'autre.Encore une fois, dois-je que ce nom de dossier soit le premier nom de package pour mes cours ?J'aimerais que le dossier soit "src", mais je ne veux pas que mes classes soient "src.WhateverPage".

Existe-t-il une bonne pratique ?Avec Django 1.0 à l'horizon, y a-t-il quelque chose que je puisse faire maintenant pour améliorer ma capacité à m'intégrer lorsqu'il deviendra le moteur de création de modèles GAE officiel ?Je commencerais simplement à essayer ces choses et à voir laquelle semble la meilleure, mais le support de refactoring de pyDev ne semble pas très bien gérer les déplacements de packages, donc ce sera probablement une tâche non triviale de faire fonctionner à nouveau tout cela.

Était-ce utile?

La solution

Tout d'abord, je vous suggère de jeter un œil à "Développement rapide avec Python, Django et Google App Engine"

GvR décrit une présentation générale/standard du projet à la page 10 de son diaporama.

Ici, je publierai une version légèrement modifiée de la mise en page/structure de cette page.Je suis moi-même à peu près ce modèle.Vous avez également mentionné que vous aviez des problèmes avec les packages.Assurez-vous simplement que chacun de vos sous-dossiers contient un fichier __init__.py.Ce n'est pas grave si c'est vide.

Fichiers standards

  • Ceux-ci varient peu d’un projet à l’autre
  • app.yaml :diriger toutes les requêtes non statiques vers main.py
  • main.py :initialiser l'application et lui envoyer toutes les demandes

Présentation du projet

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

Voici quelques exemples de code qui peuvent également 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)

monapplication/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")

monapplication/models.py

from google.appengine.ext import db

class SampleModel(db.Model):

Je pense que cette mise en page fonctionne très bien pour les projets nouveaux et relativement petits à moyens.Pour les projets plus importants, je suggérerais de diviser les vues et les modèles pour avoir leurs propres sous-dossiers avec quelque chose comme :

Présentation du projet

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

Autres conseils

Ma disposition habituelle ressemble à ceci :

  • app.yaml
  • index.yaml
  • request.py - contient l'application WSGI de base
  • lib
    • __init__.py - fonctionnalités communes, y compris une classe de base de gestionnaire de requêtes
  • contrôleurs - contient tous les gestionnaires.request.yaml les importe.
  • modèles
    • tous les modèles Django, utilisés par les contrôleurs
  • modèle
    • toutes les classes de modèles de banque de données
  • statique
    • fichiers statiques (css, images, etc.).Mappé sur /static par app.yaml

Je peux fournir des exemples de ce que mon app.yaml, request.py, lib/initialisation.py et les exemples de contrôleurs ressemblent, si ce n'est pas clair.

J'ai implémenté aujourd'hui un modèle de moteur d'application Google et je l'ai vérifié sur github.Cela va dans le sens décrit par Nick Johnson ci-dessus (qui travaillait pour Google).

Suivez ce lien gae-passe-partout

Je pense que la première option est considérée comme la meilleure pratique.Et faites du dossier code votre premier package.Le projet Rietveld développé par Guido van Rossum est un très bon modèle dont on peut tirer des leçons.Jetez-y un oeil : http://code.google.com/p/rietveld

En ce qui concerne Django 1.0, je vous suggère de commencer à utiliser le code réseau de Django au lieu du port Django intégré à GAE.Encore une fois, jetez un œil à la façon dont cela se déroule à Rietveld.

J'aime Webpy je l'ai donc adopté comme framework de modèles sur Google App Engine.
Mes dossiers de packages sont généralement organisés comme ceci :

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

Ici est un exemple.

Je ne suis pas entièrement au courant des dernières meilleures pratiques, et cetera en matière de mise en page du code, mais lorsque j'ai réalisé ma première application GAE, j'ai utilisé quelque chose avec votre deuxième option, où le code et les modèles sont côte à côte.

Il y avait deux raisons à cela : premièrement, le code et le modèle étaient conservés à proximité, et deuxièmement, la structure des répertoires imitait celle du site Web, ce qui rendait (pour moi) un peu plus facile de se rappeler où tout se trouvait.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top