Estrutura do projeto para Google App Engine

Question

Comecei um aplicativo no Google App Engine logo quando ele foi lançado, para brincar com a tecnologia e trabalhar em um projeto favorito que estava pensando há muito tempo, mas nunca tive tempo de começar.O resultado é TigelaSK.No entanto, à medida que cresceu e recursos foram adicionados, ficou muito difícil manter as coisas organizadas - principalmente devido ao fato de que este é meu primeiro projeto python e eu não sabia nada sobre ele 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 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 ideias:

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

  • Subpasta para código.Este 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, pois nesta etapa estou adicionando muitos recursos, portanto, modificações em um significam modificações no outro.Novamente, preciso que esse nome de pasta seja o primeiro nome do pacote para minhas aulas?Gostaria que a pasta fosse "src", mas não quero que minhas classes fossem "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 de modelagem oficial do GAE?Eu simplesmente começaria a tentar essas coisas e ver o que parece melhor, mas o suporte à refatoração do pyDev não parece lidar muito bem com movimentos de pacotes, então provavelmente será uma tarefa nada trivial fazer tudo isso funcionar novamente.

Answer 1

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

GvR descreve um layout de projeto geral/padrão na página 10 de seu Apresentação de slide.

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

Arquivos padrão

• Estes dificilmente variam entre projetos
• aplicativo.yaml:direcione todas as solicitações não estáticas para main.py
• principal.py:inicialize o aplicativo e envie todas as solicitações

Layout do projeto

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

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

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)

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

meuapp/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 e médios.Para projetos maiores eu sugeriria dividir as visualizações e modelos para ter suas próprias subpastas com algo como:

Layout do projeto

• estático/:arquivos estáticos;veiculado diretamente pelo App Engine
  • js/*.js
  • imagens/*.gif|png|jpg
  • css/*.css
• meu aplicativo/:estrutura do aplicativo
  • modelos/*.py
  • visualizações/*.py
  • testes/*.py
  • modelos/*.html:modelos

Answer 2

Meu layout normal é mais ou menos assim:

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

Posso fornecer exemplos do que meu app.yaml, request.py, lib/iniciar.py e os controladores de exemplo, se isso não estiver claro.

Answer 3

Implementei um padrão do Google App Engine hoje e verifiquei-o no GitHub.Isso segue as linhas descritas por Nick Johnson acima (que trabalhava para o Google).

Siga este link gae-boilerplate

Answer 4

Acho que a primeira opção é considerada a melhor prática.E faça da pasta de código seu primeiro pacote.O projeto Rietveld desenvolvido por Guido van Rossum é um modelo muito bom para aprender.Dê uma olhada nisso: 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 do GAE embutido na porta do Django.Novamente, dê uma olhada em como isso é feito em Rietveld.

Answer 5

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

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

Aqui é um exemplo.

Answer 6

Não estou totalmente atualizado sobre as práticas recomendadas mais recentes, etc., quando se trata de 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 ficam próximos um do outro.

Houve duas razões para isso - uma, ele manteve o código e o modelo próximos e, em segundo lugar, fiz com que o layout da estrutura de diretórios imitasse o do site - tornando (para mim) um pouco mais fácil de lembrar onde tudo estava.