Pyramid project structure

Question

Estoy desarrollando un proyecto bastante grande en la pirámide. Utilicé django antes. Me gusta mucho la forma en que estructura el proyecto y encapsula la funcionalidad en aplicaciones. Me gustaría lograr la misma estructura con la pirámide. Sé que la pirámide es muy flexible para conseguir esto, pero necesito ayuda para lograr la misma estructura con un acoplamiento flexible. La estructura del proyecto debe ser similar a:

Project/ 
     app1/ 
      models.py 
      routes.py 
      views.py 
     app2/ 
      models.py 
      routes.py 
      views.py 

¿Alguna sugerencia?

Answer 1

Dado que Pyramid no hace suposiciones sobre la estructura de su paquete en primer lugar, cualquier forma de dividir su aplicación termina siendo bastante similar en la configuración. Sin embargo, si divide su aplicación en algunos paquetes distintos, puede (opcionalmente) aprovechar la directiva config.include() para incluir cada paquete en su configuración principal.

Por ejemplo:

# myapp/__init__.py (main config) 
def main(global_config, **settings): 
    config = Configurator(...) 
    # basic setup of your app 
    config.include('pyramid_tm') 
    config.include('pyramid_jinja2') 

    # add config for each of your subapps 
    config.include('project.app1') 
    config.include('project.app2') 

    # make wsgi app 
    return config.make_wsgi_app() 

# myapp/app1/__init__.py (app1's config) 
def includeme(config): 
    config.add_route(...) 
    config.scan() 

# myapp/app2/__init__.py (app2's config) 
def includeme(config): 
    config.add_route(...) 
    config.scan() 

En cada una de sus subapps, a continuación, puede definir puntos de vista/modelos/etc.

En general, es posible que desee crear su sesión SQLAlchemy (u otra base de datos) en la configuración común, ya que es probable que sus diferentes aplicaciones utilicen el mismo motor.

Answer 2

He implementado una función global de appIncluder que se importa como includeme con el init .py del paquete que se incluirá.

includeme (ApplicationIncluder) recibe el objeto de configuración, por lo que es entonces fácil de usar config.package y sus variables/métodos/clases (presente en el mismo init .py y submódulos.

Gracias mucho para esta idea

El código:

proyecto: 'foo' aplicaciones que se desplegarán en el directorio foo.foo.apps

Estructura:

foo 
|-foo 
    |- __init__.py 
    |- appincluder.py 
    |-apps 
    |-test 
     |- __init__.py 
     |- views.py 
     |- templates 
     |- test.jinja2 

foo/foo/init .py:

config.include('foo.apps.test') 

foo/foo/appincluder.py

def appIncluder(config): 
    app = config.package 
    prefix = app.prefix 
    routes = app.routes 

    for route,url in routes.items(): 
     config.add_route(route,prefix + url) 

    config.scan(app) 

    log.info('app: %s included' % app.__name__) 

foo/foo/aplicaciones/test/init. py

from foo.appincluder import appIncluder as includeme 

prefix = '/test' 

routes = { 
    'test': '/home' 
} 

foo/foo/aplicaciones/test/views.py

from pyramid.view import view_config 


@view_config(route_name='test', renderer='templates/test.jinja2') 
def test(request): 
    return {} 

espero que ayude a alguien.