para - google app engine python

Estructura del proyecto para Google App Engine

Question

Inicié una aplicación en Google App Engine justo cuando salió, para jugar con la tecnología y trabajar en un proyecto de mascota en el que había estado pensando durante mucho tiempo pero que nunca había estado a punto de comenzar. El resultado es http://www.bowlsk.com/ . Sin embargo, como ha crecido y se han agregado características, se ha vuelto realmente difícil mantener las cosas organizadas, principalmente debido a que este es mi primer proyecto python, y no supe nada hasta que comencé a trabajar.

Lo que tengo:

• El nivel principal contiene:
  • todos los archivos .py (no sabían cómo hacer que los paquetes funcionaran)
  • todas las plantillas .html para páginas de nivel principal
• Subdirectorios:
  • carpetas separadas para css, imágenes, js, etc.
  • carpetas que contienen plantillas .html para direcciones de tipo subdirecty

Ejemplo:
http://www.bowlsk.com/ asigna a HomePage (paquete predeterminado), plantilla en "index.html"
http://www.bowlsk.com/games/view-series.html?series=7130 asigna a ViewSeriesPage (de nuevo, paquete predeterminado), plantilla en "games / view-series.html"

Es desagradable. ¿Cómo me reestructura? Tenía 2 ideas:

• Carpeta principal que contiene: appdef, indexes, main.py?

  • Subcarpeta para el código. ¿Este tiene que ser mi primer paquete?
  • Subcarpeta para plantillas. La jerarquía de carpetas coincidiría con la jerarquía del paquete
  • Subcarpetas individuales para css, imágenes, js, etc.

• Carpeta principal que contiene appdef, indexes, main.py?

  • Subcarpeta para código + plantillas. De esta forma, tengo la clase de controlador justo al lado de la plantilla, porque en esta etapa agrego muchas características, por lo que las modificaciones en una significan modificaciones en la otra. De nuevo, ¿tengo que tener este nombre de carpeta como el primer nombre del paquete para mis clases? Me gustaría que la carpeta sea "src", pero no quiero que mis clases sean "src.WhateverPage"

¿Hay una mejor práctica? Con Django 1.0 en el horizonte, ¿hay algo que pueda hacer ahora para mejorar mi capacidad de integración cuando se convierta en el motor oficial de plantillas de GAE? Simplemente comenzaría a probar estas cosas, y ver qué parece mejor, pero el soporte de refactorización de pyDev no parece manejar los movimientos del paquete muy bien, por lo que probablemente será una tarea no trivial para que todo vuelva a funcionar.

Answer 1

Creo que la primera opción se considera la mejor práctica. Y convierta la carpeta de códigos en su primer paquete. El proyecto Rietveld desarrollado por Guido van Rossum es un muy buen modelo para aprender. Échale un vistazo: http://code.google.com/p/rietveld

Con respecto a Django 1.0, le sugiero que empiece a usar el código troncal de Django en lugar del GAE integrado en el puerto django. Nuevamente, eche un vistazo a cómo se hace en Rietveld.

Answer 2

Implementé un texto repetitivo del motor de la aplicación de Google hoy y lo revisé en github. Esto es a lo largo de las líneas descritas por Nick Johnson arriba (que solía trabajar para Google).

Siga este enlace gae-boilerplate

Answer 3

Me gusta webpy así que lo he adoptado como marco de plantillas en Google App Engine.
Mis carpetas de paquetes generalmente se organizan así:

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

Here hay un ejemplo.

Answer 4

Mi diseño habitual se ve así:

• app.yaml
• index.yaml
• request.py - contiene la aplicación básica de WSGI
• lib
  • __init__.py : funcionalidad común, incluida una clase base de manejador de solicitudes
• Controladores: contiene todos los controladores. request.yaml importa estos.
• plantillas
  • todas las plantillas django, utilizadas por los controladores
• modelo
  • todas las clases de modelo de almacén de datos
• estático
  • archivos estáticos (CSS, imágenes, etc.). Asignado a / static por app.yaml

Puedo proporcionar ejemplos de cómo se ven mis app.yaml, request.py, lib / init .py y los controladores de muestra, si esto no está claro.

Answer 5

No estoy del todo actualizado sobre las últimas mejores prácticas, etcétera, cuando se trata del diseño del código, pero cuando hice mi primera aplicación GAE, utilicé algo a lo largo de su segunda opción, donde el código y las plantillas están uno junto al otro.

Había dos razones para esto: una, mantenía el código y la plantilla cerca, y en segundo lugar, tenía el diseño de la estructura del directorio imitando al del sitio web, por lo que (para mí) era un poco más fácil también recordar dónde estaba todo.

Answer 6

Primero, sugiero que eche un vistazo a " Desarrollo rápido con Python, Django y Google App Engine ".

GvR describe un diseño de proyecto general / estándar en la página 10 de su presentación de diapositivas .

Aquí publicaré una versión ligeramente modificada del diseño / estructura de esa página. Yo prácticamente sigo este patrón yo mismo. También mencionó que tuvo problemas con los paquetes. Solo asegúrese de que cada una de sus subcarpetas tenga un archivo __init__.py. Está bien si está vacío.

Archivos repetitivos

• Estos apenas varían entre proyectos
• app.yaml: dirige todas las solicitudes no estáticas a main.py
• main.py: inicializar la aplicación y enviarla todas las solicitudes

Diseño del proyecto

• static / *: archivos estáticos; servido directamente por App Engine
• myapp / *. py: código python específico de la aplicación
  • views.py, models.py, tests.py, __init__.py y más
• templates / *. html: templates (o myapp / templates / *. html)

Aquí hay algunos ejemplos de códigos que también pueden ser de ayuda:

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

Creo que este diseño funciona muy bien para proyectos nuevos y relativamente pequeños o medianos. Para proyectos más grandes, sugiero dividir las vistas y modelos para tener sus propias subcarpetas con algo como:

Diseño del proyecto

• archivos estáticos /: estáticos; servido directamente por App Engine
  • js / *. js
  • images / *. gif | png | jpg
  • css / *. css
• myapp /: estructura de la aplicación
  • modelos / *. py
  • vistas / *. py
  • pruebas / *. py
  • templates / *. html: plantillas