ZPT Performance Twiddling

""" Speed test of page template rendering over various features

Usage:  python perftest_zpt.py [-r] [-c #] [-g #] <which> <features*>

Options:
--------

 '-r' -- Print the generated, rendered template and exit.

 '-c' -- Specify the number of children (default 26).

 '-g' -- Specify the number of grandchildren (default 0).

Arguments
---------

<which> -- one of 'null' (default), 'PT', or 'ZPT'.

<features*> -- one or more of the following (order may be significant):

 'tal_define' -- set up the 'info' name (a prereq. for all the others).

 'tal_content' -- include a tag which uses 'tal:content'

 'tal_replace_structure' -- include a tag which uses 'tal:replace' with
    the 'structure' modifier (suppresses HTML quoting)

 'tal_repeat_prolog' -- set up a repeat over the children

 'child_link' -- include an <a href=...> for the child (requires
   'tal_repeat_prolog' before).

 'grandchildren' -- build a nested list of children / grandchildren

"""
import getopt
import string
import sys
import timeit


_FEATURES = {
'tal_define': '<div tal:define="info options/info">',
'tal_content': '<h1 tal:content="info/title">TITLE</h1>',
'tal_replace_structure': '<p>Description: '
                         '<span tal:replace="structure info/description" />'
                         '</p>',
'tal_repeat_prolog': '<ul>\n'
                     '<li tal:repeat="child info/children">\n'
                     '<a href="#"\n',
'child_link':        'tal:attributes="href child/id"\n'
                     'tal:content="child/title"\n',
'tal_repeat_epilog': '>CHILD</a>\n'
                     '</li>\n'
                     '</ul>\n',
'grandchildren':     '<ul>\n'
                     '<li tal:repeat="child info/children">\n'
                     '<span tal:content="child/id">CHILD ID</span>\n'
                     '<ul>\n'
                     '<li tal:repeat="grand child/children">\n'
                     '<span tal:replace="structure grand/title">TITLE</span>\n'
                     '</li>\n'
                     '</ul>\n'
                     '</li>\n'
                     '</ul>\n',
'epilog':            '</div>',
}

def _cleanupFeatures(features):
    features = list(features)
    if 'tal_repeat_prolog' in features and 'tal_repeat_epilog' not in features:
        features.append('tal_repeat_epilog')
    if 'tal_define' in features and 'epilog' not in features:
        features.append('epilog')
    return tuple(features)

def _generateTempateText(features):
    return '\n'.join([_FEATURES[x] for x in features])

def _prepareNull(ignored):
    return lambda **kw: 'XYZZY'

def _preparePageTemplate(features):
    from Products.PageTemplates.PageTemplate import PageTemplate
    template = PageTemplate()
    template.write(_generateTempateText(features))
    return template

def _prepareZopePageTemplate(features):
    import Zope2
    from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
    app = Zope2.app()
    return ZopePageTemplate(id='test',
                            text=_generateTempateText(features)).__of__(app)

def _prepareZPT_with_StreamIterator(features):
    import Zope2
    from ZPublisher.Iterators import IStreamIterator
    from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
    app = Zope2.app()

    class StreamIterator:

        __implements__ = (IStreamIterator,)

        def __init__(self):
            self._buffers = []
            self._length = 0

        def write(self, data):
            assert isinstance(data, basestring)
            self._buffers.append(data)
            self._length += len(data)

        def __iter__(self):
            return self

        def next(self):
            if len(self._buffers) == 0:
                raise StopIteration

            result, self._buffers = self._buffers[0], self._buffers[1:]

            return result

        def getvalue(self):
            return self

        def __len__(self):
            return self._length

        def __nonzero__(self):
            return True

        def asString(self):
            return ''.join(self._buffers)
    
    class ZPT_with_StreamIterator(ZopePageTemplate):

        def StringIO(self):
            return StreamIterator()

    return ZPT_with_StreamIterator(id='test',
                                   text=_generateTempateText(features),
                                  ).__of__(app)
    

def _prepareTemplateAndInfo(which, features, num_children, num_grandchildren):

    WHICH = {'ZPT' : _prepareZopePageTemplate,
             'ZPTSI' : _prepareZPT_with_StreamIterator,
             'PT' : _preparePageTemplate,
             'null' : _prepareNull,
            }

    template = WHICH[which](features)

    info = {'title': 'Page Title',
            'description': 'A longer description',
           }

    info['children'] = children = []

    for child_id in string.uppercase[:num_children]:
        child_info = {'id': child_id,
                      'title': 'Child: %s' % child_id,
                      'description': 'Describing child: %s' % child_id,
                     }
        child_info['children'] = grandchildren = []

        for grandchild_id in string.lowercase[:num_grandchildren]:
            grandchild_info = {'id': grandchild_id,
                               'title': 'Grandchild: %s' % grandchild_id,
                               'description': 'Describing grandchild: %s'
                                    % grandchild_id,
                              }
            grandchildren.append(grandchild_info)

        children.append(child_info)

    return template, info

def main():

    which = 'null'
    num_children = len(string.uppercase)
    num_grandchildren = 0
    render = False

    features = ()

    try:
        opts, args = getopt.getopt(sys.argv[1:], 'c:g:r?h')
    except getopt.GetoptError, e:
        print __doc__
        print e
        sys.exit(1)
        

    for k, v in opts:
        if k == '-c':
            num_children = int(v)
        elif k == '-g':
            num_grandchildren = int(v)
        elif k == '-r':
            render = True
        elif k in ('-h', '-?'):
            print __doc__
            sys.exit(2)

    if args:
        which = args[0]
        features = args[1:]

    features = _cleanupFeatures(features)

    print ('Which      : %s\n'
           'Features   : %s\n'
           '# children : %s\n'
           '# grands   : %s' % (
              which, ', '.join(features), num_children, num_grandchildren))

    if render:
        template, info = _prepareTemplateAndInfo(which,
                                                 features,
                                                 num_children,
                                                 num_grandchildren)
        result = template(info=info)
        print getattr(result, 'asString', lambda: result)()
        return

    NUMBER = 10000
    setup = ('from perftest_zpt import _prepareTemplateAndInfo; '
             'template, info = _prepareTemplateAndInfo("%s", %s, %s, %s)'
                % (which, features, num_children, num_grandchildren)
            )
    run = 'template(info=info)'
    t = timeit.Timer(stmt=run, setup=setup)

    try:
        times = t.repeat(number=NUMBER)
        best = min(times)
        print 'Time       : %5.3g ms/rendering' % (best * 1000 / NUMBER)
    except:
        t.print_exc()

if __name__ == '__main__':
    main()