This is an examination of Pyramid's extensibility features, with an emphasis on how it's a very good option for creating higher level frameworks.

1. Pyramid as a base for higher level frameworks Carlos de la Guardia
This is an examination of Pyramid's extensibility features, with an emphasis on how it's a
very good option for creating higher level frameworks.
Pyramid extensibility
Why Pyramid is the best framework for building web
frameworks
Carlos de la Guardia
The one file app
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
def hello_world(request):
return Response('Hello %(name)s!' % request.matchdict)
if __name__ == '__main__':
config = Configurator()
config.add_route('hello', '/hello/{name}')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()
Predictable configuration
● Application Programmers Don't Control The Module­Scope Codepath (Import­
Time Side­Effects Are Evil).
● "Stacked Object Proxies" Are Too Clever / Thread Locals Are A Nuisance.
● Routes Need Relative Ordering.
● Explicitly WSGI.
One file app revisited
from pyramid.response import Response # explicit response, no thread
local
from wsgiref.simple_server import make_server # explicitly WSGI
def hello_world(request): # accepts a request; no request thread
# explicit response object means no response threadlocal
return Response('Hello world!')
if __name__ == '__main__':

2. from pyramid.config import Configurator
config = Configurator() # no global application object.
config.add_view(hello_world) # explicit non­decorator
registration
app = config.make_wsgi_app() # explicitly WSGI
server = make_server('0.0.0.0', 8080, app)
server.serve_forever() # explicitly WSGI
Declarative configuration
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.view import view_config
@view_config()
def hello(request):
return Response('Hello')
if __name__ == '__main__':
from pyramid.config import Configurator
config = Configurator()
config.scan()
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()
Conflict detection
config = Configurator()
config.add_view(hello_world, name='hello')
# conflicting view configuration
config.add_view(goodbye_world, name='hello')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 8080, app)
server.serve_forever()
Resolving conflicts
● If at all possible, eliminate manually.
● Always use config.include instead of config.add_x (automatic resolution).
● Use config.commit to execute all pending configuration actions.
● Use an autocommiting configurator (autocommit=True).
Including external configurations
For this to work properly, the myapp module must contain a callable with the special
name includeme, which should perform configuration.

3. import myapp
config.include(myapp)
Adding methods to the configurator
If we have a package named pyramid_subhelpers with this code:
def includeme(config):
config.add_directive('add_newrequest_subscriber',
add_newrequest_subscriber)
Users whom installed that package could use it like this:
def mysubscriber(event):
print event.request
from pyramid.config import Configurator
config = Configurator()
config.include('pyramid_subscriberhelpers')
config.add_newrequest_subscriber(mysubscriber)
Levels of extensibility
1. The behavior of an application can be overridden or extended in a particular
deployment of the application without requiring that the deployer modify the
source of the original application.
2. The original developer is not required to anticipate any extensibility plugpoints at
application creation time to allow fundamental application behavior to be
overriden or extended.
3. The original developer may optionally choose to anticipate an application­specific
set of plugpoints, which may be hooked by a deployer.
Override packages
In practical terms, for reaching level 2 a developer should be able to override a route,
view or resource to do what he wants to do in ways not necessarily anticipated by the
original developer.
● If a deployment needs a different styling, the deployer may override the main
template and the CSS in a separate Python package which defines overrides.
● If a deployment needs an application page to do something differently, or to
expose more or different information, the deployer may override the view that
renders the page within a separate Python package.
● If a deployment needs an additional feature, the deployer may add a view to the
override package.

4. Pyramid extensibility
You only need to follow one rule to make your Pyramid application extensible. Instead of
this:
from pyramid.config import Configurator
if __name__ == '__main__':
config = Configurator()
config.add_view('myapp.views.view1', name='view1')
config.add_view('myapp.views.view2', name='view2')
Do this:
from pyramid.config import Configurator
if __name__ == '__main__':
config = Configurator()
config.include(add_views)
def add_views(config):
config.add_view('myapp.views.view1', name='view1')
config.add_view('myapp.views.view2', name='view2')
Overriding routes
Since route order is usually important, your best bet is to copy all route registrations to
the new package and change them there. Then, make sure the original routes are noy
included.
Overriding a view
Original app:
def configure_views(config):
config.add_view('theoriginalapp.views.theview', name='theview')
Override app:
from pyramid.config import Configurator
from originalapp import configure_views
if __name == '__main__':
config = Configurator()
config.include(configure_views)
config.add_view('theoverrideapp.views.theview', name='theview')
Overriding assets
Single asset:
config.override_asset(
to_override='some.package:templates/mytemplate.pt',

5.
override_with='another.package:othertemplates/anothertemplate.pt')
Full package:
config.override_asset(to_override='some.package',
override_with='another.package')
Subdirectory:
config.override_asset(to_override='some.package:templates/',
override_with='another.package:othertemplates/')
Existing application
If the application in question doesn't follow the extensibility rule. You can extend it like
this:
if __name__ == '__main__':
config.scan('someotherpackage')
config.add_view('mypackage.views.myview', name='myview')
Or, you can override configuration like this:
if __name__ == '__main__':
config.scan('someotherpackage')
config.commit()
config.add_view('mypackage.views.myview', name='myview')
Extensibility level 3: ZCA
Yes, the Zope Component Architecture can be used to define application­specific plug­
points.
● Time­proven.
● Featureful (superdictionary, complex lookups).
● One single registry.
● Composable (populate registry from anywhere).
● Pluggable (arbitrarily extendable).
● Testable.
● Fast.
Hooks
● Changing the Not Found view.
● Changing the Forbidden view.
● Changing the Request Factory.
● The Before Render event.
● Response callbacks.
● Finished callbacks (request).
● Adding view, route or subscriber predictes.

6. ● Registering configuration decorators.
● More (see documentation).
Other framework­friendly Pyramid features
● Extensible templating. Any templating language can be used as a first class
templating system. You can even use multiple systems in the same project.
● View predicates. You can use them to create new, more specific views from
override packages.
● Programatic introspection. If users may plug code into your system, it's useful to
be able to get an enumeration of what code was plugged at application runtime.
Groundhog
A "microframework", based on Flask semantics. Built to showcase Pyramid's
configuration and extension possibilities.
● http://github.com/Pylons/groundhog
Kotti
"A user­friendly, light­weight and extensible web content management system, based on
Pyramid and SQLAlchemy".
● http://kotti.readthedocs.org/en/latest/
Substance D
An application server in the spirit of the Zope application server. It can be used as a base
to build general purpose web applications.
● http://github.com/Pylons/groundhog
Thank You!
● Pyramid documentation:
http://docs.pylonsproject.org/projects/pyramid/en/lates
t/
● Contact me:
cguardia on twitter
cguardia@yahoo.com
#pyramid IRC channel