Prosjektstruktur for Google App Engine

stemmer
118

Jeg startet et program i Google App Engine rett når det kom ut, leke med teknologi og arbeidet med et kjæledyr prosjekt som jeg hadde tenkt på i lang tid, men aldri fått rundt å starte. Resultatet er BowlSK . Men som det har vokst, og funksjoner har blitt lagt til, har det blitt veldig vanskelig å holde ting organisert - hovedsakelig på grunn av det faktum at dette er min første python prosjekt, og jeg visste ikke noe om det før jeg begynte å jobbe.

Hva jeg har:

  • Hovednivå inneholder:
    • alle .py filer (ikke visste hvordan å gjøre pakker arbeid)
    • alle html maler for hoved nivå sidene
  • underkataloger:
    • egne mapper for css, bilder, js, etc.
    • mapper som holder html maler for subdirecty-type webadresser

Eksempel:
http://www.bowlsk.com/ kart til Homepage (standard pakke), mal på index.html
http://www.bowlsk.com/games/view-series.html?series=7130 kart å ViewSeriesPage (igjen, standard pakke), mal på spill / vis-series.html

Det er ekkelt. Hvordan omstrukturere jeg? Jeg hadde 2 ideer:

  • Hovedmappe inneholder: appdef, indekser, main.py?

    • Mappen for kode. Har dette å være min første pakke?
    • Mappen for maler. Folder hierarki ville matche pakken hierarki
    • Individuelle undermapper for css, bilder, js, etc.
  • Hovedmappe inneholder appdef, indekser, main.py?

    • Mappen for kode + maler. På denne måten har jeg behandleren klassen rett ved siden av malen, fordi i denne fasen, jeg legger massevis av funksjoner, så modifikasjoner til en gjennomsnitts modifikasjoner til den andre. Igjen må jeg ha denne mappenavnet være den første pakken navn for mine klasser? Jeg vil gjerne mappen for å være src, men jeg ønsker ikke mine klasser å være src.WhateverPage

Er det en beste praksis? Med Django 1,0 i horisonten, er det noe jeg kan gjøre nå for å forbedre min evne til å integrere med det når det blir offisiell GAE templating motor? Jeg ville rett og slett begynne å prøve disse tingene, og se hvilke virker bedre, men pyDev er refactoring støtte ser ikke ut til å håndtere pakken går veldig bra, så det vil trolig være en ikke-triviell oppgave å få alt dette fungerer igjen.

Publisert på 07/09/2008 klokken 14:08
kilden bruker
På andre språk...                            


6 svar

stemmer
104

Først vil jeg foreslå du ta en titt på " Rapid Development med Python, Django, og Google App Engine "

GVR beskriver en generell / standard prosjekt layout på side 10 i sin lysbildepresentasjon .

Her vil jeg legge en litt modifisert versjon av layout / struktur fra den siden. Jeg ganske mye følger dette mønsteret selv. Du nevnte også at du hadde problemer med pakker. Bare sørg for at hver av undermapper har en __init__.py fil. Det er ok hvis den er tom.

tekst filer

  • Disse neppe variere mellom prosjekter
  • app.yaml: direkte alle ikke-statiske forespørsler om å main.py
  • main.py: initial app og sende det alle forespørsler

Prosjekt lay-out

  • statisk / *: statiske filer; servert direkte av App Engine
  • . MinApp / * py: app-spesifikke python kode
    • views.py, models.py, tests.py, __init__.py, og mer
  • . Templates / * html: maler (. Eller MinApp / templates / * html)

Her er noen kode eksempler som kan hjelpe også:

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)

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

MinApp / models.py

from google.appengine.ext import db

class SampleModel(db.Model):

Jeg tror dette oppsettet fungerer bra for nye og relativt små til mellomstore prosjekter. For større prosjekter vil jeg foreslå å bryte opp visningene og modeller til å ha sine egne undermapper med noe sånt som:

Prosjekt lay-out

  • statisk /: statiske filer; servert direkte av App Engine
    • JS / *. js
    • images / * gif. | png | jpg
    • css / *. css
  • MinApp /: app struktur
    • modeller / *. py
    • visninger / *. py
    • tester / *. py
    • . Templates / * html: maler
Svarte 16/09/2008 kl. 08:10
kilden bruker

stemmer
16

Min vanlige oppsettet ser omtrent slik ut:

  • app.yaml
  • index.yaml
  • request.py - inneholder grunn WSGI app
  • lib
    • __init__.py - felles funksjonalitet, inkludert en forespørsel handler base klasse
  • kontrollerne - inneholder alle handlers. request.yaml importerer disse.
  • maler
    • alle Django maler, som brukes av kontrollerne
  • modell
    • alle datalager modellklassene
  • statisk
    • statiske filer (css, bilder etc). Tilordnet / statisk ved app.yaml

Jeg kan gi eksempler på hva min app.yaml, request.py, lib / init .py, og prøvekontroller se ut, hvis dette ikke er klart.

Svarte 30/09/2008 kl. 16:30
kilden bruker

stemmer
11

Jeg implementert en Google App Engine tekst i dag og sjekket den på GitHub. Dette er langs linjene beskrevet av Nick Johnson ovenfor (som pleide å jobbe for Google).

Følg denne linken Gae-standardtekst

Svarte 21/09/2012 kl. 17:07
kilden bruker

stemmer
7

Jeg tror det første alternativet er ansett som den beste praksis. Og gjøre koden mappen din første pakke. Rietveld prosjekt utviklet av Guido van Rossum er en meget god modell for å lære av. Ta en titt på det: http://code.google.com/p/rietveld

Med hensyn til Django 1.0, foreslår jeg at du begynner å bruke Django stammen kode i stedet for den GAE bygget i Django port. Igjen, ta en titt på hvordan det gjøres i Rietveld.

Svarte 15/09/2008 kl. 22:11
kilden bruker

stemmer
3

Jeg liker webpy så jeg har adoptert den som templating ramme på Google App Engine.
Min pakke mappene er vanligvis organisert slik:

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

Her er et eksempel.

Svarte 23/06/2010 kl. 20:30
kilden bruker

stemmer
1

Jeg er ikke helt oppdatert på de nyeste beste praksis, et cetera når det gjelder kode layout, men da jeg gjorde min første GAE søknaden, jeg brukte noe langs andre alternativet, hvor koden og maler er ved siden av hverandre.

Det var to grunner til dette - en, det holdt koden og mal i nærheten, og for det andre, jeg hadde katalogstrukturen layout etterligne det på nettsiden - gjør det (for meg) litt lettere for å huske hvor alt var.

Svarte 07/09/2008 kl. 14:25
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more