genshi/genshi-test: genshi/filters/transform.py comparison

comparison genshi/filters/transform.py @ 902:09cc3627654c experimental-inline

Sync `experimental/inline` branch with [source:trunk@1126].

author	cmlenz
date	Fri, 23 Apr 2010 21:08:26 +0000
parents	1837f39efd6f
children

comparison

equal deleted inserted replaced

-:de82830f8816
+:09cc3627654c
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2007 Edgewall Software
+# Copyright (C) 2007-2009 Edgewall Software
 # All rights reserved.
 #
 # This software is licensed as described in the file COPYING, which
 # you should have received as part of this distribution. The terms
 # are also available at http://genshi.edgewall.org/wiki/License.
 ...  <head><title>Some Title</title></head>
 ...  <body>
 ...    Some <em>body</em> text.
 ...  </body>
 ... </html>''')
->>> print html | Transformer('body/em').map(unicode.upper, TEXT) \\
+>>> print(html | Transformer('body/em').map(unicode.upper, TEXT)
-...                                    .unwrap().wrap(tag.u)
+...                                    .unwrap().wrap(tag.u))
 <html>
 <head><title>Some Title</title></head>
 <body>
 Some <u>BODY</u> text.
 </body>
 Transformations act on selected stream events matching an XPath expression.
 Here's an example of removing some markup (the title, in this case)
 selected by an expression:
->>> print html | Transformer('head/title').remove()
+>>> print(html | Transformer('head/title').remove())
 <html><head/><body>Some <em>body</em> text.</body></html>
 Inserted content can be passed in the form of a string, or a markup event
 stream, which includes streams generated programmatically via the
 `builder` module:
 >>> from genshi.builder import tag
->>> print html | Transformer('body').prepend(tag.h1('Document Title'))
+>>> print(html | Transformer('body').prepend(tag.h1('Document Title')))
 <html><head><title>Some Title</title></head><body><h1>Document
 Title</h1>Some <em>body</em> text.</body></html>
 Each XPath expression determines the set of tags that will be acted upon by
 subsequent transformations. In this example we select the ``<title>`` text,
 copy it into a buffer, then select the ``<body>`` element and paste the
 copied text into the body as ``<h1>`` enclosed text:
 >>> buffer = StreamBuffer()
->>> print html | Transformer('head/title/text()').copy(buffer) \\
+>>> print(html | Transformer('head/title/text()').copy(buffer)
-...     .end().select('body').prepend(tag.h1(buffer))
+...     .end().select('body').prepend(tag.h1(buffer)))
 <html><head><title>Some Title</title></head><body><h1>Some Title</h1>Some
 <em>body</em> text.</body></html>
 Transformations can also be assigned and reused, although care must be
 taken when using buffers, to ensure that buffers are cleared between
 transforms:
 >>> emphasis = Transformer('body//em').attr('class', 'emphasis')
->>> print html | emphasis
+>>> print(html | emphasis)
 <html><head><title>Some Title</title></head><body>Some <em
 class="emphasis">body</em> text.</body></html>
 """
 __slots__ = ['transforms']
 ...         if mark and kind is TEXT:
 ...             yield mark, (kind, data.upper(), pos)
 ...         else:
 ...             yield mark, (kind, data, pos)
 >>> short_stream = HTML('<body>Some <em>test</em> text</body>')
->>> print short_stream | Transformer('.//em/text()').apply(upper)
+>>> print(short_stream | Transformer('.//em/text()').apply(upper))
 <body>Some <em>TEST</em> text</body>
 """
 transformer = Transformer()
 transformer.transforms = self.transforms[:]
 if isinstance(function, Transformer):
 def select(self, path):
 """Mark events matching the given XPath expression, within the current
 selection.
 >>> html = HTML('<body>Some <em>test</em> text</body>')
->>> print html | Transformer().select('.//em').trace()
+>>> print(html | Transformer().select('.//em').trace())
-(None, ('START', (QName(u'body'), Attrs()), (None, 1, 0)))
+(None, ('START', (QName('body'), Attrs()), (None, 1, 0)))
 (None, ('TEXT', u'Some ', (None, 1, 6)))
-('ENTER', ('START', (QName(u'em'), Attrs()), (None, 1, 11)))
+('ENTER', ('START', (QName('em'), Attrs()), (None, 1, 11)))
 ('INSIDE', ('TEXT', u'test', (None, 1, 15)))
-('EXIT', ('END', QName(u'em'), (None, 1, 19)))
+('EXIT', ('END', QName('em'), (None, 1, 19)))
 (None, ('TEXT', u' text', (None, 1, 24)))
-(None, ('END', QName(u'body'), (None, 1, 29)))
+(None, ('END', QName('body'), (None, 1, 29)))
 <body>Some <em>test</em> text</body>
 :param path: an XPath expression (as string) or a `Path` instance
 :return: the stream augmented by transformation marks
 :rtype: `Transformer`
 Specificaly, all marks are converted to null marks, and all null marks
 are converted to OUTSIDE marks.
 >>> html = HTML('<body>Some <em>test</em> text</body>')
->>> print html | Transformer('//em').invert().trace()
+>>> print(html | Transformer('//em').invert().trace())
-('OUTSIDE', ('START', (QName(u'body'), Attrs()), (None, 1, 0)))
+('OUTSIDE', ('START', (QName('body'), Attrs()), (None, 1, 0)))
 ('OUTSIDE', ('TEXT', u'Some ', (None, 1, 6)))
-(None, ('START', (QName(u'em'), Attrs()), (None, 1, 11)))
+(None, ('START', (QName('em'), Attrs()), (None, 1, 11)))
 (None, ('TEXT', u'test', (None, 1, 15)))
-(None, ('END', QName(u'em'), (None, 1, 19)))
+(None, ('END', QName('em'), (None, 1, 19)))
 ('OUTSIDE', ('TEXT', u' text', (None, 1, 24)))
-('OUTSIDE', ('END', QName(u'body'), (None, 1, 29)))
+('OUTSIDE', ('END', QName('body'), (None, 1, 29)))
 <body>Some <em>test</em> text</body>
 :rtype: `Transformer`
 """
 return self.apply(InvertTransformation())
 """End current selection, allowing all events to be selected.
 Example:
 >>> html = HTML('<body>Some <em>test</em> text</body>')
->>> print html | Transformer('//em').end().trace()
+>>> print(html | Transformer('//em').end().trace())
-('OUTSIDE', ('START', (QName(u'body'), Attrs()), (None, 1, 0)))
+('OUTSIDE', ('START', (QName('body'), Attrs()), (None, 1, 0)))
 ('OUTSIDE', ('TEXT', u'Some ', (None, 1, 6)))
-('OUTSIDE', ('START', (QName(u'em'), Attrs()), (None, 1, 11)))
+('OUTSIDE', ('START', (QName('em'), Attrs()), (None, 1, 11)))
 ('OUTSIDE', ('TEXT', u'test', (None, 1, 15)))
-('OUTSIDE', ('END', QName(u'em'), (None, 1, 19)))
+('OUTSIDE', ('END', QName('em'), (None, 1, 19)))
 ('OUTSIDE', ('TEXT', u' text', (None, 1, 24)))
-('OUTSIDE', ('END', QName(u'body'), (None, 1, 29)))
+('OUTSIDE', ('END', QName('body'), (None, 1, 29)))
 <body>Some <em>test</em> text</body>
 :return: the stream augmented by transformation marks
 :rtype: `Transformer`
 """
 Example:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').empty()
+>>> print(html | Transformer('.//em').empty())
 <html><head><title>Some Title</title></head><body>Some <em/>
 text.</body></html>
 :rtype: `Transformer`
 """
 Example:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').remove()
+>>> print(html | Transformer('.//em').remove())
 <html><head><title>Some Title</title></head><body>Some
 text.</body></html>
 :rtype: `Transformer`
 """
 Example:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').unwrap()
+>>> print(html | Transformer('.//em').unwrap())
 <html><head><title>Some Title</title></head><body>Some body
 text.</body></html>
 :rtype: `Transformer`
 """
 def wrap(self, element):
 """Wrap selection in an element.
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').wrap('strong')
+>>> print(html | Transformer('.//em').wrap('strong'))
 <html><head><title>Some Title</title></head><body>Some
 <strong><em>body</em></strong> text.</body></html>
 :param element: either a tag name (as string) or an `Element` object
 :rtype: `Transformer`
 def replace(self, content):
 """Replace selection with content.
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//title/text()').replace('New Title')
+>>> print(html | Transformer('.//title/text()').replace('New Title'))
 <html><head><title>New Title</title></head><body>Some <em>body</em>
 text.</body></html>
 :param content: Either a callable, an iterable of events, or a string
 to insert.
 In this example we insert the word 'emphasised' before the <em> opening
 tag:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').before('emphasised ')
+>>> print(html | Transformer('.//em').before('emphasised '))
 <html><head><title>Some Title</title></head><body>Some emphasised
 <em>body</em> text.</body></html>
 :param content: Either a callable, an iterable of events, or a string
 to insert.
 Here, we insert some text after the </em> closing tag:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em').after(' rock')
+>>> print(html | Transformer('.//em').after(' rock'))
 <html><head><title>Some Title</title></head><body>Some <em>body</em>
 rock text.</body></html>
 :param content: Either a callable, an iterable of events, or a string
 to insert.
 Inserting some new text at the start of the <body>:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//body').prepend('Some new body text. ')
+>>> print(html | Transformer('.//body').prepend('Some new body text. '))
 <html><head><title>Some Title</title></head><body>Some new body text.
 Some <em>body</em> text.</body></html>
 :param content: Either a callable, an iterable of events, or a string
 to insert.
 def append(self, content):
 """Insert content before the END event of the selection.
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//body').append(' Some new body text.')
+>>> print(html | Transformer('.//body').append(' Some new body text.'))
 <html><head><title>Some Title</title></head><body>Some <em>body</em>
 text. Some new body text.</body></html>
 :param content: Either a callable, an iterable of events, or a string
 to insert.
 element:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em class="before">body</em> <em>text</em>.</body>'
 ...             '</html>')
->>> print html | Transformer('body/em').attr('class', None)
+>>> print(html | Transformer('body/em').attr('class', None))
 <html><head><title>Some Title</title></head><body>Some <em>body</em>
 <em>text</em>.</body></html>
 Otherwise the attribute will be set to `value`:
->>> print html | Transformer('body/em').attr('class', 'emphasis')
+>>> print(html | Transformer('body/em').attr('class', 'emphasis'))
 <html><head><title>Some Title</title></head><body>Some <em
 class="emphasis">body</em> <em class="emphasis">text</em>.</body></html>
 If `value` is a callable it will be called with the attribute name and
 the `START` event for the matching element. Its return value will then
 be used to set the attribute:
 >>> def print_attr(name, event):
 ...     attrs = event[1][1]
-...     print attrs
+...     print(attrs)
 ...     return attrs.get(name)
->>> print html | Transformer('body/em').attr('class', print_attr)
+>>> print(html | Transformer('body/em').attr('class', print_attr))
-Attrs([(QName(u'class'), u'before')])
+Attrs([(QName('class'), u'before')])
 Attrs()
 <html><head><title>Some Title</title></head><body>Some <em
 class="before">body</em> <em>text</em>.</body></html>
 :param name: the name of the attribute
 >>> from genshi.builder import tag
 >>> buffer = StreamBuffer()
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('head/title/text()').copy(buffer) \\
+>>> print(html | Transformer('head/title/text()').copy(buffer)
-...     .end().select('body').prepend(tag.h1(buffer))
+...     .end().select('body').prepend(tag.h1(buffer)))
 <html><head><title>Some Title</title></head><body><h1>Some
 Title</h1>Some <em>body</em> text.</body></html>
 This example illustrates that only a single contiguous selection will
 be buffered:
->>> print html | Transformer('head/title/text()').copy(buffer) \\
+>>> print(html | Transformer('head/title/text()').copy(buffer)
-...     .end().select('body/em').copy(buffer).end().select('body') \\
+...     .end().select('body/em').copy(buffer).end().select('body')
-...     .prepend(tag.h1(buffer))
+...     .prepend(tag.h1(buffer)))
 <html><head><title>Some Title</title></head><body><h1>Some
 Title</h1>Some <em>body</em> text.</body></html>
->>> print buffer
+>>> print(buffer)
 <em>body</em>
 Element attributes can also be copied for later use:
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body><em>Some</em> <em class="before">body</em>'
 ...             '<em>text</em>.</body></html>')
 >>> buffer = StreamBuffer()
 >>> def apply_attr(name, entry):
 ...     return list(buffer)[0][1][1].get('class')
->>> print html | Transformer('body/em[@class]/@class').copy(buffer) \\
+>>> print(html | Transformer('body/em[@class]/@class').copy(buffer)
-...     .end().buffer().select('body/em[not(@class)]') \\
+...     .end().buffer().select('body/em[not(@class)]')
-...     .attr('class', apply_attr)
+...     .attr('class', apply_attr))
 <html><head><title>Some Title</title></head><body><em
 class="before">Some</em> <em class="before">body</em><em
 class="before">text</em>.</body></html>
 >>> from genshi.builder import tag
 >>> buffer = StreamBuffer()
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...             '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('.//em/text()').cut(buffer) \\
+>>> print(html | Transformer('.//em/text()').cut(buffer)
-...     .end().select('.//em').after(tag.h1(buffer))
+...     .end().select('.//em').after(tag.h1(buffer)))
 <html><head><title>Some Title</title></head><body>Some
 <em/><h1>body</h1> text.</body></html>
 Specifying accumulate=True, appends all selected intervals onto the
 buffer. Combining this with the .buffer() operation allows us operate
 top of the document:
 >>> doc = HTML('<doc><notes></notes><body>Some <note>one</note> '
 ...            'text <note>two</note>.</body></doc>')
 >>> buffer = StreamBuffer()
->>> print doc | Transformer('body/note').cut(buffer, accumulate=True) \\
+>>> print(doc | Transformer('body/note').cut(buffer, accumulate=True)
-...     .end().buffer().select('notes').prepend(buffer)
+...     .end().buffer().select('notes').prepend(buffer))
 <doc><notes><note>one</note><note>two</note></notes><body>Some  text
 .</body></doc>
 """
 return self.apply(list)
 once for each contiguous block of marked events.
 >>> from genshi.filters.html import HTMLSanitizer
 >>> html = HTML('<html><body>Some text<script>alert(document.cookie)'
 ...             '</script> and some more text</body></html>')
->>> print html | Transformer('body/*').filter(HTMLSanitizer())
+>>> print(html | Transformer('body/*').filter(HTMLSanitizer()))
 <html><body>Some text and some more text</body></html>
 :param filter: The stream filter to apply.
 :rtype: `Transformer`
 """
 """Applies a function to the ``data`` element of events of ``kind`` in
 the selection.
 >>> html = HTML('<html><head><title>Some Title</title></head>'
 ...               '<body>Some <em>body</em> text.</body></html>')
->>> print html | Transformer('head/title').map(unicode.upper, TEXT)
+>>> print(html | Transformer('head/title').map(unicode.upper, TEXT))
 <html><head><title>SOME TITLE</title></head><body>Some <em>body</em>
 text.</body></html>
 :param function: the function to apply
 :param kind: the kind of event the function should be applied to
 Refer to the documentation for ``re.sub()`` for details.
 >>> html = HTML('<html><body>Some text, some more text and '
 ...             '<b>some bold text</b>\\n'
 ...             '<i>some italicised text</i></body></html>')
->>> print html | Transformer('body/b').substitute('(?i)some', 'SOME')
+>>> print(html | Transformer('body/b').substitute('(?i)some', 'SOME'))
 <html><body>Some text, some more text and <b>SOME bold text</b>
 <i>some italicised text</i></body></html>
 >>> tags = tag.html(tag.body('Some text, some more text and\\n',
 ...      Markup('<b>some bold text</b>')))
->>> print tags.generate() | Transformer('body').substitute(
+>>> print(tags.generate() | Transformer('body').substitute(
-...     '(?i)some', 'SOME')
+...     '(?i)some', 'SOME'))
 <html><body>SOME text, some more text and
 <b>SOME bold text</b></body></html>
 :param pattern: A regular expression object or string.
 :param replace: Replacement pattern.
 def rename(self, name):
 """Rename matching elements.
 >>> html = HTML('<html><body>Some text, some more text and '
 ...             '<b>some bold text</b></body></html>')
->>> print html | Transformer('body/b').rename('strong')
+>>> print(html | Transformer('body/b').rename('strong'))
 <html><body>Some text, some more text and <strong>some bold text</strong></body></html>
 """
 return self.apply(RenameTransformation(name))
 def trace(self, prefix='', fileobj=None):
 """Print events as they pass through the transform.
 >>> html = HTML('<body>Some <em>test</em> text</body>')
->>> print html | Transformer('em').trace()
+>>> print(html | Transformer('em').trace())
-(None, ('START', (QName(u'body'), Attrs()), (None, 1, 0)))
+(None, ('START', (QName('body'), Attrs()), (None, 1, 0)))
 (None, ('TEXT', u'Some ', (None, 1, 6)))
-('ENTER', ('START', (QName(u'em'), Attrs()), (None, 1, 11)))
+('ENTER', ('START', (QName('em'), Attrs()), (None, 1, 11)))
 ('INSIDE', ('TEXT', u'test', (None, 1, 15)))
-('EXIT', ('END', QName(u'em'), (None, 1, 19)))
+('EXIT', ('END', QName('em'), (None, 1, 19)))
 (None, ('TEXT', u' text', (None, 1, 24)))
-(None, ('END', QName(u'body'), (None, 1, 29)))
+(None, ('END', QName('body'), (None, 1, 29)))
 <body>Some <em>test</em> text</body>
 :param prefix: a string to prefix each event with in the output
 :param fileobj: the writable file-like object to write to; defaults to
 the standard output stream
 """Apply the transform filter to the marked stream.
 :param stream: the marked event stream to filter
 """
 for event in stream:
-print>>self.fileobj, self.prefix + str(event)
+self.fileobj.write('%s%s\n' % (self.prefix, event))
 yield event
 class FilterTransformation(object):
 """Apply a normal stream filter to the selection. The filter is called once
 ...         for event in self._inject():
 ...             yield event
 ...         for event in stream:
 ...             yield event
 >>> html = HTML('<body>Some <em>test</em> text</body>')
->>> print html | Transformer('.//em').apply(Top('Prefix '))
+>>> print(html | Transformer('.//em').apply(Top('Prefix ')))
 Prefix <body>Some <em>test</em> text</body>
 """
 def __init__(self, content):
 """Create a new injector.

Mercurial > genshi > genshi-test

comparison genshi/filters/transform.py @ 902:09cc3627654c experimental-inline