Planet Zope

Repoze Presentation at ZPUG-DC Tuesday September 2, 2008

Sun, 07 Sep 2008 09:57:41 -0700

Python web framework at a meeting of the Washington DC Zope and Python User's Group on Tuesday, September 2 2008 in the Radio Free Asia boardroom

Installing Deliverance

Sun, 07 Sep 2008 09:57:41 -0700

Deliverance is a cool tool, that makes it possible to give web based software a new skin.works

New Blogging Pastures

Sun, 07 Sep 2008 09:57:41 -0700

So head over to . Gods and time willing, I'll get around to knocking out my tech thoughts again on topics such as:

XML configuration vs wiring

Sun, 07 Sep 2008 09:57:41 -0700

Lessons from Java and Zope

More on repoze.urispace

Sun, 07 Sep 2008 09:57:41 -0700

I blogged yesterday about the fact that I had docs online for the repoze.urispace package, but didn't do much to motivate readers' interest: repoze.urispace should be interesting if you have an application which needs policies which vary based on "where" in the site the request is addressed. Examples might include: fine- grained security, theme selection, caching policies, etc.

Helping the ZCML-Allergic

Sun, 07 Sep 2008 09:57:41 -0700

OK. I'll pander to the ZCML-allergic crowd by making it possible to configure repoze.bfg applications without writing any ZCML.

My September schedule is empty!

Sun, 07 Sep 2008 09:57:41 -0700

collective.flowplayer

Sun, 07 Sep 2008 09:57:41 -0700

Hot off the presses - a video/audio player for Plone

One Month To Plone Conference 2008

Sun, 07 Sep 2008 09:57:41 -0700

Make your plans now!

repoze.bfg.viewgroup ("content provider"-like Thingies for repoze.bfg)

Mon, 01 Sep 2008 00:52:26 -0700

Although I'm not much of a fan of the concept of Zope 3 content providers (aka "viewlets" and "viewlet managers"), I've implemented something a lot like them for repoze.bfg named "repoze.bfg.viewgroup".

Docs online for new repoze.urispace package

Sat, 30 Aug 2008 20:52:03 -0700

I have uploaded Sphinxified documentation for repoze.urispace, a library package which implements most of the W3C URISpace spec for use in WSGI middleware. I'm planning to use it to select themes and rulesets for Deliverance based on the URI; other uses might include setting caching headers, or doing some flavor of "declarative security" in middleware.

Grok-by-Example: Wiki

Sat, 30 Aug 2008 04:51:55 -0700

install_requires=['setuptools', 'grok', ... 'megrok.tinymce', ],

GAE uses the webapp.WSGIApplication and already configures the URL dispatching as a wildcard pattern:

class WikiPage(grok.Application, grok.Container): ... def traverse(self, page_name=default_page_name): ...

While GAE webapp.RequestHandler classes understand HTTP methods and dispatch accordingly, Grok uses grok.View classes that ‘render’ the representation of the current context object.

Here both frameworks use templating to render the context object and return the result.

class BaseRequestHandler(webapp.RequestHandler): def generate(self, template_name, template_values={}): ... self.response.out.write(template.render(path, values, debug=_DEBUG))

In this example GAE uses the low-level ‘datastore’ API to store and retrieve Page objects to and from the appengine datastore: def load(name): query = datastore.Query('Page') ...

def save(self): datastore.Put(entity)

def dc(self): return IZopeDublinCore(self.context)

GAE uses the appengine ‘users’ API to handle the posting of new or editing existing wiki pages. The user must be logged in with her google account: def post(self, page_name): if not users.get_current_user(): self.redirect(users.create_login_url(self.request.uri)) ...

class WikiPage(grok.Application, grok.Container): grok.local_utility(PluggableAuthentication, IAuthentication, setup=setup_pau_principal)

class PermissionEditPage(grok.Permission): grok.name('wiki.EditPage')

class PermissionAddPage(grok.Permission): grok.name('wiki.AddPage')

permission_mngr = IPrincipalPermissionManager(grok.getSite()) permission_mngr.grantPermissionToPrincipal( 'wiki.AddPage', principals.prefix + login) permission_mngr.grantPermissionToPrincipal( 'wiki.EditPage', principals.prefix + login)

class Login(Master): def update(self, login_submit=None): ...

Before returning the rendered Page (@@index view) to the user, the page content gets wikified. In our example a list of transformations is applied to the ‘content’ by adapting the view object itself: class Index(Master):

def wikified_content(self): self.content = self.context.content ...

transforms = [ 'wiki.AutoLink', 'wiki.ListOfPages', 'wiki.WikiWords', ]

for transform in transforms: self.content = getAdapter(self, ITransform, transform).run() return self.content

class ITransform(Interface): pass

class WikiWords(grok.Adapter): grok.implements(ITransform) grok.name('wiki.WikiWords') grok.context(grok.View) ...

Several actions return a feedback message to the user which is displayed above the content on the next response page.

Porting this application took quite some time (about 1 day), mostly because of implementing the user management (again) and getting megrok.tinymce working. The wiki app is usable as is and also works fine when used inside an existing grok application. Transformation/Wikification of page contents through adapters could easily be made into a plugin-like configuration (using a distinct admin form). Also the renderer (TinyMCE and HTML) could be pluggable replaced by a RestructuredText based engine.

repoze.bfg incompatibility in 0.3.4

Fri, 29 Aug 2008 02:52:29 -0700

I've just released repoze.bfg 0.3.4, which contains a backwards incompatible change (the first since 0.1).

- Make ``repoze.bfg`` a namespace package so we can allow folks to create subpackages (e.g. ``repoze.bfg.otherthing``) within separate eggs. This is a backwards incompatible change which makes it impossible to import "make_app" and "get_options" from the ``repoze.bfg`` module directly. This change will break all existing apps generated by the paster code generator. Instead, you need to import these functions as ``repoze.bfg.router:make_app`` and ``repoze.bfg.registry:get_options``, respectively. Sorry folks, it has to be done now or never, and definitely better now.

Apply for Plone Foundation Membership Now

Thu, 28 Aug 2008 17:57:23 -0700

File your application for Plone Foundation membership now if you'd like it considered in time for the Plone Conference.

Carlos' repoze.shootout In Action

Thu, 28 Aug 2008 17:57:23 -0700

Carlos de la Guardia came up with an example "idea competition" application named a week or two ago. You can now see it "in action" at . It's purty these days.

sample application which currently demonstrates , integration with , integration with the theming engine and integration with the WSGI authentication system.

svn co http://svn.repoze.org/repoze.shootout/trunk repoze.shootout

Grok-by-Example

Thu, 28 Aug 2008 17:57:22 -0700

Motivation is that you can look at the original source and the grok code side-by-side and deduce from both. Source is available from

Repoze.bfg App Development Screencast

Thu, 28 Aug 2008 17:57:22 -0700

A screencast demonstrating the development of an application under repoze.bfg.

Cleaning up after the party

Thu, 28 Aug 2008 17:57:22 -0700

Views are a mess in Zope! There's quite a lot of magic and too much functionality outside of Python. This is implemented by a number of ZCML directives that support various useful and not so useful use-cases. Since these days it's all about putting together frameworks that get all the good bits and pieces from the Zope libraries and leave the rest, it's up to a framework to do away with this mess. But we can't just replace it with nothing.In the beginning of this piece I mentioned that templates would pull in additional API as needed. These would be adapters on context and request (like views), but should not provide any rendering capabilities as such. They are simply a view on some data source. We might use the terms "data view" and "browser view" to make this distinction.

Grok-by-Example: Guestbook

Thu, 28 Aug 2008 17:57:21 -0700

Both frameworks use the ‘Application’ concept. Grok subclasses from both grok.Application and grok.Container: class Application(grok.Application, grok.Container): pass

application = webapp.WSGIApplication([ ('/', MainPage), ('/sign', Guestbook) ], debug=True)

The application accepts 2 possible requests: the default view and the action to post the form contents to.

class MainPage(grok.View): grok.context(Application) grok.name('index') ...

class MainPage(webapp.RequestHandler): def get(self): ...

Grok has a ‘grok.REST’ class that supports HTTP method dispatching, but it is not used in the example: class Guestbook(grok.View): ... def render(self): if self.request.method.upper() != 'POST': return self.redirect(self.application_url()) ...

class Guestbook(webapp.RequestHandler): def post(self): ...

Grok output is collected and returned from the view ‘render’ method: def render(self): out=['<html><body>'] ... return ''.join(out)

Grok content objects are subclassed from grok.Model. Properties are defined in an Interface class which the object implements: class IGreeting(Interface): author = schema.Field(title=u'Author') ...

class Greeting(grok.Model): grok.implements(IGreeting)

class Greeting(db.Model): author = db.UserProperty()

Grok content objects are instantiated, modified and finally inserted into a container (which here is the application object itself). A local-unique name must be provided on insertion. Existing objects must be deleted and reinserted. Properties are not validated by default: id=str(uuid.uuid4()) self.context[id]=greeting

Grok uses python to locate objects and create a result listing: greetings=[(x.date, x) for x in self.context.values()] greetings=list(reversed(sorted(greetings))) for date,greeting in greetings[:10]: ...

greetings = db.GqlQuery("SELECT * " "FROM Greeting " "ORDER BY date DESC LIMIT 10") for greeting in greetings: ...

Grok has no fixed ‘user’ API, user management depends on loaded authentication plugins: greeting.author = self.request.principal ... if IUnauthenticatedPrincipal.providedBy(greeting.author): ...

if users.get_current_user(): greeting.author = users.get_current_user() ... if greeting.author: ...

Grok is a long-running process. Requests are processed, the object graph is traversed to a final context object and the result of calling the view on the context object is returned.

def main(): wsgiref.handlers.CGIHandler().run(application)

The number of lines of code is about the same. For this small example GAE is simpler with respect to the number of APIs and concepts used and richer with respect to debugging and datasecurity.

World Plone Day reaches five continents

Thu, 28 Aug 2008 17:57:21 -0700

More than 30 members of the Plone Community in 22 countries on five continents are promoting Plone around the world on November 7th 2008. Learn how you can help!

Silva 2.1 Released

Thu, 28 Aug 2008 17:57:21 -0700

Infrae is pleased to announce the alpha release of Silva 2.1. This release adds a range of features for both Author/Editors and Site Managers, as well as performance and technical improvements such as functional tests.