class ExampleElement(Element): loader = XMLFile(FilePath('templates/tpl_temperature.xml')) def __init__(self, temp, hum): self.temperature = temp self.hummidity = hum self.extraTemperatureContent = XMLString('<input id="temperature" type="range" min="-100" max="100" value="'+self.temperature+'" class="xwot1 sensor columns large-8" />') self.extraHumidityContent = XMLString('<input id="humidity" type="range" min="0" max="100" value="'+self.hummidity+'" class="xwot1 sensor columns large-8" />') @renderer def header(self, request, tag): return tag('Header.') @renderer def temp(self, request, tag): return self.temperature @renderer def temperatureInput(self, request, tag): return self.extraTemperatureContent.load() @renderer def humidity(self, request, tag): return self.hummidity @renderer def humidityInput(self, request, tag): return self.extraHumidityContent.load()
def render_content(self, request, tag): """ render the content for the graph container """ if self.showreel_document is not None: graph_row_xml = XMLString(self.get_content_xml()) return graph_row_xml.load() else: oops_container = self.get_bad_container() return oops_container.load()
def configuration_content(self, request, tag): """ """ set_theme = theme_helpers.get_configured_theme(self.accessor) set_style = theme_helpers.get_configured_style(self.accessor) output_string = "" output_string += "<div>" output_string += "<h3>Themes</h3>" output_string += '<div class="btn-group">' for theme in theme_helpers.get_configured_themes(): if theme == set_theme: output_string += ( "<button type=\"button\" onclick=\"setTheme" "('%s')\" class=\"%s\">%s</button>" % ( theme, "btn btn-primary", theme )) else: output_string += ( "<button type=\"button\" onclick=\"setTheme" "('%s')\" class=\"%s\">%s</button>" % ( theme, "btn btn-default", theme )) output_string += "</div>" output_string += "<h3>Colour Schemes</h3>" output_string += '<div class="btn-group">' for style in theme_helpers.get_configured_styles(): if style == set_style: output_string += ( "<button type=\"button\" onclick=\"setStyle" "('%s')\" class=\"%s\">%s</button>" % ( style, "btn btn-primary", style )) else: output_string += ( "<button type=\"button\" onclick=\"setStyle" "('%s')\" class=\"%s\">%s</button>" % ( style, "btn btn-default", style )) output_string += "</div>" output_string += "</div>" renderable_string = XMLString(output_string) return renderable_string.load()
def render_content(self, request, tag): """ render the content for the graph container """ try: graph_row_xml = XMLString(self.get_row_xml()) return graph_row_xml.load() except Exception as err: logging.error( "Exception raised when rendering graphs, exception: %r" % ( err, )) oops_container = self.get_bad_container() return oops_container.load()
def loadMessage(self, code): tag = XMLString( ('<t:transparent xmlns:t="http://twistedmatrix.com/' 'ns/twisted.web.template/0.1">') + ERROR_MESSAGES.get(code, "") + '</t:transparent>').load()[0] return tag
class Elem(Element): loader = XMLString(b""" <div xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1"> """ + b"A" * 1000 + b""" <div t:render="r" /> <div t:render="r2" /> <div t:render="r3"> <t:slot name="meep" /> </div> </div> """) def __init__(self, children=[]): super(Elem, self).__init__() self.children = children @renderer def r(self, req, tag): return tag([self.children, u'hi mom!'], attr=u'value') @renderer def r2(self, req, tag): return tags.div(u'foo', attr=u'value') @renderer def r3(self, req, tag): return tag.fillSlots(meep=(u'slotvalue', u'42', b'bar', tags.div(u'meep', attr=u'value')))
def test_entityConversion(self): """ When flattening an HTML entity, it should flatten out to the utf-8 representation if possible. """ element = Element(loader=XMLString('<p>☃</p>')) return self.assertFlattensTo(element, b'<p>\xe2\x98\x83</p>')
def test_entityConversion(self): """ When flattening an HTML entity, it should flatten out to the utf-8 representation if possible. """ element = Element(loader=XMLString("<p>☃</p>")) self.assertFlattensImmediately(element, b"<p>\xe2\x98\x83</p>")
class MenuNavigationBar(Element): ''' Convenient class to create a dynamic navigation bar .. versionadded:: 0.8.2 .. note:: This is strongly related with the file: templates/template_index.html. The content of the each element should be implemented dynamically (here or in any subclass) or statically (into the mentioned file). ''' loader = XMLString(template_menu_item) menuData = ['cohen3', 'devices', 'logging', 'about'] def __init__(self, page): super(MenuNavigationBar, self).__init__() self.page = page self.coherence = page.coherence self.tabs = [] @renderer def menu_elements(self, request, tag): for el in self.menuData: link = el.lower() cls_active = '' if el == 'cohen3': link = 'home' cls_active += 'active' tag.fillSlots(menu_id=f'but-{link}') tag.fillSlots(menu_class=f'{cls_active}') tag.fillSlots(menu_click=f'openTab(\'{link}\', this)') yield MenuItemElement(TagLoader(tag), el)
def test_elementContainingDynamicElement(self): """ Directives in the document factory of an Element returned from a render method of another Element are satisfied from the correct object: the "inner" Element. """ class OuterElement(Element): @renderer def outerMethod(self, request, tag): return tag( InnerElement(loader=XMLString(""" <t:ignored xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="innerMethod" /> """))) class InnerElement(Element): @renderer def innerMethod(self, request, tag): return "Hello, world." element = OuterElement(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="outerMethod" /> """)) return self.assertFlattensTo(element, b"<p>Hello, world.</p>")
def test_sameLoaderTwice(self): """ Rendering the output of a loader, or even the same element, should return different output each time. """ sharedLoader = XMLString( '<p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">' '<t:transparent t:render="classCounter" /> ' '<t:transparent t:render="instanceCounter" />' '</p>') class DestructiveElement(Element): count = 0 instanceCount = 0 loader = sharedLoader @renderer def classCounter(self, request, tag): DestructiveElement.count += 1 return tag(str(DestructiveElement.count)) @renderer def instanceCounter(self, request, tag): self.instanceCount += 1 return tag(str(self.instanceCount)) e1 = DestructiveElement() e2 = DestructiveElement() self.assertFlattensImmediately(e1, b"<p>1 1</p>") self.assertFlattensImmediately(e1, b"<p>2 2</p>") self.assertFlattensImmediately(e2, b"<p>3 1</p>")
def outerMethod(self, request, tag): return tag( InnerElement(loader=XMLString(""" <t:ignored xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="innerMethod" /> """)))
def html2stan(html): """ Convert an HTML string to a Stan tree. @param html: An HTML fragment; multiple roots are allowed. @type html: C{string} @return: The fragment as a tree with a transparent root node. """ if isinstance(html, str): html = html.encode('utf8') html = _RE_CONTROL.sub(lambda m:b'\\x%02x' % ord(m.group()), html) stan = XMLString(b'<div>%s</div>' % html).load()[0] assert stan.tagName == 'div' stan.tagName = '' return stan
class BravoRootElement(Element): """ Element representing the web site root. """ loader = XMLString(root_template) def __init__(self, worlds, services): Element.__init__(self) self.services = services self.worlds = worlds @renderer def title(self, request, tag): return tag("Bravo %s" % version) @renderer def service(self, request, tag): services = [] for name, factory in self.services.iteritems(): services.append(tags.li("%s (%s)" % (name, factory.__class__))) return tag(tags.h2("Services"), tags.ul(*services)) @renderer def world(self, request, tag): worlds = [] for name in self.worlds.keys(): worlds.append(tags.li(tags.a(name.title(), href=name))) return tag(tags.h2("Worlds"), tags.ul(*worlds))
def outerMethod(self, request: Optional[IRequest], tag: Tag) -> Flattenable: return tag( InnerElement(loader=XMLString(""" <t:ignored xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="innerMethod" /> """)))
class TestElement(Element): """ An L{Element} that can be rendered successfully. """ loader = XMLString( '<p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">' 'Hello, world.' '</p>')
def configuration_content(self, request, tag): """ get the list content """ output_string = "" output_string += '<div class="list-group">' output_string += "<div>" output_string += self.get_showreel_xml() output_string += self.get_dashboard_xml() output_string += self.get_graph_xml() output_string += self.get_data_sources_xml() output_string += "</div>" output_string += "</div>" renderable_string = XMLString(output_string) return renderable_string.load()
def __init__(self, name: str, text: str): super().__init__(name=name, text=text) if self.is_empty(): self._dom: Optional[minidom.Document] = None self._version = -1 self._loader: ITemplateLoader = TagLoader(tags.transparent) else: self._dom = parse_xml(self.text) self._version = self._extract_version(self._dom, self.name) self._loader = XMLString(self._dom.toxml())
class AutomatonStatsElement(Element): """ Render some information about automatons. """ loader = XMLString(automaton_stats_template) @renderer def main(self, request, tag): return tag(*(AutomatonElement(a) for a in factory.automatons))
def test_lenientPrefixBehavior(self): """ If the parser sees a prefix it doesn't recognize on an attribute, it will pass it on through to serialization. """ theInput = ('<hello:world hello:sample="testing" ' 'xmlns:hello="http://made-up.example.com/ns/not-real">' "This is a made-up tag.</hello:world>") element = Element(loader=XMLString(theInput)) self.assertFlattensTo(element, theInput.encode("utf8"))
class RecentChangesElement(Element): def __init__(self, root): self.root = root @renderer def changes(self, request, tag): r = [] for d in reversed(self.root._edits): r.append( tag.clone().fillSlots( diff=self.diff(d, request), hist=self.hist(d, request), object=util.taglink(d.obj), time=d.time, user=d.user)) return r def diff(self, data, request): u = URLPath.fromRequest(request) u = u.sibling('diff') u.query = urllib.urlencode({ 'ob': data.obj.fullName(), 'revA': data.rev-1, 'revB': data.rev, }) return tags.a(href=str(u))("(diff)") def hist(self, data, request): u = URLPath.fromRequest(request) u = u.sibling('diff') u.query = urllib.urlencode({ 'ob': data.obj.fullName(), 'rev': data.rev, }) return tags.a(href=str(u))("(hist)") loader = XMLString('''\ <html xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1"> <head> <title>Recent Changes</title> <link rel="stylesheet" type="text/css" href="apidocs.css" /> </head> <body> <h1>Recent Changes</h1> <p>See <a href="bigDiff">a diff containing all changes made online</a></p> <ul> <li t:render="changes"> <t:slot name="diff" /> - <t:slot name="hist" /> - <t:slot name="object" /> - <t:slot name="time" /> - <t:slot name="user" /> </li> </ul> </body> </html> ''')
class SimpleElement(Element): loader = XMLString( '<h1 xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" ' 't:render="name" />') def __init__(self, name): self._name = name @renderer def name(self, request, tag): return tag(self._name)
def test_transparentRendering(self): """ A C{transparent} element should be eliminated from the DOM and rendered as only its children. """ element = Element(loader=XMLString( "<t:transparent " 'xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">' "Hello, world." "</t:transparent>")) return self.assertFlattensTo(element, b"Hello, world.")
def test_missingRenderMethod(self): """ Flattening an L{Element} with a C{loader} which has a tag with a render directive fails with L{FlattenerError} if there is no available render method to satisfy that directive. """ element = Element(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="unknownMethod" /> """)) return self.assertFlatteningRaises(element, MissingRenderMethod)
def test_attrRendering(self): """ An Element with an attr tag renders the vaule of its attr tag as an attribute of its containing tag. """ element = Element(loader=XMLString( '<a xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">' '<t:attr name="href">http://example.com</t:attr>' "Hello, world." "</a>")) return self.assertFlattensTo( element, b'<a href="http://example.com">Hello, world.</a>')
class TestFailureElement(Element): """ An L{Element} that can be used in place of L{FailureElement} to verify that L{renderElement} can render failures properly. """ loader = XMLString( '<p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1">' 'I failed.' '</p>') def __init__(self, failure, loader=None): self.failure = failure
class RoomsElement(Element): loader = XMLString( ('<h1 ' 'xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1"' '>Hello, <span t:render="name"></span>!</h1>')) def __init__(self, name): self.m_name = name @renderer def name(self, _request, _tag): return self.m_name
def rstToStan(rst): html = rstToHTML(rst) # fix a bad encoding in docutils html = html.replace('encoding="unicode"', '') stan = XMLString(html).load()[0] if stan.tagName != "html": raise ValueError("Unexpected top-level HTML tag.") head, body = [x for x in stan.children if checkTag(x)] if head.tagName != "head": raise ValueError("Expected 'head' node, got '%s'" % (head.tagName)) if body.tagName != "body": raise ValueError("Expected 'body' node, got '%s'" % (body.tagName)) return body.children
class BravoElement(Element): loader = XMLString(root_template) def __init__(self, services): Element.__init__(self) self.services = services @renderer def title(self, request, tag): return tag("Bravo %s" % version) @renderer def service(self, request, tag): l = [] services = [] for name, service in self.services.iteritems(): factory = service.args[1] if isinstance(factory, BravoFactory): services.append(self.bravofactory(request, tags.div, factory)) else: l.append( tags.li("%s (%s)" % (name, self.services[name].__class__))) ul = tags.ul(*l) div = tags.div(*services) return tag(ul, div) def bravofactory(self, request, tag, factory): g = (tags.li(username) for username in factory.protocols) users = tags.div(tags.h3("Users"), tags.ul(*g)) world = self.world(request, tags.div, factory.world) return tag(tags.h2("Bravo world %s" % factory.name), users, world) def world(self, request, tag, world): l = [] total = (len(world.chunk_cache) + len(world.dirty_chunk_cache) + len(world._pending_chunks)) l.append(tags.li("Total chunks: %d" % total)) l.append(tags.li("Clean chunks: %d" % len(world.chunk_cache))) l.append(tags.li("Dirty chunks: %d" % len(world.dirty_chunk_cache))) l.append( tags.li("Chunks being generated: %d" % len(world._pending_chunks))) if world.permanent_cache: l.append( tags.li("Permanent cache: enabled, %d chunks" % len(world.permanent_cache))) else: l.append(tags.li("Permanent cache: disabled")) status = tags.ul(*l) return tag(tags.h3("World status"), status)
class BravoWorldElement(Element): """ Element representing a single world. """ loader = XMLString(world_template) def __init__(self, factory, plugins): Element.__init__(self) self.factory = factory self.plugins = plugins @renderer def title(self, request, tag): return tag("World %s" % self.factory.name.title()) @renderer def user(self, request, tag): users = (tags.li(username) for username in self.factory.protocols) return tag(tags.h2("Users"), tags.ul(*users)) @renderer def status(self, request, tag): world = self.factory.world l = [] total = (len(world.chunk_cache) + len(world.dirty_chunk_cache) + len(world._pending_chunks)) l.append(tags.li("Total chunks: %d" % total)) l.append(tags.li("Clean chunks: %d" % len(world.chunk_cache))) l.append(tags.li("Dirty chunks: %d" % len(world.dirty_chunk_cache))) l.append( tags.li("Chunks being generated: %d" % len(world._pending_chunks))) if world.permanent_cache: l.append( tags.li("Permanent cache: enabled, %d chunks" % len(world.permanent_cache))) else: l.append(tags.li("Permanent cache: disabled")) status = tags.ul(*l) return tag(tags.h2("Status"), status) @renderer def plugin(self, request, tag): plugins = [] for name in self.plugins.keys(): plugins.append( tags.li( tags.a(name.title(), href='%s/%s' % (self.factory.name, name)))) return tag(tags.h2("Plugins"), tags.ul(*plugins))
def test_elementContainingStaticElement(self): """ An Element which is returned by the render method of another Element is rendered properly. """ class RenderfulElement(Element): @renderer def renderMethod(self, request, tag): return tag(Element( loader=XMLString("<em>Hello, world.</em>"))) element = RenderfulElement(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="renderMethod" /> """)) return self.assertFlattensTo(element, b"<p><em>Hello, world.</em></p>")
def test_directiveRenderingOmittingTag(self): """ An Element with a render method which omits the containing tag successfully removes that tag from the output. """ class RenderfulElement(Element): @renderer def renderMethod(self, request, tag): return "Hello, world." element = RenderfulElement(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="renderMethod"> Goodbye, world. </p> """)) return self.assertFlattensTo(element, b"Hello, world.")
def test_directiveRendering(self): """ An Element with a valid render directive has that directive invoked and the result added to the output. """ renders = [] class RenderfulElement(Element): @renderer def renderMethod(self, request, tag): renders.append((self, request)) return tag("Hello, world.") element = RenderfulElement(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="renderMethod" /> """)) return self.assertFlattensTo(element, b"<p>Hello, world.</p>")
def test_deferredRendering(self): """ An Element with a render method which returns a Deferred will render correctly. """ class RenderfulElement(Element): @renderer def renderMethod(self, request, tag): return succeed("Hello, world.") element = RenderfulElement(loader=XMLString(""" <p xmlns:t="http://twistedmatrix.com/ns/twisted.web.template/0.1" t:render="renderMethod"> Goodbye, world. </p> """)) return self.assertFlattensTo(element, b"Hello, world.")
def html2stan(html): """ Convert HTML to a Stan structure. @param html: A HTML string. @type html: L{unicode} or L{bytes} """ if isinstance(html, unicode): html = html.encode("utf8") html = _control_pat.sub(lambda m: "\\x%02x" % ord(m.group()), html) html = "<div>" + html + "</div>" html = XMLString(html).load()[0].children if html and html[-1] == u"\n": del html[-1] return html
def __init__(self, temp, hum): self.temperature = temp self.hummidity = hum self.extraTemperatureContent = XMLString('<input id="temperature" type="range" min="-100" max="100" value="'+self.temperature+'" class="xwot1 sensor columns large-8" />') self.extraHumidityContent = XMLString('<input id="humidity" type="range" min="0" max="100" value="'+self.hummidity+'" class="xwot1 sensor columns large-8" />')