Yet another reinvention of a Python HTML generation mechanism (Python recipe) by Josiah Carlson

ActiveState Code (http://code.activestate.com/recipes/440563/)

Attributes that are Python keywords. I'd like to use the HTML generated from this recipe with CSS classes. The problem is that you can't do T.tag(class="whatevercssclass") because "class" is a Python keyword and using it this way generates an error. Is there a clean way to get around this?

to add attribute 'class' add this chunk of code after line 46 of the code:

__klass = kwargs.pop('klass', None)
if __klass:
    kwargs['class'] = __klass

then just do this:

T.option(klass="aclass")( ..some content..)...

spelt with a 'k' so Python does not catch it as a reserved word, and it will output with the correct class="aclass" attribute

I've added this modification to the code. Thank you.

This is a useful bit of code. I really like this recipe, and I even used it in a internal project of mine that never really went anywhere.

Before I mothball my project I wanted to share back with you my rendition of your code.

I made some small changes to the general code to add some extra name-spacing. I also dropped the need for using tell() to determine if the renderer should wrap, instead relying on counting the number of children in an element and whether those children are themselves tags.

With the dropped dependency on tell(), render() can now be used with sys.stdout passed in as the file object.

I also made some other slight changes to the HTML that is generated to make it more XHTML like (although I do no such verification of this).

Anyway, here is the code. I figure it better to post it in a comment, rather than a recipe (even though comment code formatting sucks), since this is really not a new recipe.

import htmlentitydefs
import re
import cStringIO as StringIO
import urllib

class HTMLEscape(object):
    __lookuptable = None
    __escapefunc = None
    def __init__(self):
        if HTMLEscape.__lookuptable is None:
            HTMLEscape.__lookuptable = {}
            for codepoint,name in htmlentitydefs.codepoint2name.iteritems():
                if codepoint <= 127:
                    HTMLEscape.__lookuptable[chr(codepoint)] = '&%s; ' % name
                else:
                    HTMLEscape.__lookuptable[unichr(codepoint)] = '&#%d; ' % codepoint

        if HTMLEscape.__escapefunc is None:
            HTMLEscape.__escapefunc = re.compile('(%s)' % ('|'.join(list(HTMLEscape.__lookuptable))))

    def escape(self,_encodedhtml):
        _replace = lambda matchobj: HTMLEscape.__lookuptable.get(matchobj.group(0), '?')
        return HTMLEscape.__escapefunc.sub(_replace,_encodedhtml)

    def canescape(self,_char):
        return _char in HTMLEscape.__lookuptable

class Tag(object):
    """HTMLTag Factory"""
    def __getattr__(self,_type):
        return HTMLTag(_type)

class HTMLTag(object):
    """Constructs a new HTMLTag object, which can contain inner HTMLTag objects and text"""
    __unpairedtags = frozenset('br input img hr link meta iframe'.split())
    __noescaping = frozenset('script cdata'.split())
    __noformatting = frozenset('pre'.split())
    __htmlents = HTMLEscape()
    __wrapchildcount = 1

    __slots__ = ["_type","_attributes","_children"]
    def __init__(self,_type,_attributes=None,_children=None):
        self._type = _type.lower()
        self._attributes = _attributes
        self._children = _children

    def _shallow_copy_update(_dict,_update):
        d = dict(_dict)
        d.update(_update)
        return d

(comment continued...)

(...continued from previous comment)

    def __call__(self,*_children,**_attributes):
        """Calling on an instantiated HTMLTag object instantiates a new shallow copy of the tag or the tag updated
        In the copy the children are replaced by _children and the attributes are updated from _attributes"""
        if _attributes and self._attributes:
            _attributes = _shallow_copy_update(_attributes,self._attributes)
        # replace 'klass' with 'class', must be 'klass' in Python to prevent name conflict
        klass = _attributes.pop("klass",None)
        if klass: _attributes['class'] = klass
        # return a new HTMLTag
        if _children and _attributes:
            return HTMLTag(self._type,_attributes,_children)
        elif _attributes:
            return HTMLTag(self._type,_attributes,self._children)
        elif _children:
            return HTMLTag(self._type,self._attributes,_children)
        else:
            return self

    def __setitem__(self,_attribute,value):
        """Allow HTMLTag attributes to be updated like Python attributes"""
        # prevent assignment on hashable types other than strings
        if not isinstance(_attribute,basestring):
            raise TypeError("Invalid attribute name")
        if self._attributes is None: self._attributes = {}
        self._attributes[_attribute] = value

    def __getitem__(self,index):
        """Retrieve a child element from the HTMLTag"""
        if not isinstance(index,(int,long)):
            raise TypeError("Children must be indexed numerically")
        if not self._children:
            raise IndexError("list index out of range")
        return self._children[index]

    def render(self,fp=None,calldepth=0):
        """Pretty print the HTMLTag tree into a file object"""
        spaces = lambda: calldepth * ' '
        if fp is None:
            fp = StringIO.StringIO()
            self.render(fp)
            fp.seek(0)
            return fp.read()

        if calldepth == 0:
            fp.write('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">')

        if self._type != 'cdata':
            unpaired_terminator = ""
            if self._type in HTMLTag.__unpairedtags:
                unpaired_terminator = " /"
            if self._attributes:
                fp.write('\n' + spaces() + '<%s %s%s>' % (self._type,' '.join([x for x in ["%s='%s'" % (k,v) for k,v in self._attributes.iteritems()]]).encode('utf-8'),unpaired_terminator))
            else:
                fp.write('\n' + spaces() + '<%s%s>' % (self._type,unpaired_terminator))
        else:
            fp.write('\n' + spaces() + '<![CDATA[')

(comment continued...)

(...continued from previous comment)

        if self._children:
            for child in self._children:
                if hasattr(child,'render'):
                    child.render(fp,calldepth + 1)
                elif self._type in HTMLTag.__noescaping:
                    fp.write(str(child).encode('utf-8'))
                else:
                    child = str(child)
                    try:
                        for char in child:
                            if HTMLTag.__htmlents.canescape(char):
                                raise ValueError
                    except ValueError:
                        # child contained a value that needed escaping
                        child = HTMLTag.__htmlents.escape(child)

                    fp.write(child.encode('utf-8'))
        if self._type != 'cdata' and self._type not in HTMLTag.__unpairedtags:
            # sets a boolean flag to determin if we can wrap
            child_wrap_p = self._children and (len(self._children) >= HTMLTag.__wrapchildcount and hasattr(self._children[-1],'render'))
            if self._type not in HTMLTag.__noformatting and child_wrap_p:
                fp.write('\n' + spaces() + '</%s>' % self._type)
            else:
                fp.write('</%s>' % self._type)
        elif self._type == 'cdata':
            fp.write(']]>')

        if calldepth == 0:
            fp.write('\n')