The new file/directory structure of Pyramid (Pylons) is causing me some confusion

Question

I've been developing in Pylons for a little while now and have recently learned they're merging with another framework to create Pyramid.

I've been looking over example code to see the differences and it's causing a bit of confusion...

For example, Controllers have been replaced by Views. Not a big problem... But what I find interesting is there's no directories for these. It's simply one file: views.py.

How does this new MVC structure work? Do I write all my actions into this one file? That could get rather annoying when I have similarly named actions (multiple indexes, for example) :/

Could you point me in the direction of some good tutorials/documentation on how to use this framework?

Answer 1

Since the various view-related configuration methods (config.add_view, config.add_handler) require you to pass a dotted name as the class or function to be used as a view or handler, you can arrange your code however you like.

For example, if your project package name were myproject and wanted to arrange all your views in a Python subpackage within the myproject package named "views" (see http://docs.python.org/tutorial/modules.html#packages) instead of a single views file, you might:

• Create a views directory inside your mypackage package.

• Move the existing views.py file to a file inside the new views directory named, say, blog.py.

• Create a file within the new views directory named __init__.py (it can be empty, this just tells Python that the views directory is a package.

Then change the __init__.py of your myproject project (not the __init__.py you just created in the views directory, the one in its parent directory) from something like:

config.add_handler('myhandler', '/my/handler', handler='mypackage.views.MyHandler')

To:

config.add_handler('myhandler', '/my/handler', handler='mypackage.views.blog.MyHandler')

You can then continue to add files to the views directory, and refer to views or handler classes/functions within those files via the dotted name passed as handler= or view=.

Answer 2

Here is one answer that should be pretty straight forward. This question was asked when Pyramid 1.3 wasn't yet out. So forget about python handlers since the new decorator do a pretty good job now.

But just to start: Pyramid doesn't have any common structure. You could possibly write a whole app in one single file if you wanted. In other words, if you liked how pylons was structured, you can go with it. If you prefer to setup your own structure then go for it.

If your site doesn't need more than one file then...GO FOR IT!!! All you really need is that it works.

I personally have a structure like that

- root
    - __init__.py # all setup goes there
    - security.py # where functions related to ACL and group_finder
    - models.py or models/ # where all my models go
    - views.py or views/   # where all my views go 
    - templates
       - modelname
          - all template related to this resource type

    - scripts # where I put my scripts like backup etc
    - lib # all utilities goes there
    - subscribers # where all events are defined

My view package might sometimes be splitted up in many files where I'd group views by ResourceType.

If you happen to use context to match views instead of routes. You can do some pretty nice things with view_defaults and view_config.

view_defaults sets some default for the class, and view_config sets some more configurations for the defs using defaults provided by view_defaults if present.