Changeset 4052:88a13e8947d6 in livinglogic.python.xist

Show
Ignore:
Timestamp:
06/14/10 12:26:31 (9 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Module renaming and cleanup.

Rename the ll.xist.parsers module to parse and presenters to present.

Move ll.xist.publishers.Publisher and ll.xist.converters.Converter into the
ll.xist.xsc module and remove ll.xist.publishers and ll.xist.converters.

Files:
2 removed
33 modified
2 moved

Legend:

Unmodified
Added
Removed
  • INSTALL.rst

    r3898 r4052  
    8484 
    8585You can specify which format gets used by changing the value of the 
    86 ``defaultpresenter`` variable in the module :mod:`ll.xist.presenters`:: 
     86``defaultpresenter`` variable in the module :mod:`ll.xist.present`:: 
    8787 
    88     from ll.xist import presenters 
    89     presenters.defaultpresenter = presenters.TreePresenter 
     88    from ll.xist import present 
     89    present.defaultpresenter = present.TreePresenter 
    9090 
    9191Setting this value to ``None`` turns the display hook off. 
  • MIGRATION.rst

    r3998 r4052  
    11Migrating to version 3.8 
    22======================== 
     3 
     4Changes to parsing 
     5------------------ 
     6 
     7*   The module :mod:`ll.xist.parsers` has been renamed to :mod:`parse`. 
     8 
     9*   The module :mod:`ll.xist.presenters` has been renamed to :mod:`present`. 
     10 
     11*   The classes :class:`ll.xist.converters.Converter` and 
     12    :class:`ll.xist.publishers.Publisher` has been moved to :mod:`ll.xist.xsc`. 
     13    The modules :mod:`ll.xist.converters` and :mod:`ll.xist.publishers` no longer 
     14    exist. 
    315 
    416Changes to XISTs walk filters 
  • NEWS.rst

    r4028 r4052  
    77*   The function :class:`ll.xist.xsc.docprefixes` has been dropped. A new 
    88    function :class:`ll.xist.xsc.docpool` has been added. 
     9 
     10*   The module :mod:`ll.xist.parsers` has been renamed to :mod:`parse`. 
     11 
     12*   The module :mod:`ll.xist.presenters` has been renamed to :mod:`present`. 
     13 
     14*   The classes :class:`ll.xist.converters.Converter` and 
     15    :class:`ll.xist.publishers.Publisher` has been moved to :mod:`ll.xist.xsc`. 
     16    The modules :mod:`ll.xist.converters` and :mod:`ll.xist.publishers` no longer 
     17    exist. 
    918 
    1019*   The walk methods :meth:`walknode` and :meth:`walkpath` have been renamed to 
     
    11411150    character references. 
    11421151 
    1143     __  http://www.w3.org/TR/2004/REC-xml11-20040204/#NT-RestrictedChar 
     1152    __ http://www.w3.org/TR/2004/REC-xml11-20040204/#NT-RestrictedChar 
    11441153 
    11451154 
  • demos/cherrypy-images/images.py

    r4038 r4052  
    1010from cherrypy.lib import cptools 
    1111 
    12 from ll.xist import xsc, converters 
     12from ll.xist import xsc 
    1313from ll.xist.ns import xml, html, doc, htmlspecials, meta 
    1414 
  • demos/media/Media.py

    r4038 r4052  
    22# -*- coding: utf-8 -*- 
    33 
    4 from ll.xist import xsc, sims, parsers 
     4from ll.xist import xsc, sims, parse 
    55from ll.xist.ns import html, htmlspecials, meta, xml, chars 
    66 
     
    144144 
    145145if __name__ == "__main__": 
    146     node = parsers.tree(parsers.FileSource("Media.xml"), parsers.Expat(ns=True), xsc.Pool(vars(), chars, xml)) 
     146    node = parse.tree(parse.FileSource("Media.xml"), parse.Expat(ns=True), xsc.Pool(vars(), chars, xml)) 
    147147    node = node[media][0] 
    148148    node = node.conv() 
  • demos/python-quotes/python-quotes.py

    r4038 r4052  
    22# -*- coding: utf-8 -*- 
    33 
    4 from ll.xist import xsc, parsers 
     4from ll.xist import xsc, parse 
    55from ll.xist.ns import xml, html, meta 
    66 
     
    1414    pool = xsc.Pool(html, xml, qel_xmlns, rdf_xmlns, rdfs_xmlns, cc_xmlns, dc_xmlns) 
    1515    base = "root:python-quotes.html" 
    16     e = parsers.tree(parsers.URLSource(url), parsers.Expat(ns=True), parsers.Instantiate(pool=pool, base=base), validate=False) 
     16    e = parse.tree(parse.URLSource(url), parse.Expat(ns=True), parse.Instantiate(pool=pool, base=base), validate=False) 
    1717    e = e[qel_xmlns.quotations][0] 
    1818    e = e.compact().conv() 
  • docs/XIST_Advanced.xml

    r3999 r4052  
    44<p>Converter contexts can be used to pass around information in recursive 
    55calls to the <meth>convert</meth> and <meth>mapped</meth> methods. 
    6 A <pyref module="ll.xist.converters" class="Converter"><class>Converter</class></pyref> 
     6A <pyref module="ll.xist.xsc" class="Converter"><class>Converter</class></pyref> 
    77object will be passed in all calls, so this object is the place to store 
    88information. However if each element, procinst and entity class decided on its 
  • docs/XIST_Examples.xml

    r4039 r4052  
    109109 
    110110<prog> 
    111 from ll.xist import parsers 
     111from ll.xist import parse 
    112112from ll.xist.ns import html 
    113113 
    114 node = parsers.tree( 
    115     parsers.URLSource("http://www.python.org/"), 
    116     parsers.Tidy(), 
    117     parsers.NS(html), 
    118     parsers.Instantiate() 
     114node = parse.tree( 
     115    parse.URLSource("http://www.python.org/"), 
     116    parse.Tidy(), 
     117    parse.NS(html), 
     118    parse.Instantiate() 
    119119) 
    120120</prog> 
     
    129129 
    130130<tty> 
    131 <prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parsers</input> 
     131<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parse</input> 
    132132<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    133 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.tree(</input> 
    134 <prompt>... </prompt><input>    parsers.URLSource("http://www.python.org/"),</input> 
    135 <prompt>... </prompt><input>    parsers.Expat(ns=True),</input> 
    136 <prompt>... </prompt><input>    parsers.Instantiate()</input> 
     133<prompt>&gt;&gt;&gt; </prompt><input>node = parse.tree(</input> 
     134<prompt>... </prompt><input>    parse.URLSource("http://www.python.org/"),</input> 
     135<prompt>... </prompt><input>    parse.Expat(ns=True),</input> 
     136<prompt>... </prompt><input>    parse.Instantiate()</input> 
    137137<prompt>... </prompt><input>)</input> 
    138138<prompt>&gt;&gt;&gt; </prompt><input>for img in node.walknodes(html.a/html.img):</input> 
     
    149149 
    150150<tty> 
    151 <prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parsers, xfind</input> 
     151<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parse, xfind</input> 
    152152<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    153 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.tree(</input> 
    154 <prompt>... </prompt><input>    parsers.URLSource("http://www.python.org/"),</input> 
    155 <prompt>... </prompt><input>    parsers.Expat(ns=True),</input> 
    156 <prompt>... </prompt><input>    parsers.Instantiate()</input> 
     153<prompt>&gt;&gt;&gt; </prompt><input>node = parse.tree(</input> 
     154<prompt>... </prompt><input>    parse.URLSource("http://www.python.org/"),</input> 
     155<prompt>... </prompt><input>    parse.Expat(ns=True),</input> 
     156<prompt>... </prompt><input>    parse.Instantiate()</input> 
    157157<prompt>... </prompt><input>)</input> 
    158158<prompt>&gt;&gt;&gt; </prompt><input>for path in node.walkpaths(html.a/html.img):</input> 
     
    169169<tty> 
    170170<prompt>&gt;&gt;&gt; </prompt><input>from ll import misc</input> 
    171 <prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parsers</input> 
     171<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parse</input> 
    172172<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    173 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.tree(</input> 
    174 <prompt>... </prompt><input>    parsers.URLSource("http://www.python.org/"),</input> 
    175 <prompt>... </prompt><input>    parsers.Expat(ns=True),</input> 
    176 <prompt>... </prompt><input>    parsers.Instantiate()</input> 
     173<prompt>&gt;&gt;&gt; </prompt><input>node = parse.tree(</input> 
     174<prompt>... </prompt><input>    parse.URLSource("http://www.python.org/"),</input> 
     175<prompt>... </prompt><input>    parse.Expat(ns=True),</input> 
     176<prompt>... </prompt><input>    parse.Instantiate()</input> 
    177177<prompt>... </prompt><input>)</input> 
    178178<prompt>&gt;&gt;&gt; </prompt><input>misc.count(node.walk(html.a))</input> 
     
    189189 
    190190<prog> 
    191 from ll.xist import xsc, parsers 
     191from ll.xist import xsc, parse 
    192192 
    193193def p2p(node, converter): 
     
    197197    return node 
    198198 
    199 node = parsers.tree( 
    200     parsers.URLSource("http://www.python.org/"), 
    201     parsers.Expat(ns=True), 
    202     parsers.Instantiate() 
     199node = parse.tree( 
     200    parse.URLSource("http://www.python.org/"), 
     201    parse.Expat(ns=True), 
     202    parse.Instantiate() 
    203203) 
    204204 
     
    212212<section><h>Converting &html; to &xist; code</h> 
    213213 
    214 <p>The class <pyref module="ll.xist.presenters" class="CodePresenter"><class>ll.xist.presenters.CodePresenter</class></pyref> 
     214<p>The class <pyref module="ll.xist.present" class="CodePresenter"><class>ll.xist.present.CodePresenter</class></pyref> 
    215215makes it possible to output an &xist; tree as usable Python source code:</p> 
    216216 
    217217<tty> 
    218 <prompt>&gt;&gt;&gt;</prompt> <input>from ll.xist import parsers, presenters</input> 
    219 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.tree(</input> 
    220 <prompt>... </prompt><input>    parsers.URLSource("http://www.python.org/"),</input> 
    221 <prompt>... </prompt><input>    parsers.Expat(ns=True),</input> 
    222 <prompt>... </prompt><input>    parsers.Instantiate()</input> 
     218<prompt>&gt;&gt;&gt;</prompt> <input>from ll.xist import parse, present</input> 
     219<prompt>&gt;&gt;&gt; </prompt><input>node = parse.tree(</input> 
     220<prompt>... </prompt><input>    parse.URLSource("http://www.python.org/"),</input> 
     221<prompt>... </prompt><input>    parse.Expat(ns=True),</input> 
     222<prompt>... </prompt><input>    parse.Instantiate()</input> 
    223223<prompt>... </prompt><input>)</input> 
    224 <prompt>&gt;&gt;&gt;</prompt> <input>print presenters.CodePresenter(node)</input> 
     224<prompt>&gt;&gt;&gt;</prompt> <input>print present.CodePresenter(node)</input> 
    225225ll.xist.xsc.Frag( 
    226226    ll.xist.ns.html.html( 
  • docs/XIST_Howto.xml

    r4040 r4052  
    137137<section><h>Generating &xml; trees from &xml; files</h> 
    138138<p>&xml; trees can also be generated by parsing &xml; files. 
    139 For this the module <pyref module="ll.xist.parsers"><mod>ll.xist.parsers</mod></pyref> 
     139For this the module <pyref module="ll.xist.parse"><mod>ll.xist.parse</mod></pyref> 
    140140provides several tools.</p> 
    141141 
     
    143143<example><h>Parsing a string</h> 
    144144<prog><![CDATA[ 
    145 from ll.xist import parsers 
     145from ll.xist import parse 
    146146from ll.xist.ns import html 
    147147 
    148 node = parsers.tree( 
     148node = parse.tree( 
    149149    "<p>Hello <a href='http://www.python.org/'>Python</a> world!</p>", 
    150     parsers.Expat(), 
    151     parsers.NS(html), 
    152     parsers.Instantiate() 
     150    parse.Expat(), 
     151    parse.NS(html), 
     152    parse.Instantiate() 
    153153) 
    154154]]></prog> 
     
    157157<p>For further info about the arguments to the parsing functions, see the 
    158158documentation for 
    159 <pyref module="ll.xist.parsers"><mod>ll.xist.parsers</mod></pyref>.</p> 
     159<pyref module="ll.xist.parse"><mod>ll.xist.parse</mod></pyref>.</p> 
    160160</section> 
    161161</section> 
     
    202202calls 
    203203<pyref module="ll.xist.xsc" class="Node" method="convert"><meth>convert</meth></pyref> 
    204 with a default <pyref module="ll.xist.converters" class="Converter"><var>converter</var></pyref> 
     204with a default <pyref module="ll.xist.xsc" class="Converter"><var>converter</var></pyref> 
    205205argument. We'll come to converters in a minute. 
    206206<pyref module="ll.xist.xsc" class="Node" method="bytes"><meth>bytes</meth></pyref> 
     
    254254 
    255255<prog> 
    256 from ll.xist import converters 
     256from ll.xist import xsc 
    257257from ll.xist.ns import html 
    258258 
    259259node = cool(python()) 
    260 node = node.convert(converters.Converter()) 
     260node = node.convert(xsc.Converter()) 
    261261</prog> 
    262262 
    263263<p>You can pass the following arguments to the 
    264 <pyref module="ll.xist.converters" class="Converter"><class>Converter</class></pyref> constructor:</p> 
     264<pyref module="ll.xist.xsc" class="Converter"><class>Converter</class></pyref> constructor:</p> 
    265265<dl> 
    266266<dt><var>root</var></dt><dd><var>root</var> (which defaults to <lit>None</lit>) is the root &url; 
     
    488488<tty> 
    489489<prompt>&gt;&gt;&gt; </prompt><input>s = '&lt;cool adj="pretty"&gt;&lt;python/&gt;&lt;/cool&gt;'</input> 
    490 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.parsestring(s)</input> 
     490<prompt>&gt;&gt;&gt; </prompt><input>node = parse.parsestring(s)</input> 
    491491/Users/walter/checkouts/LivingLogic.Python.xist/src/ll/xist/xsc.py:2006: \ 
    492492IllegalAttrValueWarning: Attribute value u'pretty' not allowed for __main__:cool.Attrs.adj 
     
    543543<example><h>Assigning a namespace to elements</h> 
    544544<prog> 
    545 from ll.xist import xsc, parsers 
     545from ll.xist import xsc, parse 
    546546from ll.xist.ns import html 
    547547 
     
    577577<example><h>Populating a pool with a <lit>with</lit> block</h> 
    578578<prog> 
    579 from ll.xist import xsc, parsers 
     579from ll.xist import xsc, parse 
    580580from ll.xist.ns import html 
    581581 
     
    604604s = '<cool xmlns="http://xmlns.example.org/foo"><python/></cool>' 
    605605 
    606 node = parsers.tree(s, parsers.Expat(ns=True), pool) 
     606node = parse.tree(s, parse.Expat(ns=True), pool) 
    607607]]></prog> 
    608608</example> 
     
    615615s = '<cool><python/></cool>' 
    616616 
    617 node = parsers.tree(s, parsers.Expat(), parsers.NS("http://xmlns.example.org/foo"), pool) 
     617node = parse.tree(s, parse.Expat(), parse.NS("http://xmlns.example.org/foo"), pool) 
    618618]]></prog> 
    619619</example> 
     
    766766<pyref module="ll.xist.xsc" class="Node" method="publish"><meth>publish</meth></pyref> internally. 
    767767<pyref module="ll.xist.xsc" class="Node" method="publish"><meth>publish</meth></pyref> gets passed 
    768 an instance of <pyref module="ll.xist.publishers" class="Publisher"><class>ll.xist.publisher.Publisher</class></pyref>.</p> 
     768an instance of <pyref module="ll.xist.xsc" class="Publisher"><class>ll.xist.xsc.Publisher</class></pyref>.</p> 
    769769 
    770770<section><h>Specifying an encoding</h> 
  • docs/XIST_Misc.xml

    r3999 r4052  
    1414be prepended to all &url;s that are read during parsing:</p> 
    1515<tty> 
    16 <prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parsers</input> 
     16<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist import parse</input> 
    1717<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    18 <prompt>&gt;&gt;&gt; </prompt><input>node = parsers.parsestring('&lt;img src="eggs.png"/&gt;', base="root:spam/index.html")</input> 
     18<prompt>&gt;&gt;&gt; </prompt><input>node = parse.parsestring('&lt;img src="eggs.png"/&gt;', base="root:spam/index.html")</input> 
    1919<prompt>&gt;&gt;&gt; </prompt><input>print node.bytes()</input> 
    2020&lt;img src="root:spam/eggs.png" /&gt; 
     
    4545for parsing and publishing like this:</p> 
    4646<prog> 
    47 node = parsers.parsefile("spam.htmlxsc", base="root:spam.htmlxsc") 
     47node = parse.parsefile("spam.htmlxsc", base="root:spam.htmlxsc") 
    4848node = node.conv() 
    4949node.write(open("spam.html", "wb"), base="root:spam.html") 
  • docs/XIST_Searching.xml

    r3999 r4052  
    4949<example><h>Using the <meth>walk</meth> method</h> 
    5050<prog> 
    51 from ll.xist import parsers, xfind 
    52 from ll.xist.ns import html 
     51from ll.xist import xsc, parse, xfind 
     52from ll.xist.ns import xml, html 
    5353 
    5454class IsTable(xfind.WalkFilter): 
     
    5959            return (xfind.entercontent,) 
    6060 
    61 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     61node = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    6262 
    6363for node in doc.walknodes(IsTable()): 
     
    8989<example><h>Finding all links on the Python home page</h> 
    9090<prog> 
    91 from ll.xist import xsc, parsers 
    92 from ll.xist.ns import html 
    93  
    94 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     91from ll.xist import xsc, parse 
     92from ll.xist.ns import xml, html 
     93 
     94node = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    9595 
    9696for node in doc.walknodes(xfind.FindTypeAll(html.a)): 
     
    116116<example><h>Finding external links on the Python home page</h> 
    117117<prog> 
    118 from ll.xist import parsers, xfind 
    119 from ll.xist.ns import html 
     118from ll.xist import parse, xfind 
     119from ll.xist.ns import xml, html 
    120120 
    121121class IsExtLink(xfind.WalkFilter): 
     
    125125        return (xfind.entercontent,) 
    126126 
    127 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     127doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    128128 
    129129for node in doc.walknodes(IsExtLink()): 
     
    185185 
    186186<prog> 
    187 from ll.xist import xsc, parsers, xfind 
    188 from ll.xist.ns import html 
    189  
    190 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     187from ll.xist import xsc, parse, xfind 
     188from ll.xist.ns import xml, html 
     189 
     190doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    191191 
    192192for node in doc.walknodes((html.a | html.area) &amp; xfind.hasattr("href")): 
     
    198198 
    199199<prog> 
    200 from ll.xist import xsc, parsers, xfind 
    201 from ll.xist.ns import html 
    202  
    203 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     200from ll.xist import xsc, parse, xfind 
     201from ll.xist.ns import xml, html 
     202 
     203doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    204204 
    205205for node in doc.walknodes(xfind.hasattr("id")): 
     
    234234<example><h>Using &css; selectors as walk filters</h> 
    235235<prog> 
    236 from ll.xist import xsc, parsers, css 
    237 from ll.xist.ns import html 
    238  
    239 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     236from ll.xist import xsc, parse, css 
     237from ll.xist.ns import xml, html 
     238 
     239doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    240240 
    241241for node in doc.walknodes(css.selector("div#menu ul.level-one li > a")): 
  • docs/XIST_Transformation.xml

    r3999 r4052  
    6767 
    6868<prog> 
    69 from ll.xist import xsc, parsers 
     69from ll.xist import xsc, parse 
    7070 
    7171def p2p(node, converter): 
     
    7575    return node 
    7676 
    77 node = parsers.parseurl("http://www.python.org/", tidy=True) 
     77node = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    7878node = node.mapped(p2p) 
    7979node.write(open("parrot_index.html", "wb")) 
  • src/ll/toxicc.py

    r4043 r4052  
    148148transforming it and printing the function body works like this:: 
    149149 
    150     from ll.xist import parsers 
     150    from ll.xist import parse 
    151151    from ll.xist.ns import html, htmlspecials 
    152152    from ll import toxic 
    153153 
    154     node = parsers.parsefile("search.sqlxsc") 
     154    node = parse.tree(parse.FileSource("search.sqlxsc"), parse.Expat(ns=True), parse.Instantiate()) 
    155155    node = node.conv() 
    156156    print toxic.xml2ora(node.string(encoding="us-ascii")).encode("us-ascii") 
     
    161161 
    162162from ll import misc 
    163 from ll.xist import xsc, publishers 
     163from ll.xist import xsc 
    164164 
    165165 
     
    349349    """ 
    350350    if mode == "oracle": 
    351         return  _compile_oracle(string) 
     351        return _compile_oracle(string) 
    352352    elif mode == "sqlserver": 
    353353        return _compile_sqlserver(string) 
  • src/ll/xist/__init__.py

    r3933 r4052  
    3131 
    3232 
    33 __all__ = ["xsc", "publishers", "presenters", "parsers", "converters", "sims", "xnd", "ns"] 
     33__all__ = ["xsc", "present", "parse", "sims", "xnd", "xfind", "ns"] 
  • src/ll/xist/ns/__init__.py

    r3930 r4052  
    2323classes. Calling :meth:`ll.xist.xsc.Node.convert` on these elements might 
    2424convert them to one of these target namespaces (depending on the :attr:`target` 
    25 attribute of the :class:`ll.xist.converters.Converter` object passed around.) 
    26 Some of these namespace modules completely ignore the target and convert to one 
     25attribute of the :class:`ll.xist.xsc.Converter` object passed around.) Some of 
     26these namespace modules completely ignore the target and convert to one 
    2727fixed target namespace (:mod:`ll.xist.ns.html` in most cases). 
    2828""" 
  • src/ll/xist/ns/doc.py

    r4030 r4052  
    1818 
    1919import ll 
    20 from ll.xist import xsc, parsers, sims, xfind 
     20from ll.xist import xsc, parse, sims, xfind 
    2121from ll.xist.ns import html, docbook, fo, specials, xml 
    2222 
     
    7272    elif lformat == "xist": 
    7373        from ll.xist.ns import doc 
    74         node = parsers.tree(parsers.StringSource(text), parsers.SGMLOP(), parsers.NS(doc), parsers.Instantiate(pool=xsc.docpool(), base=base)) 
     74        node = parse.tree(parse.StringSource(text), parse.SGMLOP(), parse.NS(doc), parse.Instantiate(pool=xsc.docpool(), base=base)) 
    7575        if not node[p]: # optimization: one paragraph docstrings don't need a <p> element. 
    7676            node = p(node) 
  • src/ll/xist/ns/htmlspecials.py

    r3972 r4052  
    1717import sys, types, time as time_, string, warnings 
    1818 
    19 from ll.xist import xsc, parsers, sims 
     19from ll.xist import xsc, sims 
    2020from ll.xist.ns import ihtml, html, meta, specials 
    2121 
  • src/ll/xist/ns/specials.py

    r3997 r4052  
    1818 
    1919from ll import url as url_ 
    20 from ll.xist import xsc, parsers, sims 
     20from ll.xist import xsc, parse, sims 
    2121 
    2222 
     
    120120 
    121121    def convert(self, converter): 
    122         e = parsers.parseURL(self[u"src"].forInput()) 
     122        e = parse.tree(parse.URLSource(self[u"src"].forInput()), parse.Expat(ns=True), parse.Instantiate()) 
    123123 
    124124        return e.convert(converter) 
  • src/ll/xist/parse.py

    r4051 r4052  
    2424Parsing a simple HTML string might e.g. look like this:: 
    2525 
    26     >>> from ll.xist import xsc, parsers 
     26    >>> from ll.xist import xsc, parse 
    2727    >>> from ll.xist.ns import html 
    2828    >>> source = "<a href='http://www.python.org/'>Python</a>" 
    29     >>> doc = parsers.tree( 
    30     ...     parsers.StringSource(source) 
    31     ...     parsers.Expat() 
    32     ...     parsers.NS(html) 
    33     ...     parsers.Instantiate(pool=xsc.Pool(html)) 
     29    >>> doc = parse.tree( 
     30    ...     parse.StringSource(source) 
     31    ...     parse.Expat() 
     32    ...     parse.NS(html) 
     33    ...     parse.Instantiate(pool=xsc.Pool(html)) 
    3434    ... ) 
    3535    >>> doc.bytes() 
     
    4040input):: 
    4141 
    42     >>> from ll.xist import parsers 
    43     >>> list(parsers.StringSource("<a href='http://www.python.org/'>Python</a>")) 
     42    >>> from ll.xist import parse 
     43    >>> list(parse.StringSource("<a href='http://www.python.org/'>Python</a>")) 
    4444    [('url', URL('STRING')), 
    4545     ('bytes', "<a href='http://www.python.org/'>Python</a>")] 
     
    4949following code shows an example of an event stream:: 
    5050 
    51     >>> from ll.xist import parsers 
     51    >>> from ll.xist import parse 
    5252    >>> source = "<a href='http://www.python.org/'>Python</a>" 
    53     >>> list(parsers.events(parsers.StringSource(source), parsers.Expat())) 
     53    >>> list(parse.events(parse.StringSource(source), parse.Expat())) 
    5454    [('url', URL('STRING')), 
    5555     ('position', (0, 0)), 
     
    277277        if isinstance(self.data, str): 
    278278            yield (u"bytes", self.data) 
    279         elif  isinstance(self.data, unicode): 
     279        elif isinstance(self.data, unicode): 
    280280            yield (u"unicode", self.data) 
    281281        else: 
     
    306306            if isinstance(data, str): 
    307307                yield (u"bytes", data) 
    308             elif  isinstance(data, unicode): 
     308            elif isinstance(data, unicode): 
    309309                yield (u"unicode", data) 
    310310            else: 
     
    340340                if isinstance(data, str): 
    341341                    yield (u"bytes", data) 
    342                 elif  isinstance(data, unicode): 
     342                elif isinstance(data, unicode): 
    343343                    yield (u"unicode", data) 
    344344                else: 
     
    955955    The output of an :class:`NS` object in the stream looks like this:: 
    956956 
    957         >>> from ll.xist import parsers 
     957        >>> from ll.xist import parse 
    958958        >>> from ll.xist.ns import html 
    959         >>> source = list(parsers.events( 
    960         ...     parsers.StringSource("<a href='http://www.python.org/'>Python</a>"), 
    961         ...     parsers.Expat(), 
    962         ...     parsers.NS(html) 
     959        >>> source = list(parse.events( 
     960        ...     parse.StringSource("<a href='http://www.python.org/'>Python</a>"), 
     961        ...     parse.Expat(), 
     962        ...     parse.NS(html) 
    963963        ... )) 
    964964        [('url', URL('STRING')), 
     
    13011301    into a (unnamespaced) event stream by using libxml2__'s HTML parser:: 
    13021302 
    1303         >>> from ll.xist import parsers 
    1304         >>> list(parsers.events(parsers.URLSource("http://www.yahoo.com/"), parsers.Tidy())) 
     1303        >>> from ll.xist import parse 
     1304        >>> list(parse.events(parse.URLSource("http://www.yahoo.com/"), parse.Tidy())) 
    13051305        [('url', URL('http://de.yahoo.com/?p=us')), 
    13061306         ('position', (3, None)), 
     
    14631463    Example:: 
    14641464 
    1465         >>> from ll.xist import xsc, parsers 
     1465        >>> from ll.xist import xsc, parse 
    14661466        >>> from ll.xist.ns import xml, html, chars 
    1467         >>> doc = parsers.tree( 
    1468         ...     parsers.URLSource("http://www.python.org/"), 
    1469         ...     parsers.Expat(ns=True), 
    1470         ...     parsers.Instantiate(pool=xsc.Pool(xml, html, chars)) 
     1467        >>> doc = parse.tree( 
     1468        ...     parse.URLSource("http://www.python.org/"), 
     1469        ...     parse.Expat(ns=True), 
     1470        ...     parse.Instantiate(pool=xsc.Pool(xml, html, chars)) 
    14711471        ... ) 
    14721472        >>> doc[0] 
     
    15101510    Example:: 
    15111511 
    1512         >>> from ll.xist import xsc, parsers 
     1512        >>> from ll.xist import xsc, parse 
    15131513        >>> from ll.xist.ns import xml, html, chars 
    1514         >>> for (evtype, path) in parsers.itertree( 
    1515         ...     parsers.URLSource("http://www.python.org/"), 
    1516         ...     parsers.Expat(ns=True), 
    1517         ...     parsers.Instantiate(pool=xsc.Pool(xml, html, chars)), 
     1514        >>> for (evtype, path) in parse.itertree( 
     1515        ...     parse.URLSource("http://www.python.org/"), 
     1516        ...     parse.Expat(ns=True), 
     1517        ...     parse.Instantiate(pool=xsc.Pool(xml, html, chars)), 
    15181518        ...     filter=html.a/html.img 
    15191519        ... ): 
  • src/ll/xist/scripts/doc2txt.py

    r4002 r4052  
    2323import sys, getopt 
    2424 
    25 from ll.xist import xsc, parsers, converters 
     25from ll.xist import xsc, parse 
    2626from ll.xist.ns import html, doc, text 
    2727 
     
    3131 
    3232def xsc2txt(infilename, outfilename, title, width): 
    33     e = parsers.tree(parsers.FileSource(infilename) | parsers.SGMLOP() | parsers.NS(doc) | parsers.Instantiate(pool=xsc.docpool())) 
     33    e = parse.tree(parse.FileSource(infilename), parse.SGMLOP(), parse.NS(doc), parse.Instantiate(pool=xsc.docpool())) 
    3434 
    3535    if title is None: 
  • src/ll/xist/scripts/dtd2xsc.py

    r4014 r4052  
    3333 
    3434from ll import url 
    35 from ll.xist import xsc, parsers, xnd 
     35from ll.xist import xsc, parse, xnd 
    3636 
    3737 
     
    152152    for entname in ents: 
    153153        if entname not in ("quot", "apos", "gt", "lt", "amp"): 
    154             ent = parsers.tree(dtd.resolve_ge(entname).value, parsers.Encoder("utf-8"), parsers.SGMLOP(encoding="utf-8"), parsers.NS(), parsers.Instantiate()) 
     154            ent = parse.tree(dtd.resolve_ge(entname).value, parse.Encoder("utf-8"), parse.SGMLOP(encoding="utf-8"), parse.NS(), parse.Instantiate()) 
    155155            ns.content.append(xnd.CharRef(entname, codepoint=ord(unicode(ent[0])[0]))) 
    156156 
  • src/ll/xist/scripts/tld2xsc.py

    r4014 r4052  
    2525 
    2626from ll import url 
    27 from ll.xist import xsc, xfind, parsers, converters 
     27from ll.xist import xsc, xfind, parse 
    2828from ll.xist.ns import tld 
    2929 
     
    3333 
    3434def tld2xnd(stream, shareattrs=None): 
    35     node = parsers.tree(parsers.StreamSource(stream), parsers.Expat(), parsers.NS(tld), parsers.Instantiate()) 
     35    node = parse.tree(parse.StreamSource(stream), parse.Expat(), parse.NS(tld), parse.Instantiate()) 
    3636 
    3737    # get and convert the taglib object 
  • src/ll/xist/xfind.py

    r4004 r4052  
    246246    will be automatically wrapped in an :class:`IsInstanceSelector`):: 
    247247 
    248         >>> from ll.xist import parsers, xfind 
    249         >>> from ll.xist.ns import html 
    250         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     248        >>> from ll.xist import xsc, parse, xfind 
     249        >>> from ll.xist.ns import xml, html 
     250        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    251251        >>> for node in doc.walknodes(html.a): 
    252252        ...     print node.attrs.href, node.attrs.title 
     
    299299    from the specified namespace:: 
    300300 
    301         >>> from ll.xist import parsers, xfind 
    302         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     301        >>> from ll.xist import xsc, parse, xfind 
     302        >>> from ll.xist.ns import xml, html 
     303        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    303304        >>> for node in doc.walknodes(xfind.hasname("img")): 
    304305        ...     print node.bytes() 
     
    362363    a node to a function that expects a walk filter:: 
    363364 
    364         >>> from ll.xist import parsers, xfind 
    365         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     365        >>> from ll.xist import xsc, parse, xfind 
     366        >>> from ll.xist.ns import xml, html 
     367        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    366368        >>> for node in doc.walknodes(doc[0]/xsc.Element): 
    367369        ...     print repr(node) 
     
    395397    Selector that selects all empty elements or fragments:: 
    396398 
    397         >>> from ll.xist import parsers, xfind 
    398         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     399        >>> from ll.xist import xsc, parse, xfind 
     400        >>> from ll.xist.ns import xml, html 
     401        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    399402        >>> for node in doc.walknodes(xfind.empty): 
    400403        ...     print node.bytes() 
     
    424427    Selector that selects all node that are the only child of their parents:: 
    425428 
    426         >>> from ll.xist import parsers, xfind 
    427         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     429        >>> from ll.xist import xsc, parse, xfind 
     430        >>> from ll.xist.ns import xml, html 
     431        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    428432        >>> for node in doc.walknodes(xfind.onlychild & html.a): 
    429433        ...     print node.bytes() 
     
    455459    their siblings:: 
    456460 
    457         >>> from ll.xist import parsers, xfind 
    458         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     461        >>> from ll.xist import xsc, parse, xfind 
     462        >>> from ll.xist.ns import xml, html 
     463        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    459464        >>> for node in doc.walknodes(xfind.onlyoftype & xsc.Element): 
    460465        ...     print repr(node) 
     
    492497    the attribute class can be passed:: 
    493498 
    494         >>> from ll.xist import parsers, xfind 
    495         >>> from ll.xist.ns import html, xml 
    496         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     499        >>> from ll.xist import xsc, parse, xfind 
     500        >>> from ll.xist.ns import xml, html 
     501        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    497502        >>> for node in doc.walknodes(xfind.hasattr(xml.Attrs.lang)): 
    498503        ...     print repr(node) 
     
    546551    containing non-text) will not be considered:: 
    547552 
    548         >>> from ll.xist import parsers, xfind 
    549         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     553        >>> from ll.xist import xsc, parse, xfind 
     554        >>> from ll.xist.ns import xml, html 
     555        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    550556        >>> for node in doc.walknodes(xfind.attrhasvalue("rel", "stylesheet")): 
    551557        ...     print node.attrs.href 
     
    607613    attributes (i.e. those containing non-text) will not be considered:: 
    608614 
    609         >>> from ll.xist import parsers, xfind 
    610         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     615        >>> from ll.xist import xsc, parse, xfind 
     616        >>> from ll.xist.ns import xml, html 
     617        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    611618        >>> for node in doc.walknodes(xfind.attrcontains("rel", "stylesheet")): 
    612619        ...     print node.attrs.rel, node.attrs.href 
     
    671678    (i.e. those containing non-text) will not be considered:: 
    672679 
    673         >>> from ll.xist import parsers, xfind 
    674         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     680        >>> from ll.xist import xsc, parse, xfind 
     681        >>> from ll.xist.ns import xml, html 
     682        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    675683        >>> for node in doc.walknodes(xfind.attrstartswith("class_", "input-")): 
    676684        ...     print repr(node) 
     
    731739    (i.e. those containing non-text) will not be considered:: 
    732740 
    733         >>> from ll.xist import parsers, xfind 
    734         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     741        >>> from ll.xist import xsc, parse, xfind 
     742        >>> from ll.xist.ns import xml, html 
     743        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    735744        >>> for node in doc.walknodes(xfind.attrendswith("href", ".css")): 
    736745        ...     print node.attrs.href 
     
    792801    if the specified values:: 
    793802 
    794         >>> from ll.xist import parsers, xfind 
    795         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     803        >>> from ll.xist import xsc, parse, xfind 
     804        >>> from ll.xist.ns import xml, html 
     805        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    796806        >>> for node in doc.walknodes(xfind.hasid("logo")): 
    797807        ...     print node.bytes() 
     
    823833    one of the specified values:: 
    824834 
    825         >>> from ll.xist import parsers, xfind 
    826         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     835        >>> from ll.xist import xsc, parse, xfind 
     836        >>> from ll.xist.ns import xml, html 
     837        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    827838        >>> for node in doc.walknodes(xfind.hasclass("reference")): 
    828839        ...     print node.bytes() 
     
    857868    Selector that selects all attribute nodes and nodes inside of attributes:: 
    858869 
    859         >>> from ll.xist import parsers, xfind 
    860         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     870        >>> from ll.xist import xsc, parse, xfind 
     871        >>> from ll.xist.ns import xml, html 
     872        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    861873        >>> for node in doc.walknodes(xfind.inattr & xsc.Text): 
    862874        ...     print node.bytes() 
     
    915927    (``/``):: 
    916928 
    917         >>> from ll.xist import parsers, xfind 
    918         >>> from ll.xist.ns import html 
    919         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     929        >>> from ll.xist import xsc, parse, xfind 
     930        >>> from ll.xist.ns import xml, html 
     931        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    920932        >>> for node in doc.walknodes(html.a/html.img): 
    921933        ...     print node.bytes() 
     
    945957    operator (``//``):: 
    946958 
    947         >>> from ll.xist import parsers, xfind 
    948         >>> from ll.xist.ns import html 
    949         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     959        >>> from ll.xist import xsc, parse, xfind 
     960        >>> from ll.xist.ns import xml, html 
     961        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    950962        >>> for node in doc.walknodes(html.div//html.img): 
    951963        ...     print node.bytes() 
     
    978990    element:: 
    979991 
    980         >>> from ll.xist import parsers, xfind 
    981         >>> from ll.xist.ns import html 
    982         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     992        >>> from ll.xist import xsc, parse, xfind 
     993        >>> from ll.xist.ns import xml, html 
     994        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    983995        >>> for node in doc.walknodes(html.h2*html.p/html.a): 
    984996        ...     print node.bytes() 
     
    10241036    link among their preceding siblings):: 
    10251037 
    1026         >>> from ll.xist import parsers, xfind 
    1027         >>> from ll.xist.ns import html 
    1028         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1038        >>> from ll.xist import xsc, parse, xfind 
     1039        >>> from ll.xist.ns import xml, html 
     1040        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    10291041        >>> for node in doc.walknodes(html.a**html.a): 
    10301042        ...     print node.bytes() 
     
    10771089    :class:`OrCombinator` can be created with the binary or operator (``|``):: 
    10781090 
    1079         >>> from ll.xist import parsers, xfind 
    1080         >>> from ll.xist.ns import html 
    1081         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1091        >>> from ll.xist import xsc, parse, xfind 
     1092        >>> from ll.xist.ns import xml, html 
     1093        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    10821094        >>> for node in doc.walknodes(xfind.hasattr("href") | xfind.hasattr("src")): 
    10831095        ...     print node.attrs.href if "href" in node.Attrs else node.attrs.src 
     
    11161128    (``&``):: 
    11171129 
    1118         >>> from ll.xist import parsers, xfind 
    1119         >>> from ll.xist.ns import html 
    1120         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1130        >>> from ll.xist import xsc, parse, xfind 
     1131        >>> from ll.xist.ns import xml, html 
     1132        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    11211133        >>> for node in doc.walknodes(html.input & xfind.hasattr("id")): 
    11221134        ...     print node.bytes() 
     
    11481160    attribute:: 
    11491161 
    1150         >>> from ll.xist import parsers, xfind 
    1151         >>> from ll.xist.ns import html 
    1152         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1162        >>> from ll.xist import xsc, parse, xfind 
     1163        >>> from ll.xist.ns import xml, html 
     1164        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    11531165        >>> for node in doc.walknodes(html.img & ~xfind.hasattr("border")): 
    11541166        ...     print node.bytes() 
     
    11811193    domain:: 
    11821194 
    1183         >>> from ll.xist import parsers, xfind 
    1184         >>> from ll.xist.ns import html 
    1185         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1195        >>> from ll.xist import xsc, parse, xfind 
     1196        >>> from ll.xist.ns import xml, html 
     1197        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    11861198        >>> def foreignlink(path): 
    11871199        ...     return path and isinstance(path[-1], html.a) and not path[-1].attrs.href.asURL().server.endswith(".python.org") 
     
    12451257    explicitly. If no types are passed the type of the node itself is used:: 
    12461258 
    1247         >>> from ll.xist import parsers, xfind 
    1248         >>> from ll.xist.ns import html 
    1249         >>> doc = parsers.parseurl("http://www.python.org", tidy=True) 
     1259        >>> from ll.xist import xsc, parse, xfind 
     1260        >>> from ll.xist.ns import xml, html 
     1261        >>> doc = parse.tree(parse.URLSource("http://www.python.org"), parse.Tidy(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(xml, html))) 
    12501262        >>> for node in doc.walknodes(xfind.nthoftype(0, html.h2)): 
    12511263        ...     print node.bytes() 
  • src/ll/xist/xnd.py

    r3933 r4052  
    1818import sys, keyword 
    1919 
    20 from ll.xist import xsc, parsers, sims 
     20from ll.xist import xsc, sims 
    2121 
    2222 
  • src/ll/xist/xsc.py

    r4000 r4052  
    2222import cssutils 
    2323 
    24 from ll import misc, url as url_ 
     24from ll import misc, url as url_, xml_codec 
    2525 
    2626try: 
     
    386386 
    387387### 
     388### Context containing state during :meth:`convert` calls 
     389### 
     390 
     391class ConverterState(object): 
     392    def __init__(self, node, root, mode, stage, target, lang, makeaction, makeproject): 
     393        self.node = node 
     394        self.root = root 
     395        self.mode = mode 
     396        self.stage = stage 
     397        if target is None: 
     398            from ll.xist.ns import html 
     399            target = html 
     400        self.target = target 
     401        self.lang = lang 
     402        self.makeaction = makeaction 
     403        self.makeproject = makeproject 
     404 
     405 
     406class Converter(object): 
     407    """ 
     408    An instance of this class is passed around in calls to the :meth:`convert` 
     409    method. A :class:`Converter` object can be used when some element needs to 
     410    keep state across a nested :meth:`convert` call. A typical example are nested 
     411    chapter/subchapter elements with automatic numbering. For an example see the 
     412    element :class:`ll.xist.ns.doc.section`. 
     413    """ 
     414 
     415    def __init__(self, node=None, root=None, mode=None, stage=None, target=None, lang=None, makeaction=None, makeproject=None): 
     416        """ 
     417        Create a :class:`Converter`. Arguments are used to initialize the 
     418        :class:`Converter` properties of the same name. 
     419        """ 
     420        self.states = [ ConverterState(node=node, root=root, mode=mode, stage=stage, target=target, lang=lang, makeaction=makeaction, makeproject=makeproject) ] 
     421        self.contexts = {} 
     422 
     423    class node(misc.propclass): 
     424        """ 
     425        The root node for which conversion has been called. This is automatically 
     426        set by the :meth:`conv` method of :class:`Node` objects. 
     427        """ 
     428        def __get__(self): 
     429            return self.states[-1].node 
     430 
     431        def __set__(self, node): 
     432            self.states[-1].node = node 
     433 
     434        def __delete__(self): 
     435            self.states[-1].node = None 
     436 
     437    class root(misc.propclass): 
     438        """ 
     439        The root URL for the conversion. Resolving URLs during the conversion 
     440        process should be done relative to :prop:`root`. 
     441        """ 
     442        def __get__(self): 
     443            return self.states[-1].root 
     444 
     445        def __set__(self, root): 
     446            self.states[-1].root = root 
     447 
     448        def __delete__(self): 
     449            self.states[-1].root = None 
     450 
     451    class mode(misc.propclass): 
     452        """ 
     453        The conversion mode. This corresponds directly to the mode in XSLT. 
     454        The default is :const:`None`. 
     455        """ 
     456        def __get__(self): 
     457            return self.states[-1].mode 
     458 
     459        def __set__(self, mode): 
     460            self.states[-1].mode = mode 
     461 
     462        def __delete__(self): 
     463            self.states[-1].mode = None 
     464 
     465    class stage(misc.propclass): 
     466        """ 
     467        If your conversion is done in multiple steps or stages you can use this 
     468        property to specify in which stage the conversion process currently is. 
     469        The default is :const:`"deliver"`. 
     470        """ 
     471        def __get__(self): 
     472            if self.states[-1].stage is None: 
     473                return "deliver" 
     474            else: 
     475                return self.states[-1].stage 
     476 
     477        def __set__(self, stage): 
     478            self.states[-1].stage = stage 
     479 
     480        def __delete__(self): 
     481            self.states[-1].stage = None 
     482 
     483    class target(misc.propclass): 
     484        """ 
     485        Specifies the conversion target. This must be a namespace module or 
     486        similar object. 
     487        """ 
     488        def __get__(self): 
     489            return self.states[-1].target 
     490 
     491        def __set__(self, target): 
     492            self.states[-1].target = target 
     493 
     494        def __delete__(self): 
     495            self.states[-1].target = None 
     496 
     497    class lang(misc.propclass): 
     498        """ 
     499        The target language. The default is :const:`None`. 
     500        """ 
     501        def __get__(self): 
     502            return self.states[-1].lang 
     503 
     504        def __set__(self, lang): 
     505            self.states[-1].lang = lang 
     506 
     507        def __delete__(self): 
     508            self.states[-1].lang = None 
     509 
     510    class makeaction(misc.propclass): 
     511        """ 
     512        If an XIST conversion is done by an :class:`ll.make.XISTConvertAction` 
     513        this property will hold the action object during that conversion. If 
     514        you're not using the :mod:`ll.make` module you can simply ignore this 
     515        property. The default is :const:`None`. 
     516        """ 
     517        def __get__(self): 
     518            return self.states[-1].makeaction 
     519 
     520        def __set__(self, makeaction): 
     521            self.states[-1].makeaction = makeaction 
     522 
     523        def __delete__(self): 
     524            self.states[-1].makeaction = None 
     525 
     526    class makeproject(misc.propclass): 
     527        """ 
     528        If an XIST conversion is done by an :class:`ll.make.XISTConvertAction` 
     529        this property will hold the :class:`Project` object during that conversion. 
     530        If you're not using the :mod:`ll.make` module you can simply ignore this 
     531        property. 
     532        """ 
     533        def __get__(self): 
     534            return self.states[-1].makeproject 
     535 
     536        def __set__(self, makeproject): 
     537            self.states[-1].makeproject = makeproject 
     538 
     539        def __delete__(self): 
     540            self.states[-1].makeproject = None 
     541 
     542    def push(self, node=None, root=None, mode=None, stage=None, target=None, lang=None, makeaction=None, makeproject=None): 
     543        self.lastnode = None 
     544        if node is None: 
     545            node = self.node 
     546        if root is None: 
     547            root = self.root 
     548        if mode is None: 
     549            mode = self.mode 
     550        if stage is None: 
     551            stage = self.stage 
     552        if target is None: 
     553            target = self.target 
     554        if lang is None: 
     555            lang = self.lang 
     556        if makeaction is None: 
     557            makeaction = self.makeaction 
     558        if makeproject is None: 
     559            makeproject = self.makeproject 
     560        self.states.append(ConverterState(node=node, root=root, mode=mode, stage=stage, target=target, lang=lang, makeaction=makeaction, makeproject=makeproject)) 
     561 
     562    def pop(self): 
     563        if len(self.states) == 1: 
     564            raise IndexError("can't pop last state") 
     565        state = self.states.pop() 
     566        self.lastnode = state.node 
     567        return state 
     568 
     569    def __getitem__(self, obj): 
     570        """ 
     571        Return a context object for :var:`obj`, which should be an 
     572        :class:`ll.xist.xsc.Node` instance or subclass. Each of these classes 
     573        that defines its own :class:`Context` class gets a unique instance of 
     574        this class. This instance will be created on the first access and the 
     575        element can store information there that needs to be available across 
     576        calls to :meth:`convert`. 
     577        """ 
     578        contextclass = obj.Context 
     579        # don't use :meth:`setdefault`, as constructing the context object might involve some overhead 
     580        try: 
     581            return self.contexts[contextclass] 
     582        except KeyError: 
     583            context = contextclass() 
     584            self.contexts[contextclass] = context 
     585            return context 
     586 
     587 
     588### 
     589### Publisher for serializing XML trees to strings 
     590### 
     591 
     592class Publisher(object): 
     593    """ 
     594    A :class:`Publisher` object is used for serializing an XIST tree into a byte 
     595    sequence. 
     596    """ 
     597 
     598    def __init__(self, encoding=None, xhtml=1, validate=True, prefixes={}, prefixdefault=False, hidexmlns=(), showxmlns=()): 
     599        """ 
     600        Create a publisher. Arguments have the following meaning: 
     601 
     602        :var:`encoding` : string or :const:`None` 
     603            Specifies the encoding to be used for the byte sequence. If 
     604            :const:`None` is used the encoding in the XML declaration will be used. 
     605            If there is no XML declaration, UTF-8 will be used. 
     606 
     607        :var:`xhtml` : int 
     608            With the parameter :var:`xhtml` you can specify if you want HTML 
     609            output: 
     610 
     611            HTML (``xhtml==0``) 
     612                Elements with a empty content model will be published as ``<foo>``. 
     613 
     614            HTML browser compatible XML (``xhtml==1``) 
     615                Elements with an empty content model will be published as ``<foo />`` 
     616                and others that just happen to be empty as ``<foo></foo>``. This is 
     617                the default. 
     618 
     619            Pure XML (``xhtml==2``) 
     620                All empty elements will be published as ``<foo/>``. 
     621 
     622        :var:`validate` : bool 
     623            Specifies whether validation should be done before publishing. 
     624 
     625        :var:`prefixes` : mapping 
     626            A dictionary that specifies which namespace prefixes should be used 
     627            for publishing. Keys in the dictionary are either namespace names or 
     628            objects that have an ``xmlns`` attribute which is the namespace name. 
     629            Values can be: 
     630 
     631            :const:`False` 
     632                Treat elements in this namespace as if they are not in any 
     633                namespace (if global attributes from this namespace are encountered, 
     634                a non-empty prefix will be used nonetheless). 
     635 
     636            :const:`None` 
     637                Treat the namespace as the default namespaces (i.e. use unprefixed 
     638                element names). Global attributes will again result in a non-empty 
     639                prefix. 
     640 
     641            :const:`True` 
     642                The publisher uses a unique non-empty prefix for this namespace. 
     643 
     644            A string 
     645                Use this prefix for the namespace. 
     646 
     647        :var:`prefixdefault` : string or :const:`None` 
     648            If an element or attribute is encountered whose namespace name is not 
     649            in :var:`prefixes` :var:`prefixdefault` is used as the fallback. 
     650 
     651        :var:`hidexmlns` : list or set 
     652            :var:`hidexmlns` can be a list or set that contains namespace names 
     653            for which no ``xmlns`` attributes should be published. (This can be 
     654            used to hide the namespace declarations for e.g. Java taglibs.) 
     655 
     656        :var:`showxmlns` : list or set 
     657            :var:`showxmlns` can be a list or set that contains namespace names 
     658            for which ``xmlns`` attributes *will* be published, even if there are 
     659            no elements from this namespace in the tree. 
     660        """ 
     661        self.base = None 
     662        self.encoding = encoding 
     663        self.encoder = None 
     664        self.xhtml = xhtml 
     665        self.validate = validate 
     666        self.prefixes = dict((nsname(xmlns), prefix) for (xmlns, prefix) in prefixes.iteritems()) 
     667        self.prefixdefault = prefixdefault 
     668        self.hidexmlns = set(nsname(xmlns) for xmlns in hidexmlns) 
     669        self.showxmlns = set(nsname(xmlns) for xmlns in showxmlns) 
     670        self._ns2prefix = {} 
     671        self._prefix2ns = {} 
     672 
     673    def encode(self, text): 
     674        """ 
     675        Encode :var:`text` with the encoding and error handling currently active 
     676        and return the resulting byte string. 
     677        """ 
     678        return self.encoder.encode(text) 
     679 
     680    def encodetext(self, text): 
     681        """ 
     682        Encode :var:`test` as text data. :var:`text` must be a :class:`unicode` 
     683        object. The publisher will apply the configured encoding, error handling 
     684        and the current text filter (which escapes characters that can't appear 
     685        in text data (like ``<`` etc.)) and returns the resulting :class:`str` 
     686        object. 
     687        """ 
     688        self.encoder.errors = self.__errors[-1] 
     689        result = self.encoder.encode(self.__textfilters[-1](text)) 
     690        self.encoder.errors = "strict" 
     691        return result 
     692 
     693    def pushtextfilter(self, filter): 
     694        """ 
     695        Pushes a new text filter function ontp the text filter stack. This 
     696        function is responsible for escaping characters that can't appear in text 
     697        data (like ``<``)). This is used to switch on escaping of ``"`` inside 
     698        attribute values. 
     699        """ 
     700        self.__textfilters.append(filter) 
     701 
     702    def poptextfilter(self): 
     703        """ 
     704        Pops the current text filter function from the stack. 
     705        """ 
     706        self.__textfilters.pop() 
     707 
     708    def pusherrors(self, errors): 
     709        """ 
     710        Pushes a new error handling scheme onto the error handling stack. 
     711        """ 
     712        self.__errors.append(errors) 
     713 
     714    def poperrors(self): 
     715        """ 
     716        Pop the current error handling scheme from the error handling stack. 
     717        """ 
     718        self.__errors.pop() 
     719 
     720    def _newprefix(self): 
     721        prefix = "ns" 
     722        suffix = 2 
     723        while True: 
     724            if prefix not in self._prefix2ns: 
     725                return prefix 
     726            prefix = "ns{0}".format(suffix) 
     727            suffix += 1 
     728 
     729    def getencoding(self): 
     730        """ 
     731        Return the encoding currently in effect. 
     732        """ 
     733        if self.encoding is not None: 
     734            # The encoding has been prescribed, so this *will* be used. 
     735            return self.encoding 
     736        elif self.encoder is not None: 
     737            # The encoding is determined by the XML declaration in the output, 
     738            # so use that if it has been determined already. If the encoder hasn't 
     739            # determined the encoding yet (e.g. because nothing has been output 
     740            # yet) use utf-8 (which will be what the encoder eventually will decide 
     741            # to use too). Note that this will not work if nothing has been output 
     742            # yet, but later an XML declaration (using a different encoding) will 
     743            # be output, but this shouldn't happen anyway. 
     744            return self.encoder.encoding or "utf-8" 
     745        return "utf-8" 
     746 
     747    def getnamespaceprefix(self, xmlns): 
     748        """ 
     749        Return (and register) a namespace prefix for the namespace name 
     750        :var:`xmlns`. This honors the namespace configuration from ``self.prefixes`` 
     751        and ``self.prefixdefault``. Furthermore the same prefix will be returned 
     752        from now on (except when the empty prefix becomes invalid once global 
     753        attributes are encountered) 
     754        """ 
     755        if xmlns is None: 
     756            return None 
     757 
     758        if xmlns == xml_xmlns: # We don't need a namespace mapping for the xml namespace 
     759            prefix = "xml" 
     760        else: 
     761            try: 
     762                prefix = self._ns2prefix[xmlns] 
     763            except KeyError: # A namespace we haven't encountered yet 
     764                prefix = self.prefixes.get(xmlns, self.prefixdefault) 
     765                if prefix is True: 
     766                    prefix = self._newprefix() 
     767                if prefix is not False: 
     768                    try: 
     769                        oldxmlns = self._prefix2ns[prefix] 
     770                    except KeyError: 
     771                        pass 
     772                    else: 
     773                        # If this prefix has already been used for another namespace, we need a new one 
     774                        if oldxmlns != xmlns: 
     775                            prefix = self._newprefix() 
     776                    self._ns2prefix[xmlns] = prefix 
     777                    self._prefix2ns[prefix] = xmlns 
     778        return prefix 
     779 
     780    def getobjectprefix(self, object): 
     781        """ 
     782        Get and register a namespace prefix for the namespace :var:`object` lives 
     783        in (specified by the :attr:`xmlns` attribute of :var:`object`). Similar 
     784        to :meth:`getnamespaceprefix` this honors the namespace configuration from 
     785        ``self.prefixes`` and ``self.prefixdefault`` (except when a global 
     786        attribute requires a non-empty prefix). 
     787        """ 
     788        xmlns = getattr(object, "xmlns") 
     789        if xmlns is None: 
     790            return None 
     791 
     792        if xmlns == xml_xmlns: # We don't need a namespace mapping for the xml namespace 
     793            prefix = "xml" 
     794        else: 
     795            emptyok = isinstance(object, Element) # If it's e.g. a procinst assume we need a non-empty prefix 
     796            try: 
     797                prefix = self._ns2prefix[xmlns] 
     798            except KeyError: # A namespace we haven't encountered yet 
     799                prefix = self.prefixes.get(xmlns, self.prefixdefault) 
     800                # global attributes always require prefixed names 
     801                if prefix is True or ((prefix is None or prefix is False) and not emptyok): 
     802                    prefix = self._newprefix() 
     803                if prefix is not False: 
     804                    try: 
     805                        oldxmlns = self._prefix2ns[prefix] 
     806                    except KeyError: 
     807                        pass 
     808                    else: 
     809                        # If this prefix has already been used for another namespace, we need a new one 
     810                        if oldxmlns != xmlns: 
     811                            prefix = self._newprefix() 
     812                    self._ns2prefix[xmlns] = prefix 
     813                    self._prefix2ns[prefix] = xmlns 
     814            else: 
     815                # We can't use the unprefixed names for global attributes 
     816                if (prefix is None or prefix is False) and not emptyok: 
     817                    # Use a new one 
     818                    prefix = self._newprefix() 
     819                    self._ns2prefix[xmlns] = prefix 
     820                    self._prefix2ns[prefix] = xmlns 
     821        return prefix 
     822 
     823    def iterbytes(self, node, base=None): 
     824        """ 
     825        Output the node :var:`node`. This method is a generator that will yield 
     826        the resulting XML byte sequence in fragments. 
     827        """ 
     828        self._ns2prefix.clear() 
     829        self._prefix2ns.clear() 
     830        # iterate through every node in the tree 
     831        for n in node.walknodes(Node): 
     832            self.getobjectprefix(n) 
     833        # Add the prefixes forced by ``self.showxmlns`` 
     834        for xmlns in self.showxmlns: 
     835            self.getnamespaceprefix(xmlns) 
     836 
     837        # Do we have to publish xmlns attributes? 
     838        self._publishxmlns = False 
     839        if self._ns2prefix: 
     840            # Determine if we have multiple roots 
     841            if isinstance(node, Frag): 
     842                count = 0 
     843                for child in node: 
     844                    if isinstance(node, Element) and node.xmlns not in self.hidexmlns: 
     845                        count += 1 
     846                if count > 1: 
     847                    raise MultipleRootsError() 
     848            self._publishxmlns = True 
     849 
     850        self.inattr = 0 
     851        self.__textfilters = [ misc.xmlescape_text ] 
     852 
     853        self.__errors = [ "xmlcharrefreplace" ] 
     854 
     855        self.base = url_.URL(base) 
     856        self.node = node 
     857 
     858        self.encoder = codecs.getincrementalencoder("xml")(encoding=self.encoding) 
     859 
     860        for part in self.node.publish(self): 
     861            yield part 
     862        rest = self.encoder.encode(u"", True) # finish encoding and flush buffers 
     863        if rest: 
     864            yield rest 
     865 
     866        self.inattr = 0 
     867        self.__textfilters = [ misc.xmlescape_text ] 
     868 
     869        self.__errors = [ "xmlcharrefreplace" ] 
     870 
     871        self.publishxmlns = False 
     872        self._ns2prefix.clear() 
     873        self._prefix2ns.clear() 
     874 
     875        self.encoder = None 
     876 
     877    def bytes(self, node, base=None): 
     878        """ 
     879        Return a byte string in XML format for the XIST node :var:`node`. 
     880        """ 
     881        return "".join(self.iterbytes(node, base)) 
     882 
     883    def iterstring(self, node, base=None): 
     884        """ 
     885        A generator that will produce a serialized string of :var:`node`. 
     886        """ 
     887        decoder = codecs.getincrementaldecoder("xml")(encoding=self.encoding) 
     888        for part in self.iterbytes(node, base): 
     889            part = decoder.decode(part, False) 
     890            if part: 
     891                yield part 
     892        part = decoder.decode("", True) 
     893        if part: 
     894            yield part 
     895 
     896    def string(self, node, base=None): 
     897        """ 
     898        Return a unicode string for :var:`node`. 
     899        """ 
     900        decoder = codecs.getdecoder("xml") 
     901        result = self.bytes(node, base) 
     902        return decoder(result, encoding=self.encoding)[0] 
     903 
     904    def write(self, stream, node, base=None): 
     905        """ 
     906        Write :var:`node` to the file-like object :var:`stream` (which must 
     907        provide a :meth:`write` method). 
     908        """ 
     909        for part in self.iterbytes(node, base): 
     910            stream.write(part) 
     911 
     912 
     913### 
    388914### The DOM classes 
    389915### 
     
    5571083        """ 
    5581084        if converter is None: 
    559             converter = converters.Converter(node=self, root=root, mode=mode, stage=stage, target=target, lang=lang, makeaction=makeaction, makeproject=makeproject) 
     1085            converter = Converter(node=self, root=root, mode=mode, stage=stage, target=target, lang=lang, makeaction=makeaction, makeproject=makeproject) 
    5601086            return self.convert(converter) 
    5611087        else: 
     
    6551181        """ 
    6561182        Generate unicode strings for the node. :var:`publisher` must be an 
    657         instance of :class:`ll.xist.publishers.Publisher`. 
     1183        instance of :class:`ll.xist.xsc.Publisher`. 
    6581184 
    6591185        The encoding and xhtml specification are taken from the :var:`publisher`. 
     
    6641190        A generator that will produce this node as a serialized byte string. 
    6651191 
    666         For the possible parameters see the :class:`ll.xist.publishers.Publisher` 
     1192        For the possible parameters see the :class:`ll.xist.xsc.Publisher` 
    6671193        constructor. 
    6681194        """ 
    6691195        if publisher is None: 
    670             publisher = publishers.Publisher(**publishargs) 
     1196            publisher = Publisher(**publishargs) 
    6711197 
    6721198        return publisher.iterbytes(self, base) # return a generator-iterator 
     
    6761202        Return :var:`self` as a serialized byte string. 
    6771203 
    678         For the possible parameters see the :class:`ll.xist.publishers.Publisher` 
     1204        For the possible parameters see the :class:`ll.xist.xsc.Publisher` 
    6791205        constructor. 
    6801206        """ 
    6811207        if publisher is None: 
    682             publisher = publishers.Publisher(**publishargs) 
     1208            publisher = Publisher(**publishargs) 
    6831209 
    6841210        return publisher.bytes(self, base) 
     
    6881214        A generator that will produce a serialized byte string of :var:`self`. 
    6891215 
    690         For the possible parameters see the :class:`ll.xist.publishers.Publisher` 
     1216        For the possible parameters see the :class:`ll.xist.xsc.Publisher` 
    6911217        constructor. 
    6921218        """ 
    6931219        if publisher is None: 
    694             publisher = publishers.Publisher(**publishargs) 
     1220            publisher = Publisher(**publishargs) 
    6951221 
    6961222        return publisher.iterstring(self, base) # return a generator-iterator 
     
    7001226        Return a serialized unicode string for :var:`self`. 
    7011227 
    702         For the possible parameters see the :class:`ll.xist.publishers.Publisher` 
     1228        For the possible parameters see the :class:`ll.xist.xsc.Publisher` 
    7031229        constructor. 
    7041230        """ 
    7051231        if publisher is None: 
    706             publisher = publishers.Publisher(**publishargs) 
     1232            publisher = Publisher(**publishargs) 
    7071233        return publisher.string(self, base) 
    7081234 
     
    7121238        a :meth:`write` method). 
    7131239 
    714         For the rest of the parameters see the :class:`ll.xist.publishers.Publisher` 
     1240        For the rest of the parameters see the :class:`ll.xist.xsc.Publisher` 
    7151241        constructor. 
    7161242        """ 
    7171243        if publisher is None: 
    718             publisher = publishers.Publisher(**publishargs) 
     1244            publisher = Publisher(**publishargs) 
    7191245        return publisher.write(stream, self, base) 
    7201246 
     
    8081334        """ 
    8091335        if converter is None: 
    810             converter = converters.Converter(**converterargs) 
     1336            converter = Converter(**converterargs) 
    8111337        node = function(self, converter) 
    8121338        assert isinstance(node, Node), "the mapped method returned the illegal object {0!r} (type {1!r}) when mapping {2!r}".format(node, type(node), self) 
     
    14371963    def mapped(self, function, converter=None, **converterargs): 
    14381964        if converter is None: 
    1439             converter = converters.Converter(**converterargs) 
     1965            converter = Converter(**converterargs) 
    14401966        node = function(self, converter) 
    14411967        assert isinstance(node, Node), "the mapped method returned the illegal object {0!r} (type {1!r}) when mapping {2!r}".format(node, type(node), self) 
     
    29183444    def mapped(self, function, converter=None, **converterargs): 
    29193445        if converter is None: 
    2920             converter = converters.Converter(**converterargs) 
     3446            converter = Converter(**converterargs) 
    29213447        node = function(self, converter) 
    29223448        assert isinstance(node, Node), "the mapped method returned the illegal object {0!r} (type {1!r}) when mapping {2!r}".format(node, type(node), self) 
     
    31003626    def upper(self): 
    31013627        return Text(self.content.upper()) 
    3102  
    3103  
    3104 import publishers, converters 
    31053628 
    31063629 
  • src/ll/xml_codec.py

    r3933 r4052  
    100100    def decode(self, input, final=False): 
    101101        # We're doing basically the same as a ``BufferedIncrementalDecoder``, 
    102         # but since  the buffer is only relevant until the encoding has been detected 
     102        # but since the buffer is only relevant until the encoding has been detected 
    103103        # (in which case the buffer of the underlying codec might kick in), 
    104104        # we're implementing buffering ourselves to avoid some overhead. 
  • test/test_xist_basics.py

    r4041 r4052  
    1717 
    1818from ll import url 
    19 from ll.xist import xsc, parsers, css, presenters, converters, sims, xnd, xfind 
     19from ll.xist import xsc, css, present, sims, xnd, xfind 
    2020from ll.xist.ns import wml, ihtml, html, chars, abbr, specials, htmlspecials, meta, form, php, xml, tld, docbook 
    2121 
     
    2424 
    2525# set to something ASCII, so presenters work, even if the system default encoding is ascii 
    26 presenters.reprtab = "  " 
     26present.reprtab = "  " 
    2727 
    2828 
     
    275275    node = common.createfrag() 
    276276    node.conv() 
    277     node.conv(converters.Converter()) 
    278     node.mapped(mappedmapper, converters.Converter()) 
     277    node.conv(xsc.Converter()) 
     278    node.mapped(mappedmapper, xsc.Converter()) 
    279279 
    280280 
    281281def test_repr(): 
    282282    tests = common.allnodes() 
    283     allpresenters = [c for c in presenters.__dict__.itervalues() if isinstance(c, type) and c is not presenters.Presenter and issubclass(c, presenters.Presenter)] 
     283    allpresenters = [c for c in present.__dict__.itervalues() if isinstance(c, type) and c is not present.Presenter and issubclass(c, present.Presenter)] 
    284284    for node in tests: 
    285285        repr(node) 
  • test/test_xist_css.py

    r4041 r4052  
    1111 
    1212from ll import url 
    13 from ll.xist import xsc, css, parsers 
     13from ll.xist import xsc, css, parse 
    1414from ll.xist.ns import html, specials 
    1515 
     
    239239def test_comments(): 
    240240    d = b'<html><head><style type="text/css">/*nix*/ p{/*nix*/ color: red;}</style></head><body><p>gurk</p></body></html>' 
    241     node = parsers.tree(d, parsers.Expat(), parsers.NS(html), parsers.Instantiate()) 
     241    node = parse.tree(d, parse.Expat(), parse.NS(html), parse.Instantiate()) 
    242242    css.applystylesheets(node) 
    243243    assert unicode(node.walknodes(html.p)[0].attrs.style) == u"color: red;" 
  • test/test_xist_htmlspecials.py

    r4041 r4052  
    1010 
    1111 
    12 from ll.xist import converters 
     12from ll.xist import xsc 
    1313from ll.xist.ns import htmlspecials 
    1414 
     
    2121    assert unicode(e.conv().attrs.src) == u"root:nix.gif" 
    2222 
    23     c = converters.Converter() 
     23    c = xsc.Converter() 
    2424    c[htmlspecials.pixel].src = u"root:spam.gif" 
    2525    e = htmlspecials.pixel() 
  • test/test_xist_parse.py

    r4047 r4052  
    1111 
    1212import cStringIO 
    13  
    1413from xml.etree import cElementTree 
    15 from xml.parsers import expat 
    16  
    17 import py.test 
    18  
    1914from xml import sax 
    2015from xml.parsers import expat 
    2116 
     17import py.test 
     18 
    2219from ll import url 
    23 from ll.xist import xsc, parsers, xfind 
     20from ll.xist import xsc, parse, xfind 
    2421from ll.xist.ns import xml, chars, html, ihtml, specials, ruby, doc 
    2522 
     
    4744 
    4845    def check(*pipeline): 
    49         node = parsers.tree(*pipeline) 
     46        node = parse.tree(*pipeline) 
    5047        node = node.walknodes(a)[0] 
    5148        assert unicode(node) == t 
     
    5552    pool = xsc.Pool(a) 
    5653 
    57     yield check, b, parsers.Expat(), parsers.NS(a.xmlns), parsers.Instantiate(pool) 
    58     yield check, s, parsers.Encoder(encoding="utf-8"), parsers.Expat(), parsers.NS(a.xmlns), parsers.Instantiate(pool) 
    59     yield check, parsers.IterSource(b), parsers.Expat(), parsers.NS(a.xmlns), parsers.Instantiate(pool) # parse byte by byte 
    60     yield check, parsers.StreamSource(cStringIO.StringIO(b), bufsize=1), parsers.Expat(), parsers.NS(a.xmlns), parsers.Instantiate(pool) 
    61     yield check, parsers.ETreeSource(cElementTree.fromstring(b), defaultxmlns=a.xmlns), parsers.Instantiate(pool) 
     54    yield check, b, parse.Expat(), parse.NS(a.xmlns), parse.Instantiate(pool) 
     55    yield check, s, parse.Encoder(encoding="utf-8"), parse.Expat(), parse.NS(a.xmlns), parse.Instantiate(pool) 
     56    yield check, parse.IterSource(b), parse.Expat(), parse.NS(a.xmlns), parse.Instantiate(pool) # parse byte by byte 
     57    yield check, parse.StreamSource(cStringIO.StringIO(b), bufsize=1), parse.Expat(), parse.NS(a.xmlns), parse.Instantiate(pool) 
     58    yield check, parse.ETreeSource(cElementTree.fromstring(b), defaultxmlns=a.xmlns), parse.Instantiate(pool) 
    6259 
    6360 
    6461def test_parselocationsgmlop(): 
    6562    # sgmlop doesn't provide any location info, so check only the URL 
    66     node = parsers.tree(b"<z>gurk&amp;hurz&#42;hinz&#x666;hunz</z>", parsers.SGMLOP(), parsers.NS(doc), parsers.Instantiate()) 
     63    node = parse.tree(b"<z>gurk&amp;hurz&#42;hinz&#x666;hunz</z>", parse.SGMLOP(), parse.NS(doc), parse.Instantiate()) 
    6764    assert len(node) == 1 
    6865    assert len(node[0]) == 1 
     
    7471def test_parselocationexpat(): 
    7572    # Check that expat gets the location info right 
    76     node = parsers.tree(b"<z>gurk&amp;hurz&#42;hinz&#x666;hunz</z>", parsers.Expat(), parsers.NS(doc), parsers.Instantiate()) 
     73    node = parse.tree(b"<z>gurk&amp;hurz&#42;hinz&#x666;hunz</z>", parse.Expat(), parse.NS(doc), parse.Instantiate()) 
    7774    assert len(node) == 1 
    7875    assert len(node[0]) == 1 
     
    9895        ) 
    9996    ) 
    100     node = parsers.tree(xml, parsers.Expat(), parsers.NS(x=ihtml), parsers.Instantiate()) 
     97    node = parse.tree(xml, parse.Expat(), parse.NS(x=ihtml), parse.Instantiate()) 
    10198    node = node.walknodes(xsc.Element)[0].compact() # get rid of the Frag and whitespace 
    10299    assert node == check 
     
    104101 
    105102def test_parseurls(): 
    106     # Check proper URL handling when parsing URLAttr or StyleAttr attributes 
    107     node = parsers.tree(b'<a href="4.html" style="background-image: url(3.gif);"/>', parsers.Expat(), parsers.NS(html), parsers.Instantiate(base="root:1/2.html")) 
     103    # Check proper URL handling when parsing ``URLAttr`` or ``StyleAttr`` attributes 
     104    node = parse.tree(b'<a href="4.html" style="background-image: url(3.gif);"/>', parse.Expat(), parse.NS(html), parse.Instantiate(base="root:1/2.html")) 
    108105    assert str(node[0]["style"]) == "background-image: url(root:1/3.gif)" 
    109106    assert node[0]["style"].urls() == [url.URL("root:1/3.gif")] 
     
    123120                    required = True 
    124121 
    125         node = parsers.tree(b'<Test required="foo"/>', parsers.Expat(), parsers.NS(xmlns), parsers.Instantiate()) 
     122        node = parse.tree(b'<Test required="foo"/>', parse.Expat(), parse.NS(xmlns), parse.Instantiate()) 
    126123        assert str(node[0]["required"]) == "foo" 
    127124 
    128         parsers.tree(b'<Test/>', parsers.Expat(), parsers.NS(xmlns), parsers.Instantiate()) 
     125        parse.tree(b'<Test/>', parse.Expat(), parse.NS(xmlns), parse.Instantiate()) 
    129126        w = recwarn.pop(xsc.RequiredAttrMissingWarning) 
    130127 
    131     py.test.raises(xsc.IllegalElementError, parsers.tree, b'<Test required="foo"/>', parsers.Expat(), parsers.NS(xmlns), parsers.Instantiate()) 
     128    py.test.raises(xsc.IllegalElementError, parse.tree, b'<Test required="foo"/>', parse.Expat(), parse.NS(xmlns), parse.Instantiate()) 
    132129 
    133130 
     
    143140                    values = ("foo", "bar") 
    144141 
    145         node = parsers.tree(b'<Test withvalues="bar"/>', parsers.Expat(), parsers.NS(xmlns), parsers.Instantiate()) 
     142        node = parse.tree(b'<Test withvalues="bar"/>', parse.Expat(), parse.NS(xmlns), parse.Instantiate()) 
    146143        assert str(node[0]["withvalues"]) == "bar" 
    147144 
    148         parsers.tree(b'<Test withvalues="baz"/>', parsers.Expat(), parsers.NS(xmlns), parsers.Instantiate()) 
     145        parse.tree(b'<Test withvalues="baz"/>', parse.Expat(), parse.NS(xmlns), parse.Instantiate()) 
    149146        w = recwarn.pop(xsc.IllegalAttrValueWarning) 
    150147 
     
    154151        for i in xrange(3): 
    155152            try: 
    156                 parsers.tree(b"<>gurk", parser, parsers.NS(html), parsers.Instantiate()) 
     153                parse.tree(b"<>gurk", parser, parse.NS(html), parse.Instantiate()) 
    157154            except Exception: 
    158155                pass 
    159156            for j in xrange(3): 
    160                 assert parsers.tree(b"<a>gurk</a>", parser, parsers.NS(html), parsers.Instantiate()).bytes() == "<a>gurk</a>" 
     157                assert parse.tree(b"<a>gurk</a>", parser, parse.NS(html), parse.Instantiate()).bytes() == "<a>gurk</a>" 
    161158 
    162159    # A Parser instance should be able to parse multiple XML sources, even when some of the parse calls fail 
    163     for parser in (parsers.SGMLOP, parsers.Expat): 
     160    for parser in (parse.SGMLOP, parse.Expat): 
    164161        yield check, parser() 
    165162 
     
    167164def test_parseentities_sgmlop(): 
    168165    def check(input, output): 
    169         node = parsers.tree(b"""<a title="{0}">{0}</a>""".format(input), parsers.SGMLOP(), parsers.NS(a.xmlns), parsers.Instantiate(pool=xsc.Pool(a, bar, foo, chars))) 
     166        node = parse.tree(b"""<a title="{0}">{0}</a>""".format(input), parse.SGMLOP(), parse.NS(a.xmlns), parse.Instantiate(pool=xsc.Pool(a, bar, foo, chars))) 
    170167        node = node.walknodes(a)[0] 
    171168        assert unicode(node) == output 
     
    191188def test_parseattr_sgmlop(): 
    192189    def check(input, output): 
    193         node = parsers.tree(input, parsers.SGMLOP(), parsers.NS(a), parsers.Instantiate()) 
     190        node = parse.tree(input, parse.SGMLOP(), parse.NS(a), parse.Instantiate()) 
    194191        node = node.walknodes(a)[0] 
    195192        assert unicode(node.attrs.title) == output 
     
    206203def test_parsestringurl(): 
    207204    # Base URLs should end up in the location info of the resulting XML tree 
    208     node = parsers.tree(b"gurk", parsers.SGMLOP(), parsers.NS(), parsers.Instantiate()) 
     205    node = parse.tree(b"gurk", parse.SGMLOP(), parse.NS(), parse.Instantiate()) 
    209206    assert str(node[0].startloc.url) == "STRING" 
    210207 
    211     node = parsers.tree(parsers.StringSource(b"gurk", url="root:gurk.xmlxsc"), parsers.SGMLOP(), parsers.NS(), parsers.Instantiate()) 
     208    node = parse.tree(parse.StringSource(b"gurk", url="root:gurk.xmlxsc"), parse.SGMLOP(), parse.NS(), parse.Instantiate()) 
    212209    assert str(node[0].startloc.url) == "root:gurk.xmlxsc" 
    213210 
     
    215212def test_xmlns(): 
    216213    s = b"<z xmlns={0!r}><rb xmlns={1!r}/><z/></z>".format(doc.xmlns, ruby.xmlns) 
    217     e = parsers.tree(s, parsers.Expat(ns=True), parsers.Instantiate(pool=xsc.Pool(doc, ruby))) 
     214    e = parse.tree(s, parse.Expat(ns=True), parse.Instantiate(pool=xsc.Pool(doc, ruby))) 
    218215 
    219216    assert e[0].xmlns == doc.xmlns 
     
    221218 
    222219    s = b"<a xmlns={0!r}><a xmlns={1!r}/></a>".format(html.xmlns, ihtml.xmlns) 
    223     e = parsers.tree(s, parsers.Expat(ns=True), parsers.Instantiate(pool=xsc.Pool(html, ihtml))) 
     220    e = parse.tree(s, parse.Expat(ns=True), parse.Instantiate(pool=xsc.Pool(html, ihtml))) 
    224221    assert isinstance(e[0], html.a) 
    225222    assert isinstance(e[0][0], ihtml.a) 
    226223 
    227224    s = b"<a><a xmlns={0!r}/></a>".format(ihtml.xmlns) 
    228     py.test.raises(xsc.IllegalElementError, parsers.tree, s, parsers.Expat(), parsers.NS(html), parsers.Instantiate(pool=xsc.Pool(ihtml))) 
    229     e = parsers.tree(s, parsers.Expat(), parsers.NS(html), parsers.Instantiate(pool=xsc.Pool(html, ihtml))) 
     225    py.test.raises(xsc.IllegalElementError, parse.tree, s, parse.Expat(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(ihtml))) 
     226    e = parse.tree(s, parse.Expat(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(html, ihtml))) 
    230227    assert isinstance(e[0], html.a) 
    231228    assert isinstance(e[0][0], ihtml.a) 
    232229 
    233230    s = b"<z xmlns={0!r}/>".format(doc.xmlns) 
    234     e = parsers.tree(s, parsers.Expat(ns=True), parsers.Instantiate(pool=xsc.Pool(doc.z))) 
     231    e = parse.tree(s, parse.Expat(ns=True), parse.Instantiate(pool=xsc.Pool(doc.z))) 
    235232    assert isinstance(e[0], doc.z) 
    236     py.test.raises(xsc.IllegalElementError, parsers.tree, s, parsers.Expat(ns=True), parsers.Instantiate(pool=xsc.Pool())) 
     233    py.test.raises(xsc.IllegalElementError, parse.tree, s, parse.Expat(ns=True), parse.Instantiate(pool=xsc.Pool())) 
    237234 
    238235 
    239236def test_parseemptyattribute(): 
    240     e = parsers.tree(b"<a target=''/>", parsers.Expat(), parsers.NS(html), parsers.Instantiate(pool=xsc.Pool(html))) 
     237    e = parse.tree(b"<a target=''/>", parse.Expat(), parse.NS(html), parse.Instantiate(pool=xsc.Pool(html))) 
    241238    assert "target" in e[0].attrs 
    242239 
    243240 
    244241def test_expat_xmldecl(): 
    245     e = parsers.tree(b"<?xml version='1.0' encoding='utf-8' standalone='yes'?><a/>", parsers.Expat(), parsers.NS(html), parsers.Instantiate()) 
     242    e = parse.tree(b"<?xml version='1.0' encoding='utf-8' standalone='yes'?><a/>", parse.Expat(), parse.NS(html), parse.Instantiate()) 
    246243    assert not isinstance(e[0], xml.XML) 
    247244 
    248     e = parsers.tree(b"<a/>", parsers.Expat(xmldecl=True), parsers.NS(html), parsers.Instantiate()) 
     245    e = parse.tree(b"<a/>", parse.Expat(xmldecl=True), parse.NS(html), parse.Instantiate()) 
    249246    assert not isinstance(e[0], xml.XML) 
    250247 
    251     e = parsers.tree(b"<?xml version='1.0'?><a/>", parsers.Expat(xmldecl=True), parsers.NS(html), parsers.Instantiate()) 
     248    e = parse.tree(b"<?xml version='1.0'?><a/>", parse.Expat(xmldecl=True), parse.NS(html), parse.Instantiate()) 
    252249    assert isinstance(e[0], xml.XML) 
    253250    assert e[0].content == u'version="1.0"' 
    254251 
    255     e = parsers.tree(b"<?xml version='1.0' encoding='utf-8'?><a/>", parsers.Expat(xmldecl=True), parsers.NS(html), parsers.Instantiate()) 
     252    e = parse.tree(b"<?xml version='1.0' encoding='utf-8'?><a/>", parse.Expat(xmldecl=True), parse.NS(html), parse.Instantiate()) 
    256253    assert isinstance(e[0], xml.XML) 
    257254    assert e[0].content == u'version="1.0" encoding="utf-8"' 
    258255 
    259     e = parsers.tree(b"<?xml version='1.0' encoding='utf-8' standalone='yes'?><a/>", parsers.Expat(xmldecl=True), parsers.NS(html), parsers.Instantiate()) 
     256    e = parse.tree(b"<?xml version='1.0' encoding='utf-8' standalone='yes'?><a/>", parse.Expat(xmldecl=True), parse.NS(html), parse.Instantiate()) 
    260257    assert isinstance(e[0], xml.XML) 
    261258    assert e[0].content == u'version="1.0" encoding="utf-8" standalone="yes"' 
     
    263260 
    264261def test_expat_doctype(): 
    265     e = parsers.tree(b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parsers.Expat(), parsers.NS(html), parsers.Instantiate()) 
     262    e = parse.tree(b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parse.Expat(), parse.NS(html), parse.Instantiate()) 
    266263    assert not isinstance(e[0], xsc.DocType) 
    267264 
    268     e = parsers.tree(b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parsers.Expat(doctype=True), parsers.NS(html), parsers.Instantiate()) 
     265    e = parse.tree(b'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parse.Expat(doctype=True), parse.NS(html), parse.Instantiate()) 
    269266    assert isinstance(e[0], xsc.DocType) 
    270267    assert e[0].content == html.DocTypeXHTML11().content 
    271268 
    272     e = parsers.tree(b'<!DOCTYPE html><a/>', parsers.Expat(doctype=True), parsers.NS(html), parsers.Instantiate()) 
     269    e = parse.tree(b'<!DOCTYPE html><a/>', parse.Expat(doctype=True), parse.NS(html), parse.Instantiate()) 
    273270    assert isinstance(e[0], xsc.DocType) 
    274271    assert e[0].content == "html" 
    275272 
    276     e = parsers.tree(b'<!DOCTYPE html SYSTEM "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parsers.Expat(doctype=True), parsers.NS(html), parsers.Instantiate()) 
     273    e = parse.tree(b'<!DOCTYPE html SYSTEM "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"><a/>', parse.Expat(doctype=True), parse.NS(html), parse.Instantiate()) 
    277274    assert isinstance(e[0], xsc.DocType) 
    278275    assert e[0].content == u'html SYSTEM "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"' 
    279276 
    280     e = parsers.tree(b'<!DOCTYPE a [<!ELEMENT a EMPTY><!--gurk-->]><a/>', parsers.Expat(doctype=True), parsers.NS(html), parsers.Instantiate()) 
     277    e = parse.tree(b'<!DOCTYPE a [<!ELEMENT a EMPTY><!--gurk-->]><a/>', parse.Expat(doctype=True), parse.NS(html), parse.Instantiate()) 
    281278    assert isinstance(e[0], xsc.DocType) 
    282279    assert e[0].content == u'a' # Internal subset gets dropped 
     
    284281 
    285282def test_htmlparse_base(): 
    286     e = parsers.tree(b"<a href='gurk.gif'/>", parsers.Tidy(), parsers.NS(html), parsers.Instantiate(base="hurz/index.html")) 
     283    e = parse.tree(b"<a href='gurk.gif'/>", parse.Tidy(), parse.NS(html), parse.Instantiate(base="hurz/index.html")) 
    287284    e = e.walknodes(html.a)[0] 
    288285    assert unicode(e.attrs.href) == "hurz/gurk.gif" 
     
    290287 
    291288def test_parse_tidy_empty(): 
    292     e = parsers.tree(b"", parsers.Tidy(), parsers.NS(), parsers.Instantiate()) 
     289    e = parse.tree(b"", parse.Tidy(), parse.NS(), parse.Instantiate()) 
    293290    assert not e 
    294291 
    295292 
    296293def test_base(): 
    297     e = parsers.tree(parsers.StringSource(b'<a xmlns="http://www.w3.org/1999/xhtml" href="gurk.html"/>', 'http://www.gurk.de/'), parsers.Expat(ns=True), parsers.Instantiate(pool=xsc.Pool(html))) 
     294    e = parse.tree(parse.StringSource(b'<a xmlns="http://www.w3.org/1999/xhtml" href="gurk.html"/>', 'http://www.gurk.de/'), parse.Expat(ns=True), parse.Instantiate(pool=xsc.Pool(html))) 
    298295    assert unicode(e[0].attrs.href) == "http://www.gurk.de/gurk.html" 
    299296 
     
    301298def test_stringsource(): 
    302299    expect = b"hinz & kunz" 
    303     source = parsers.StringSource(expect) 
     300    source = parse.StringSource(expect) 
    304301    for i in xrange(3): 
    305302        parsed = b"".join(data for (evtype, data) in source if evtype == "bytes") 
     
    309306def test_itersource(): 
    310307    expect = b"hinz & kunz" 
    311     source = parsers.IterSource([b"hinz", b" & ", b"kunz"]) 
     308    source = parse.IterSource([b"hinz", b" & ", b"kunz"]) 
    312309    for i in xrange(3): 
    313310        parsed = b"".join(data for (evtype, data) in source if evtype == "bytes") 
     
    317314def test_filesource(): 
    318315    expect = open("setup.py", "rb").read() 
    319     source = parsers.FileSource("setup.py", bufsize=32) 
     316    source = parse.FileSource("setup.py", bufsize=32) 
    320317    for i in xrange(3): 
    321318        parsed = "".join(data for (evtype, data) in source if evtype == "bytes") 
     
    326323    # StreamSource objects are not reusable 
    327324    expect = open("setup.py", "rb").read() 
    328     parsed = "".join(event[1] for event in parsers.StreamSource(open("setup.py", "rb"), bufsize=32) if event[0] == "bytes") 
     325    parsed = "".join(event[1] for event in parse.StreamSource(open("setup.py", "rb"), bufsize=32) if event[0] == "bytes") 
    329326    assert parsed == expect 
    330327 
     
    333330def test_urlsource(): 
    334331    expect = url.URL("http://www.python.org/").openread().read() 
    335     source = parsers.URLSource("http://www.python.org/", bufsize=32) 
     332    source = parse.URLSource("http://www.python.org/", bufsize=32) 
    336333    for i in xrange(3): 
    337334        parsed = b"".join(data for (evtype, data) in source if evtype == "bytes") 
     
    346343        yield b"</ul>" 
    347344 
    348     for (i, (evtype, path)) in enumerate(parsers.itertree(parsers.IterSource(xml()), parsers.Expat(ns=True), parsers.Instantiate(), filter=html.li)): 
     345    for (i, (evtype, path)) in enumerate(parse.itertree(parse.IterSource(xml()), parse.Expat(ns=True), parse.Instantiate(), filter=html.li)): 
    349346        assert int(str(path[-1])) == i 
    350347        path[-2].content.clear() 
     
    353350def test_expat_events_on_exception(): 
    354351    # Test that all collected events are output, before an exception is thrown 
    355     i = parsers.events(b"<x/>schrott", parsers.Expat()) 
     352    i = parse.events(b"<x/>schrott", parse.Expat()) 
    356353    assert i.next() == (u"url", url.URL("STRING")) 
    357354    assert i.next() == (u"position", (0, 0)) 
     
    365362def test_expat_no_multiple_text_events(): 
    366363    # Test that we don't get consecutive text events with expat 
    367     i = parsers.events(parsers.IterSource(b"<a>gurk &amp; hurz &amp; hinz &amp; kunz</a>"), parsers.Expat()) 
     364    i = parse.events(parse.IterSource(b"<a>gurk &amp; hurz &amp; hinz &amp; kunz</a>"), parse.Expat()) 
    368365    assert i.next() == (u"url", url.URL("ITER")) 
    369366    assert i.next() == (u"position", (0, 0)) 
     
    379376def test_sgmlop_no_multiple_text_events(): 
    380377    # Test that we don't get consecutive text events with sgmlop 
    381     i = parsers.events(parsers.IterSource(b"<a>gurk &amp; hurz &amp; hinz &amp; kunz</a>"), parsers.SGMLOP()) 
     378    i = parse.events(parse.IterSource(b"<a>gurk &amp; hurz &amp; hinz &amp; kunz</a>"), parse.SGMLOP()) 
    382379    assert i.next() == (u"url", url.URL("ITER")) 
    383380    assert i.next() == (u"enterstarttag", u"a") 
  • test/test_xist_publish.py

    r4041 r4052  
    1010 
    1111 
    12 from ll.xist import xsc, parsers 
     12from ll.xist import xsc, parse 
    1313from ll.xist.ns import html, xml, php, abbr, xlink, specials, struts_html 
    1414 
     
    145145        ) 
    146146        s = node.bytes(encoding=encoding) 
    147         node2 = parsers.tree(s, parsers.Expat(), parsers.NS(html), xsc.Pool(html, php, abbr)) 
     147        node2 = parse.tree(s, parse.Expat(), parse.NS(html), xsc.Pool(html, php, abbr)) 
    148148        assert node == node2 
    149149 
  • test/test_xist_tld2xsc.py

    r3933 r4052  
    1212import types, cStringIO 
    1313 
    14 from ll.xist import xsc, parsers, sims 
     14from ll.xist import xsc, sims 
    1515from ll.xist.ns import tld 
    1616from ll.xist.scripts import tld2xsc 
  • test/test_xist_url.py

    r4042 r4052  
    1111 
    1212from ll import url 
    13 from ll.xist import xsc, parsers 
     13from ll.xist import xsc, parse 
    1414from ll.xist.ns import specials, html, jsp 
    1515 
    1616 
    1717def test_url(recwarn): 
    18     # The recwarn argument silences the RequiredAttrMissingWarning 
    19     node = parsers.tree(b"<?url root:images/gurk.gif?>", parsers.SGMLOP(), parsers.NS(html), parsers.Instantiate()) 
     18    # The ``recwarn`` argument silences the ``RequiredAttrMissingWarning`` 
     19    node = parse.tree(b"<?url root:images/gurk.gif?>", parse.SGMLOP(), parse.NS(html), parse.Instantiate()) 
    2020    assert node.bytes(base="root:about/us.html") == b"../images/gurk.gif" 
    2121 
    22     node = parsers.tree(b'<img src="root:images/gurk.gif"/>', parsers.Expat(), parsers.NS(html), parsers.Instantiate()) 
     22    node = parse.tree(b'<img src="root:images/gurk.gif"/>', parse.Expat(), parse.NS(html), parse.Instantiate()) 
    2323    assert node.bytes(base="root:about/us.html") == b'<img src="../images/gurk.gif" />' 
    2424 
  • test/test_xist_xfind.py

    r4042 r4052  
    1313 
    1414from ll import misc 
    15 from ll.xist import xsc, xfind, parsers 
     15from ll.xist import xsc, xfind, parse 
    1616from ll.xist.ns import html 
    1717 
     
    271271 
    272272def test_frag(): 
    273     e = parsers.tree(b"das ist <b>klaus</b>. das ist <b>erich</b>", parsers.SGMLOP(), parsers.NS(html), parsers.Instantiate()) 
     273    e = parse.tree(b"das ist <b>klaus</b>. das ist <b>erich</b>", parse.SGMLOP(), parse.NS(html), parse.Instantiate()) 
    274274    assert u"".join(map(unicode, e.walknodes(e//html.b))) == u"klauserich" 
    275275