Estrutura do projeto para o Google App Engine

Iniciei um aplicativo no Google App Engine logo após o lançamento, para brincar com a tecnologia e trabalhar em um projeto que eu pensava há muito tempo, mas que nunca tinha começado. O resultado é BowlSK . No entanto, à medida que cresce, e os recursos são adicionados, ficou realmente difícil manter as coisas organizadas - principalmente devido ao fato de este ser meu primeiro projeto python, e eu não sabia nada sobre isso até começar a trabalhar.

O que eu tenho:

• O nível principal contém:
  • todos os arquivos .py (não sabia como fazer os pacotes funcionarem)
  • todos os modelos .html para páginas de nível principal
• Subdiretórios:
  • pastas separadas para css, imagens, js, etc.
  • pastas que contêm modelos .html para URLs do tipo subdiretório

Exemplo:
http://www.bowlsk.com/ mapeia para a HomePage (pacote padrão), modelo em "index.html"
http://www.bowlsk.com/games/view-series.html?series=7130 mapeia para ViewSeriesPage (novamente, pacote padrão), modelo em "games / view-series.html"

É desagradável. Como faço para reestruturar? Eu tive 2 idéias:

• Pasta principal que contém: appdef, indexes, main.py?

  • Subpasta para código. Esse tem que ser meu primeiro pacote?
  • Subpasta para modelos. A hierarquia de pastas corresponderia à hierarquia de pacotes
  • Subpastas individuais para css, imagens, js etc.

• Pasta principal contendo appdef, índices, main.py?

  • Subpasta para código + modelos. Dessa forma, tenho a classe manipuladora ao lado do modelo, porque, nesta fase, estou adicionando muitos recursos, portanto, modificações em uma significam modificações na outra. Novamente, preciso que esse nome de pasta seja o primeiro nome de pacote para minhas aulas? Gostaria que a pasta fosse "src", mas não quero que minhas classes sejam "src.WhateverPage"

Existe uma prática recomendada? Com o Django 1.0 no horizonte, há algo que eu possa fazer agora para melhorar minha capacidade de integração com ele quando ele se tornar o mecanismo oficial de modelos do GAE? Eu simplesmente começaria a tentar essas coisas e a ver o que parece melhor, mas o suporte à refatoração do pyDev não parece lidar muito bem com as movimentações de pacotes, portanto, provavelmente será uma tarefa não trivial fazer com que tudo isso funcione novamente.

Primeiro, sugiro que você dê uma olhada em " Desenvolvimento rápido com Python, Django e Google App Engine "

O GvR descreve um layout geral / padrão do projeto na página 10 de sua apresentação de slides .

Aqui vou postar uma versão ligeiramente modificada do layout / estrutura a partir dessa página. Eu praticamente sigo esse padrão. Você também mencionou que teve problemas com pacotes. Apenas verifique se cada uma de suas subpastas tem um arquivo __init__.py. Tudo bem se estiver vazio.

Arquivos Boilerplate

• Isso dificilmente varia entre os projetos
• app.yaml: direciona todas as solicitações não estáticas para main.py
• main.py: inicialize o aplicativo e envie todos os pedidos

Layout do projeto

• static / *: arquivos estáticos; veiculado diretamente pelo App Engine
• myapp / *. py: código python específico do aplicativo
  • views.py, models.py, tests.py, __init__.py e mais
• templates / *. html: templates (ou myapp / templates / *. html)

Aqui estão alguns exemplos de código que também podem ajudar:

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

Acho que esse layout funciona muito bem para projetos novos e relativamente pequenos a médios. Para projetos maiores, sugiro dividir as visualizações e modelos para ter suas próprias subpastas com algo como:

Layout do projeto

• static /: arquivos estáticos; veiculado diretamente pelo App Engine
  • js / *. js
  • images / *. gif | png | jpg
  • css / *. css
• estrutura myapp /: app
  • modelos / *. py
  • visualizações / *. py
  • testes / *. py
  • templates / *. html: modelos

Meu layout usual é mais ou menos assim:

• app.yaml
• index.yaml
• request.py - contém o aplicativo WSGI básico
• lib
  • __init__.py - funcionalidade comum, incluindo uma classe base do manipulador de solicitações
• controllers - contém todos os manipuladores. request.yaml importa isso.
• modelos
  • todos os modelos de django, usados ​​pelos controladores
• modelo
  • todas as classes de modelo do armazenamento de dados
• estático
  • arquivos estáticos (css, imagens etc.). Mapeado para / static por app.yaml

Posso fornecer exemplos de como serão meus controladores app.yaml, request.py, lib / init .py e amostra, se isso não estiver claro.

Implementei hoje um boilerplate do mecanismo de aplicativos do Google e o verifiquei no github. Isso segue as linhas descritas por Nick Johnson acima (que costumava trabalhar no Google).

Siga este link gae-boilerplate

Eu acho que a primeira opção é considerada a melhor prática. E torne a pasta de código seu primeiro pacote. O projeto Rietveld desenvolvido por Guido van Rossum é um modelo muito bom para aprender. Dê uma olhada: http://code.google.com/p/rietveld

Com relação ao Django 1.0, sugiro que você comece a usar o código de tronco do Django em vez da porta do GAE incorporada no django. Mais uma vez, veja como é feito em Rietveld.

Eu gosto do webpy, então o adotei como estrutura de modelos no Google App Engine.
Minhas pastas de pacotes são normalmente organizadas assim:

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

Aqui está um exemplo.

Não estou totalmente atualizado sobre as melhores práticas mais recentes, etc. no que diz respeito ao layout de código, mas quando fiz meu primeiro aplicativo GAE, usei algo na sua segunda opção, onde o código e os modelos estão próximos um do outro.

Havia duas razões para isso - uma: ela mantinha o código e o modelo por perto e, em segundo lugar, eu tinha o layout da estrutura de diretórios imitando o do site - tornando-o (para mim) um pouco mais fácil também para lembrar onde estava tudo.