def force_unicode(blarg):
result = blarg
if isinstance(result, str):
result = result.decode('utf-8')
else:
result = unicode(result)
return result
class Tag(object):
template = u'<%(tagname)s%(attributes)s>%(contents)s</%(tagname)s>'
attribute_template = u'%(attrname)s="%(attrvalue)s"'
def __init__(self, tag, contents=None, attributes=None):
self.children = []
self.tag = tag
if contents is None: contents = []
elif not hasattr(contents, '__iter__'):
contents = [contents]
self.contents = [(force_unicode(item) if isinstance(item, str) else item) for item in contents]
if attributes is None: attributes = {}
self.attributes = {force_unicode(key):force_unicode(attr) for key, attr in attributes.items()}
def navigate(self, *args):
if list(args) == []: return [self]
else:
head, tail = args[0], args[1:]
match = {}
if hasattr(head, '__iter__'):
match['tag'], match['attributes'] = head
else:
match['tag'], match['attributes'] = head, {}
results = []
for el in [em for em in self.contents if isinstance(em, self.__class__)]:
if el.tag == match['tag']:
if match['attributes'] == {} or all(el.attributes[k]==self.quote_value(match['attributes'][k]) for k in match['attributes']):
results.extend(el.navigate(*tail))
return filter(None, results)
def quote_value(self, value):
if not isinstance(value, (str, unicode)):
value = unicode(value)
return value.replace('"', '\\"')
def _make_attributes(self):
result = u''
if self.attributes != {}:
result = []
for attr, value in self.attributes.items():
result.append(self.attribute_template % dict(attrname=attr, attrvalue=self.quote_value(value)))
result = u' %s' % u' '.join(result)
return result
def _make_contents(self):
result = []
for item in self.contents:
result.append(force_unicode(item))
return u''.join(result)
def __repr__(self):
return '<Tag %r attrs=%r>' % (self.tag, self.attributes)
def __str__(self):
return unicode(self).encode('utf-8')
def __unicode__(self):
attributes = self._make_attributes()
contents = self._make_contents()
return self.template % dict(tagname=self.tag, contents=contents, attributes=attributes)
def _add(self, item):
return Tag(self.tag, self.contents+[item], self.attributes)
def __rshift__(self, other):
result = self
if not hasattr(other, '__iter__'):
other = [other]
for i in other:
result = result._add(i)
return result
def __rlshift__(self, other):
print 1
return self._add(other)
def __lshift__(self, other):
if hasattr(other, '_add'):
return other._add(self)
else:
raise TypeError('Cannot surround a tag with text')
def __enter__(self, *a, **kw):
return self
def __exit__(self, *a, **kw):
pass
def child(self, tag, **attrs):
attrs = { key.lower(): value for (key,value) in attrs.items() }
self.contents.append(Tag(tag, None, attrs))
return self.contents[-1]
def text(self, text):
self.contents.append(text)
return self
def attr(self, attr, value):
self.attributes[attr] = value
return self
try:
from BeautifulSoup import BeautifulSoup
def pretty(self):
return self.BeautifulSoup(str(self)).prettify()
except ImportError:
pass
import unittest
class TagTest(unittest.TestCase):
def __init__(self, *args, **kw):
unittest.TestCase.__init__(self, *args, **kw)
def test_quoteattrvalue(self):
a = Tag('test')
self.assertEqual(a.quote_value('asd"asd'), 'asd\\"asd')
self.assertEqual(a.quote_value('asd"a"sd'), 'asd\\"a\\"sd')
def test_print1(self):
a = Tag('test')
self.assertEqual(str(a), '<test></test>')
def test_print2(self):
a = Tag('test', 'asd')
self.assertEqual(str(a), '<test>asd</test>')
def test_print3(self):
a = Tag('test', None, {'a':1, 'b':'a'})
self.assertEqual(str(a), '<test a="1" b="a"></test>')
def test_print4(self):
a = Tag('test', 'asd', {'a':1, 'b':'a'})
self.assertEqual(str(a), '<test a="1" b="a">asd</test>')
def test_print4(self):
a = Tag('test', ['asd', Tag('test1')], {'a':1, 'b':'a'})
self.assertEqual(str(a), '<test a="1" b="a">asd<test1></test1></test>')
def test_print5(self):
test = str(Tag('a') >> [Tag('b') >> Tag('c'), Tag('d') >> [Tag('e') >> 'asd']])
model = '<a><b><c></c></b><d><e>asd</e></d></a>'
self.assertEqual(test, model)
def test_contextmanager1(self):
with Tag('a') as a:
with a.child('b') as b:
b.attr('height', 20)
b.text('asd')
with a.child('c'): pass
with a.child('d', Class='dog') as d: pass
self.assertEquals(str(a), '<a><b height="20">asd</b><c></c><d class="dog"></d></a>')
def test_compose1(self):
a = Tag('test')
b = Tag('test1')
self.assertEqual(str(a >> b), '<test><test1></test1></test>')
def test_compose2(self):
a = Tag('test')
self.assertEqual(str(a >> 'asd'), '<test>asd</test>')
def test_compose3(self):
a = Tag('test')
b = Tag('test1')
self.assertEqual(str(a << b), '<test1><test></test></test1>')
def test_compose4(self):
a = Tag('test')
self.assertEqual(str('asd' << a), '<test>asd</test>')
def test_compose4(self):
a = Tag('test')
unittest
self.assertRaises(TypeError, lambda: str(a << 'asd'))
def test_unicode(self):
a = Tag(u'üøœå')
unicode(a)
str(a)
def nav_tests(assertion):
def test_navigate(self):
with Tag('a') as a:
with a.child('b') as b:
b.attr('height', 20)
b.text('asd')
with a.child('b') as c:
with c.child('b') as e: pass
with c.child('d', height=20) as f: pass
with c.child('d', height=50) as g: pass
with c.child('d', height=20, width=10) as h: pass
with a.child('d', Class='dog') as d: pass
assertion(self, a,b,c,d,e,f,g,h)
return test_navigate
test_navigate1 = nav_tests(lambda self, a,b,c,d,e,f,g,h: self.assertEqual(a.navigate('b'), [b,c]))
test_navigate2 = nav_tests(lambda self, a,b,c,d,e,f,g,h: self.assertEqual(a.navigate('b', 'b'), [e]))
test_navigate3 = nav_tests(lambda self, a,b,c,d,e,f,g,h: self.assertEqual(a.navigate('b', 'd'), [f, g, h]))
test_navigate4 = nav_tests(lambda self, a,b,c,d,e,f,g,h: self.assertEqual(a.navigate('b', ['d', {'height':20}]), [f,h]))
if __name__ == '__main__':
unittest.main()
#import fileinput
#result = Tag('dl')
#for line in fileinput.input():
# line = line.strip().partition(' | ')
# result.child('dt').text(line[0])
# result.child('dd').text(line[-1])
#print (Tag('html') >> Tag('body') >> result).pretty()