Projek struktuur vir Google App Engine

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

  •  09-06-2019
  •  | 
  •  

Vra

Ek het 'n aansoek in Google App Engine reg wanneer dit kom uit, om te speel met die tegnologie en werk op 'n troeteldier projek wat ek dink het oor 'n lang tyd, maar nooit gekry om te begin. Die resultaat is BowlSK . Maar as dit gegroei het, en funksies is bygevoeg, dit het regtig moeilik gekry om dinge georganiseer te hou - veral as gevolg van die feit dat dit is my eerste luislang projek, en ek het nie geweet iets daaraan totdat ek begin werk.

Wat ek:

  • Main Level bevat:
    • al .py lêers (het nie geweet hoe om te maak pakkette werk)
    • al Html templates vir hoof vlak bladsye
  • subdirectory:
    • aparte dopgehou vir css, beelde, JS, ens.
    • dopgehou wat Html templates vir subdirecty-tipe URL's hou

Voorbeeld:
http://www.bowlsk.com/ kaarte na die tuisblad (standaard pakket), sjabloon by "index.html "
http://www.bowlsk.com/games/view-series.html ? n reeks = 7130 kaarte te ViewSeriesPage (weer, verstek pakket), sjabloon by "speletjies / view-series.html"

Dit is nare. Hoe kan ek herstruktureer? Ek het 2 idees:

  • Main gids met:? Appdef, indekse, main.py

    • subgids vir kode. Het dit aan my eerste pakket wees?
    • subgids vir templates. Gids voeg, sou ooreenstem pakket voeg,
    • Individuele subgidse vir css, beelde, JS, ens.

  • Main gids met appdef, indekse, main.py?

    • subgids vir kode + templates. Op hierdie manier het ek die hanteerder klas reg langs die sjabloon, want in hierdie stadium, ek toevoeging van baie van die funksies, so veranderinge aan een gemiddelde veranderinge aan die ander. Weer, moet ek hierdie gidsnaam wees die eerste pakket naam vir my klasse? Ek wil graag die gids na "src" wees, maar ek wil nie my klasse te wees "src.WhateverPage"

Is daar 'n beste praktyk? Met Django 1.0 op die horison, is daar iets wat ek kan doen nou na my vermoë om te integreer met dit wanneer dit die amptelike GAE template engine verbeter? Ek sou net begin probeer hierdie dinge, en sien wat beter lyk, maar pyDev se refactoring ondersteuning lyk nie hanteer pakket beweeg baie goed, so dit waarskynlik 'n nie-triviale taak om al hierdie dinge weer werk te kry sal wees.

Was dit nuttig?

Oplossing

In die eerste plek sou ek stel voor dat jy 'n blik op " snelle ontwikkeling met Python, Django, en Google App Engine "

gvr beskryf 'n algemene / standaard projek uitleg op bladsy 10 van sy skyfie aanbieding .

Hier sal ek 'n effens aangepaste weergawe van die uitleg / struktuur van die bladsy te plaas. Ek pretty much volg hierdie patroon myself. Jy het ook genoem jy probleme met pakkette het. Net seker maak elkeen van julle sub dopgehou het 'n __init__.py lêer. Dis ok as sy leë.

Boiler lêers

  • Dit wissel skaars tussen projekte
  • app.yaml: Rig alle nie-statiese versoeke om main.py
  • main.py: inisialiseer inligting en stuur dit alle versoeke

Project uitleg

  • statiese / *: statiese lêers; direk bedien deur App Engine
    • .
  • myapp / * py: programspesifieke python kode
    • views.py, models.py, tests.py, __init__.py, en nog baie meer
    • .
  • templates / * html: templates (. Of myapp / templates / * html)

Hier is 'n paar kode voorbeelde wat as goed kan help:

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

Ek dink hierdie uitleg werk baie goed vir 'n nuwe en relatief klein tot medium projekte. Vir groter projekte sou ek raai opbreek die sienings en modelle om hul eie sub-gidse het met iets soos:

Project uitleg

  • statiese /: statiese lêers; bedien direk deur App Engine
    • JS / *. JS
    • beelde / * gif |. Png | jpg
    • css / *. Css
  • myapp /: app struktuur
    • modelle / *. Py
    • uitsig / *. Py
    • toetse / *. Py
    • templates / * html:. Templates

Ander wenke

My gewone uitleg lyk iets soos hierdie:

  • app.yaml
  • index.yaml
  • request.py - bevat die basiese WSGI inligting
  • lib
    • __init__.py - algemene funksies, insluitende 'n versoek hanteerder basis klas
  • beheerders - bevat al die hanteerders. request.yaml voer hierdie.
  • templates
    • al die Django templates, wat gebruik word deur die leiers
  • model
    • al die datastore model klasse
  • statiese
    • statiese lêers (css, beelde, ens). Gekarteer na / statiese deur app.yaml

Ek kan voorbeelde van gee wat my app.yaml, request.py, lib / init .py, en monster beheerders lyk, as dit nie duidelik nie.

Ek geïmplementeer 'n Google app enjin boiler vandag en gekontroleer dit op GitHub. Dit is langs die beskryf deur Nick Johnson bo (wat gebruik word om te werk vir Google) lyne.

Volg hierdie skakel Gae-boiler

Ek dink die eerste opsie word beskou as die beste praktyk. En maak die kode gids jou eerste pakket. Die Rietveld projek wat ontwikkel is deur Guido van Rossum is 'n baie goeie model om te leer uit. Het jy 'n blik op dit: http://code.google.com/p/rietveld

Met betrekking tot Django 1.0, ek stel voor jy begin met behulp van die Django stam kode in plaas van die GAE gebou in Django hawe. Weereens, 'n blik op hoe dit gedoen word in Rietveld.

Ek hou webpy so ek het dit aangeneem as template raamwerk op Google App Engine.
My pakket dopgehou word gewoonlik georganiseer soos volg: 

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

Hier is 'n voorbeeld.

Ek is nie heeltemal op hoogte van die nuutste beste praktyke, ensovoorts wanneer dit kom by die kode uitleg, maar toe ek my eerste GAE aansoek gedoen het, het ek iets saam jou tweede opsie, waar die kode en templates is langs mekaar.

Daar was twee redes hiervoor - een, dit het die kode en sjabloon in die buurt, en tweedens, ek het die directory struktuur uitleg naboots dié van die webwerf - maak dit (vir my) 'n bietjie makliker te onthou waar alles was.

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top