Estructura del proyecto para Google App Engine

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

  •  09-06-2019
  •  | 
  •  

Pregunta

Comencé una aplicación en Google App Engine justo cuando salió, para jugar con la tecnología y trabajar en un proyecto favorito en el que había estado pensando durante mucho tiempo pero que nunca logré comenzar.El resultado es CuencoSK.Sin embargo, a medida que creció y se agregaron funciones, se volvió muy difícil mantener las cosas organizadas, principalmente debido al hecho de que este es mi primer proyecto de Python y no sabía nada al respecto hasta que comencé a trabajar.

Lo que tengo:

  • El nivel principal contiene:
    • todos los archivos .py (no sabía cómo hacer que funcionen los paquetes)
    • 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 URL de tipo subdirectorio

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

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

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

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

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

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

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

¿Fue útil?

Solución

En primer lugar, te sugiero que eches 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.También mencionaste que tuviste 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.
  • aplicación.yaml:dirigir todas las solicitudes no estáticas a main.py
  • principal.py:Inicializar la aplicación y enviarle todas las solicitudes.

diseño del proyecto

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

Aquí hay algunos ejemplos de código que también pueden ayudar:

principal.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)

miaplicación/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")

miaplicación/modelos.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 a medianos.Para proyectos más grandes, sugeriría dividir las vistas y los modelos para tener sus propias subcarpetas con algo como:

diseño del proyecto

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

Otros consejos

Mi diseño habitual se parece a esto:

  • aplicación.yaml
  • índice.yaml
  • request.py: contiene la aplicación WSGI básica
  • biblioteca
    • __init__.py - funcionalidad común, incluida una clase base de controlador de solicitudes
  • controladores: contiene todos los controladores.request.yaml los importa.
  • plantillas
    • todas las plantillas de 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 lo que mi app.yaml, request.py, lib/en eso.py y los controladores de muestra, si esto no está claro.

Implementé un modelo estándar del motor de aplicaciones de Google hoy y lo verifiqué en github.Esto sigue la línea descrita anteriormente por Nick Johnson (que solía trabajar para Google).

Siga este enlace gae-repetitivo

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

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

Me gusta Webpy así que lo adopté como marco de plantillas en Google App Engine.
Las carpetas de mis paquetes normalmente se organizan así:

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

Aquí es un ejemplo.

No estoy completamente actualizado sobre las últimas mejores prácticas, etc., en lo que respecta al diseño del código, pero cuando hice mi primera aplicación GAE, utilicé algo junto con su segunda opción, donde el código y las plantillas están uno al lado del 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, lo que hacía (para mí) un poco más fácil recordar dónde estaba todo.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top