Changeset 2235:84ff1a40d8b6 in livinglogic.python.xist

Show
Ignore:
Timestamp:
12/23/04 17:06:03 (15 years ago)
Author:
Walter Doerwald <walter@…>
Branch:
default
Message:

Rename the element, procinst, entity and global attribute attribute from
xmlns to ns.

Rename as namespace classes defined in the namespace modules from
xmlns to ns too.

Module documentation from ll.xist.ns.doc.explain no longer contains
a header.

Use XFind expressions in a few spots in doc.py.

Rename xsc.Text.content to xsc.Text._content to be able to use
a ll.propclass.

Files:
36 modified

Legend:

Unmodified
Added
Removed
  • HOWTO.xml

    r2186 r2235  
    569569        return node.convert(converter) 
    570570 
    571 class xmlns(xsc.Namespace): 
     571class __ns__(xsc.Namespace): 
    572572    xmlname = "foo" 
    573573    xmlurl = "http://www.example.com/foo" 
    574 xmlns.update(vars()) 
     574__ns__.update(vars()) 
    575575</prog> 
    576576</example> 
     
    602602        return node.convert(converter) 
    603603 
    604 class xmlns(xsc.Namespace): 
     604class __ns__(xsc.Namespace): 
    605605    xmlname = "foo" 
    606606    xmlurl = "http://www.example.com/foo" 
    607 xmlns.<em>makemod</em>(vars()) 
     607__ns__.<em>makemod</em>(vars()) 
    608608</prog> 
    609609</example> 
     
    615615<prompt>&gt;&gt;&gt; </prompt><input>import foo</input> 
    616616<prompt>&gt;&gt;&gt; </prompt><input>foo</input> 
    617 &lt;foo:xmlns namespace name=u"foo" url=u"http://www.example.com/foo" with 2 elements from "foo.py" at 0x87654321&gt; 
     617&lt;foo:__ns__ namespace name=u"foo" url=u"http://www.example.com/foo" with 2 elements from "foo.py" at 0x87654321&gt; 
    618618<prompt>&gt;&gt;&gt; </prompt><input>foo.python</input> 
    619619&lt;foo:python element at 0x87654321&gt; 
     
    630630from ll.xist import xsc 
    631631 
    632 class xmlns(xsc.Namespace): 
     632class __ns__(xsc.Namespace): 
    633633    xmlname = "foo" 
    634634    xmlurl = "http://www.example.com/foo" 
     
    636636    class Attrs(xsc.Namespace.Attrs): 
    637637        class foo(xsc.TextAttr): pass 
    638 xmlns.makemod(vars()) 
     638__ns__.makemod(vars()) 
    639639</prog> 
    640640 
     
    664664<section><title>Subclassing namespaces</title> 
    665665<par>Each element class that belongs to a namespace can access its 
    666 namespace via the class attribute <lit>xmlns</lit>. When you're subclassing 
     666namespace via the class attribute <lit>__ns__</lit>. When you're subclassing 
    667667namespace classes, the elements in the base namespace will be automatically 
    668668subclassed too. Of course you can explicitly subclass an element class too. 
     
    683683class navigation(xsc.Element): 
    684684    def convert(self, converter): 
    685         node = self.xmlns.links() 
     685        node = self.__ns__.links() 
    686686        for (name, url) in languages: 
    687             node.append(self.xmlns.link(name, href=url)) 
     687            node.append(self.__ns__.link(name, href=url)) 
    688688        return node.convert(converter) 
    689689 
     
    701701        return node.convert(converter) 
    702702 
    703 class xmlns(xsc.Namespace): 
     703class __ns__(xsc.Namespace): 
    704704    xmlname = "nav" 
    705705    xmlurl = "http://www.example.com/nav" 
    706 xmlns.makemod(vars()) 
     706__ns__.makemod(vars()) 
    707707</prog> 
    708708 
     
    729729import navns 
    730730 
    731 class xmlns(navns): 
     731class __ns__(navns): 
    732732    class links(navns.links): 
    733733        def convert(self, converter): 
     
    752752            ) 
    753753            return node.convert(converter) 
    754 xmlns.makemod(vars()) 
     754__ns__.makemod(vars()) 
    755755</prog> 
    756756 
     
    792792import navns 
    793793 
    794 class xmlns(navns): 
     794class __ns__(navns): 
    795795    class links(nav.links): 
    796796        def convert(self, converter): 
     
    826826from ll.xist.ns import html 
    827827 
    828 class xmlns(html): 
     828class __ns__(html): 
    829829    class a(html.a): 
    830830        def convert(self, converter): 
  • _xist/ns/abbr.py

    r2222 r2235  
    451451 
    452452 
    453 class xmlns(xsc.Namespace): 
     453class __ns__(xsc.Namespace): 
    454454    xmlname = "abbr" 
    455455    xmlurl = "http://xmlns.livinglogic.de/xist/ns/abbr" 
    456 xmlns.makemod(vars()) 
    457  
     456__ns__.makemod(vars()) 
     457 
  • _xist/ns/chars.py

    r1957 r2235  
    294294 
    295295 
    296 class xmlns(xsc.Namespace): 
     296class __ns__(xsc.Namespace): 
    297297    xmlname = "chars" 
    298298    xmlurl = "http://xmlns.livinglogic.de/xist/ns/chars" 
    299 xmlns.makemod(vars()) 
     299__ns__.makemod(vars()) 
  • _xist/ns/code.py

    r2217 r2235  
    128128 
    129129 
    130 class xmlns(xsc.Namespace): 
     130class __ns__(xsc.Namespace): 
    131131    xmlname = "code" 
    132132    xmlurl = "http://xmlns.livinglogic.de/xist/ns/code" 
    133 xmlns.makemod(vars()) 
     133__ns__.makemod(vars()) 
    134134 
  • _xist/ns/cond.py

    r2217 r2235  
    119119 
    120120 
    121 class xmlns(xsc.Namespace): 
     121class __ns__(xsc.Namespace): 
    122122    xmlname = "cond" 
    123123    xmlurl = "http://xmlns.livinglogic.de/xist/ns/cond" 
    124 xmlns.makemod(vars()) 
     124__ns__.makemod(vars()) 
  • _xist/ns/css.py

    r2217 r2235  
    20902090 
    20912091 
    2092 class xmlns(xsc.Namespace): 
     2092class __ns__(xsc.Namespace): 
    20932093    xmlname = "css" 
    20942094    xmlurl = "http://www.w3.org/TR/REC-CSS2" 
    2095 xmlns.makemod(vars()) 
     2095__ns__.makemod(vars()) 
  • _xist/ns/cssspecials.py

    r2217 r2235  
    154154 
    155155 
    156 class xmlns(xsc.Namespace): 
     156class __ns__(xsc.Namespace): 
    157157    xmlname = "cssspecials" 
    158158    xmlurl = "http://xmlns.livinglogic.de/xist/ns/cssspecials" 
    159 xmlns.makemod(vars()) 
     159__ns__.makemod(vars()) 
    160160 
  • _xist/ns/doc.py

    r2223 r2235  
    1111__version__ = tuple(map(int, "$Revision$"[11:-2].split("."))) 
    1212# $Source$ 
     13 
     14""" 
     15This namespace module provides classes that can be used for generating 
     16documentation (both &html; and XSL-DO). 
     17""" 
    1318 
    1419# import __builtin__ to use property, which is also defined here 
     
    8388        elif issubclass(target, html): 
    8489            return self.convert_html(converter) 
    85         elif issubclass(target, xmlns): # our own namespace 
     90        elif issubclass(target, __ns__): # our own namespace 
    8691            return self.convert_doc(converter) 
    8792        elif issubclass(target, fo): # our own namespace 
     
    165170                for c in child.content: 
    166171                    if c==u"\t": 
    167                         c = self.xmlns.tab() 
     172                        c = self.__ns__.tab() 
    168173                    e.append(c) 
    169174            else: 
     
    759764        context = converter[self] 
    760765        if not context.lists: 
    761             raise errors.NodeOutsideContextError(self, self.xmlns.list) 
     766            raise errors.NodeOutsideContextError(self, self.__ns__.list) 
    762767        if context.lists[-1][0] == "dlist": 
    763768            e = converter.target.dd(self.content) 
     
    779784            content = self.content 
    780785        else: 
    781             content = self.xmlns.par(self.content) 
     786            content = self.__ns__.par(self.content) 
    782787        if type=="dlist": 
    783788            e = target.block( 
     
    11121117        target = converter.target 
    11131118        context = converter[self] 
    1114         if issubclass(target, xmlns): # our own namespace 
     1119        if issubclass(target, __ns__): # our own namespace 
    11151120            return self.convert_doc(converter) 
    11161121        if u"function" in self.attrs: 
     
    12151220        sysid = "DOCSTRING" 
    12161221    node = parsers.parseString(text, sysid=sysid, prefixes=xsc.DocPrefixes()) 
    1217     if not node.find(xsc.FindType(par)): # optimization: one paragraph docstrings don't need a <par> element. 
     1222    if not list(node/par): # optimization: one paragraph docstrings don't need a <par> element. 
    12181223        node = cls.par(node) 
    12191224 
    1220     refs = node.find(xsc.FindTypeAll(pyref)) 
    12211225    if inspect.ismethod(thing): 
    1222         for ref in refs: 
     1226        for ref in node//pyref: 
    12231227            if u"module" not in ref.attrs: 
    12241228                ref[u"module"] = cls._getmodulename(thing) 
     
    12281232                        ref[u"method"] = thing.__name__ 
    12291233    elif inspect.isfunction(thing): 
    1230         for ref in refs: 
     1234        for ref in node//pyref: 
    12311235            if u"module" not in ref.attrs: 
    12321236                ref[u"module"] = cls._getmodulename(thing) 
    12331237    elif inspect.isclass(thing): 
    1234         for ref in refs: 
     1238        for ref in node//pyref: 
    12351239            if u"module" not in ref.attrs: 
    12361240                ref[u"module"] = cls._getmodulename(thing) 
     
    12381242                    ref[u"class_"] = thing.__name__ 
    12391243    elif inspect.ismodule(thing): 
    1240         for ref in refs: 
     1244        for ref in node//pyref: 
    12411245            if u"module" not in ref.attrs: 
    12421246                ref[u"module"] = thing.__name__ 
     
    14471451        name = name or thing.__name__ 
    14481452        context = [(thing, name)] 
    1449         node = cls.section( 
    1450             cls.title(u"Module ", cls.module(name)), 
    1451             doc, 
    1452             role=(visibility, u" module ", hasdoc), 
    1453         ) 
     1453        node = xsc.Frag(doc) 
    14541454 
    14551455        functions = [] 
     
    14821482        context = converter[self] 
    14831483        e = self.content 
    1484         converter.push(target=xmlns) 
     1484        converter.push(target=__ns__) 
    14851485        e = e.convert(converter) 
    14861486        converter.pop() 
     
    15411541 
    15421542 
    1543 class xmlns(xsc.Namespace): 
     1543class __ns__(xsc.Namespace): 
    15441544    xmlname = "doc" 
    15451545    xmlurl = "http://xmlns.livinglogic.de/xist/ns/doc" 
    1546 xmlns.makemod(vars()) 
     1546__ns__.makemod(vars()) 
  • _xist/ns/docbook.py

    r2217 r2235  
    29452945 
    29462946 
    2947 class xmlns(xsc.Namespace): 
     2947class __ns__(xsc.Namespace): 
    29482948    xmlname = "docbook" 
    29492949    xmlurl = "http://www.docbook.org/xml/4.3/docbookx.dtd" 
    2950 xmlns.makemod(vars()) 
     2950__ns__.makemod(vars()) 
  • _xist/ns/fo.py

    r2232 r2235  
    19931993 
    19941994 
    1995 class xmlns(xsc.Namespace): 
     1995class __ns__(xsc.Namespace): 
    19961996    xmlname = "fo" 
    19971997    xmlurl = "http://www.w3.org/1999/XSL/Format" 
    1998 xmlns.makemod(vars()) 
     1998__ns__.makemod(vars()) 
    19991999 
    20002000 
     
    20802080                            setattr(element.Attrs, attr.xmlname[0], attr) # add child attribute to element 
    20812081 
    2082 for element in xmlns.iterelementvalues(): 
     2082for element in __ns__.iterelementvalues(): 
    20832083    fixattributesandmodel(element) 
    20842084del dtd # don't pollute the namespace 
    20852085 
    20862086# make sure, we assigned a model to every element 
    2087 assert sum(x.model is not None for x in xmlns.iterelementvalues()) == len(xmlns.elementvalues()) 
     2087assert sum(x.model is not None for x in __ns__.iterelementvalues()) == len(__ns__.elementvalues()) 
  • _xist/ns/form.py

    r2217 r2235  
    7979 
    8080 
    81 class xmlns(xsc.Namespace): 
     81class __ns__(xsc.Namespace): 
    8282    xmlname = "form" 
    8383    xmlurl = "http://xmlns.livinglogic.de/xist/ns/form" 
    84 xmlns.makemod(vars()) 
     84__ns__.makemod(vars()) 
  • _xist/ns/html.py

    r2217 r2235  
    173173 
    174174    def unwrapHTML(self, node, converter): 
    175         if isinstance(node, xsc.Element) and issubclass(node.xmlns, xmlns): # is this one of our own elements => filter it out 
     175        if isinstance(node, xsc.Element) and issubclass(node.__ns__, __ns__): # is this one of our own elements => filter it out 
    176176            if isinstance(node, img): 
    177177                node = node["alt"] 
     
    11851185 
    11861186 
    1187 class xmlns(xsc.Namespace): 
     1187class __ns__(xsc.Namespace): 
    11881188    xmlname = "html" 
    11891189    xmlurl = "http://www.w3.org/1999/xhtml" 
    1190 xmlns.makemod(vars()) 
     1190__ns__.makemod(vars()) 
    11911191 
    11921192 
  • _xist/ns/htmlspecials.py

    r2217 r2235  
    311311 
    312312 
    313 class xmlns(xsc.Namespace): 
     313class __ns__(xsc.Namespace): 
    314314    xmlname = "htmlspecials" 
    315315    xmlurl = "http://xmlns.livinglogic.de/xist/ns/htmlspecials" 
    316 xmlns.makemod(vars()) 
     316__ns__.makemod(vars()) 
  • _xist/ns/ihtml.py

    r2217 r2235  
    712712 
    713713 
    714 class xmlns(xsc.Namespace): 
     714class __ns__(xsc.Namespace): 
    715715    xmlname = "ihtml" 
    716716    xmlurl = "http://www.nttdocomo.co.jp/imode" 
    717 xmlns.makemod(vars()) 
     717__ns__.makemod(vars()) 
  • _xist/ns/jsp.py

    r2217 r2235  
    6868 
    6969    def convert(self, converter): 
    70         return self.xmlns.scriptlet(u"if(", self.content, u"){") 
     70        return self.__ns__.scriptlet(u"if(", self.content, u"){") 
    7171 
    7272 
     
    7575 
    7676    def convert(self, converter): 
    77         return self.xmlns.scriptlet(u"}else{") 
     77        return self.__ns__.scriptlet(u"}else{") 
    7878 
    7979 
     
    8282 
    8383    def convert(self, converter): 
    84         return self.xmlns.scriptlet(u"}else if (", self.content, u"){") 
     84        return self.__ns__.scriptlet(u"}else if (", self.content, u"){") 
    8585 
    8686 
     
    8989 
    9090    def convert(self, converter): 
    91         return self.xmlns.scriptlet(u"}") 
     91        return self.__ns__.scriptlet(u"}") 
    9292 
    9393 
     
    102102    def convert(self, converter): 
    103103        e = xsc.Frag( 
    104             self.xmlns.scriptlet(u"{"), 
     104            self.__ns__.scriptlet(u"{"), 
    105105            self.content, 
    106             self.xmlns.scriptlet(u"}") 
     106            self.__ns__.scriptlet(u"}") 
    107107        ) 
    108108        return e.convert(converter) 
     
    158158 
    159159 
    160 class xmlns(xsc.Namespace): 
     160class __ns__(xsc.Namespace): 
    161161    xmlname = "jsp" 
    162162    xmlurl = "http://java.sun.com/JSP/Page" 
    163 xmlns.makemod(vars()) 
     163__ns__.makemod(vars()) 
  • _xist/ns/meta.py

    r2217 r2235  
    180180 
    181181 
    182 class xmlns(xsc.Namespace): 
     182class __ns__(xsc.Namespace): 
    183183    xmlname = "meta" 
    184184    xmlurl = "http://xmlns.livinglogic.de/xist/ns/meta" 
    185 xmlns.makemod(vars()) 
     185__ns__.makemod(vars()) 
  • _xist/ns/metal.py

    r1957 r2235  
    2020 
    2121 
    22 class xmlns(xsc.Namespace): 
     22class __ns__(xsc.Namespace): 
    2323    xmlname = "metal" 
    2424    xmlurl = "http://xml.zope.org/namespaces/metal" 
     
    3030        class use_slot(xsc.TextAttr): xmlname = "use-slot" 
    3131 
    32 xmlns.makemod(vars()) 
     32__ns__.makemod(vars()) 
  • _xist/ns/php.py

    r2217 r2235  
    2828class expression(php): 
    2929    def convert(self, converter): 
    30         return self.xmlns.php(u"print ", self.content, u";") 
     30        return self.__ns__.php(u"print ", self.content, u";") 
    3131 
    3232 
     
    3535 
    3636    def convert(self, converter): 
    37         return self.xmlns.php(u"if (", self.content, u"){") 
     37        return self.__ns__.php(u"if (", self.content, u"){") 
    3838 
    3939 
     
    4242 
    4343    def convert(self, converter): 
    44         return self.xmlns.php(u"}else{") 
     44        return self.__ns__.php(u"}else{") 
    4545 
    4646 
     
    4949 
    5050    def convert(self, converter): 
    51         return self.xmlns.php(u"}else if (", self.content, u"){") 
     51        return self.__ns__.php(u"}else if (", self.content, u"){") 
    5252 
    5353 
     
    5656 
    5757    def convert(self, converter): 
    58         return self.xmlns.php(u"}") 
     58        return self.__ns__.php(u"}") 
    5959 
    6060 
     
    6464    def convert(self, converter): 
    6565        e = xsc.Frag( 
    66             self.xmlns.php(u"{"), 
     66            self.__ns__.php(u"{"), 
    6767            self.content, 
    68             self.xmlns.php(u"}") 
     68            self.__ns__.php(u"}") 
    6969        ) 
    7070        return e.convert(converter) 
    7171 
    7272 
    73 class xmlns(xsc.Namespace): 
     73class __ns__(xsc.Namespace): 
    7474    xmlname = "php" 
    7575    xmlurl = "http://www.php.net/" 
    76 xmlns.makemod(vars()) 
     76__ns__.makemod(vars()) 
  • _xist/ns/ruby.py

    r2217 r2235  
    7575 
    7676 
    77 class xmlns(xsc.Namespace): 
     77class __ns__(xsc.Namespace): 
    7878    xmlname = "ruby" 
    7979    xmlurl = "http://www.w3.org/TR/ruby/xhtml-ruby-1.mod" 
     80__ns__.makemod(vars()) 
  • _xist/ns/specials.py

    r2217 r2235  
    194194 
    195195 
    196 class xmlns(xsc.Namespace): 
     196class __ns__(xsc.Namespace): 
    197197    xmlname = "specials" 
    198198    xmlurl = "http://xmlns.livinglogic.de/xist/ns/specials" 
    199 xmlns.makemod(vars()) 
    200  
     199__ns__.makemod(vars()) 
     200 
  • _xist/ns/struts_config.py

    r2217 r2235  
    233233 
    234234 
    235 class xmlns(xsc.Namespace): 
     235class __ns__(xsc.Namespace): 
    236236    xmlname = "struts_config" 
    237237    xmlurl = "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd" 
    238 xmlns.makemod(vars()) 
     238__ns__.makemod(vars()) 
  • _xist/ns/struts_html.py

    r2107 r2235  
    528528 
    529529 
    530 class xmlns(xsc.Namespace): 
     530class __ns__(xsc.Namespace): 
    531531    xmlname = "struts_html" 
    532532    xmlurl = "http://jakarta.apache.org/struts/tags-html" 
    533 xmlns.makemod(vars()) 
     533__ns__.makemod(vars()) 
  • _xist/ns/svg.py

    r2217 r2235  
    99## 
    1010## See xist/__init__.py for the license 
     11 
     12 
     13""" 
     14This is a namespace module implementing 
     15<link href="http://www.w3.org/TR/SVG11/">&svg; 1.1.</link>. 
     16""" 
    1117 
    1218 
     
    12611267 
    12621268 
    1263 class xmlns(xsc.Namespace): 
     1269class __ns__(xsc.Namespace): 
    12641270    xmlname = "svg" 
    12651271    xmlurl = "http://www.w3.org/2000/svg" 
    1266 xmlns.makemod(vars()) 
     1272__ns__.makemod(vars()) 
  • _xist/ns/tal.py

    r1957 r2235  
    2020 
    2121 
    22 class xmlns(xsc.Namespace): 
     22class __ns__(xsc.Namespace): 
    2323    xmlname = "tal" 
    2424    xmlurl = "http://xml.zope.org/namespaces/tal" 
     
    3333        class omit_tag(xsc.TextAttr): xmlname = "omit-tag" 
    3434 
    35 xmlns.makemod(vars()) 
     35__ns__.makemod(vars()) 
  • _xist/ns/text.py

    r2217 r2235  
    102102 
    103103 
    104 class xmlns(html_): 
     104class __ns__(html_): 
    105105    xmlname = "text" 
    106106    xmlurl = "http://xmlns.livinglogic.de/xist/ns/text" 
    107 xmlns.makemod(vars()) 
     107__ns__.makemod(vars()) 
  • _xist/ns/tld.py

    r2225 r2235  
    257257 
    258258 
    259 class xmlns(xsc.Namespace): 
     259class __ns__(xsc.Namespace): 
    260260    xmlname = "tld" 
    261261    xmlurl = "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd" 
    262 xmlns.makemod(vars()) 
     262__ns__.makemod(vars()) 
  • _xist/ns/wml.py

    r2053 r2235  
    420420 
    421421 
    422 class xmlns(xsc.Namespace): 
     422class __ns__(xsc.Namespace): 
    423423    xmlname = "wml" 
    424424    xmlurl = "http://www.wapforum.org/DTD/wml13.dtd" 
    425 xmlns.makemod(vars()) 
     425__ns__.makemod(vars()) 
  • _xist/ns/xlink.py

    r2217 r2235  
    2020 
    2121 
    22 class xmlns(xsc.Namespace): 
     22class __ns__(xsc.Namespace): 
    2323    xmlname = "xlink" 
    2424    xmlurl  = "http://www.w3.org/1999/xlink" 
     
    3535        class from_(xsc.TextAttr): xmlname = "from" 
    3636        class to(xsc.TextAttr): pass 
    37 xmlns.makemod(vars()) 
     37__ns__.makemod(vars()) 
  • _xist/ns/xml.py

    r2217 r2235  
    7070 
    7171 
    72 class xmlns(xsc.Namespace): 
     72class __ns__(xsc.Namespace): 
    7373    xmlname = "xml" 
    7474    xmlurl = "http://www.w3.org/XML/1998/namespace" 
     
    8585            xmlprefix = "xml" 
    8686            needsxmlns = 1 
    87 xmlns.makemod(vars()) 
     87__ns__.makemod(vars()) 
  • _xist/publishers.py

    r2208 r2235  
    171171        for child in node.walk(iselorat): 
    172172            if child.needsxmlns(self) == 2: 
    173                 prefixes2def[child.xmlns] = True 
     173                prefixes2def[child.__ns__] = True 
    174174 
    175175        # Determine if we have multiple roots 
  • _xist/sims.py

    r2217 r2235  
    150150        if isinstance(node, xsc.Element): 
    151151            for child in node.content: 
    152                 if isinstance(child, xsc.Element) and node.xmlns is not None and child.xmlns is not None and issubclass(child.xmlns, node.xmlns): 
     152                if isinstance(child, xsc.Element) and node.__ns__ is not None and child.__ns__ is not None and issubclass(child.__ns__, node.__ns__): 
    153153                    warnings.warn(ElementWarning(node, child)) 
    154154 
     
    172172                if badtext(child): 
    173173                    warnings.warn(IllegalTextWarning(node, child)) 
    174                 elif isinstance(child, xsc.Element) and node.xmlns is not None and child.xmlns is not None and issubclass(child.xmlns, node.xmlns): 
     174                elif isinstance(child, xsc.Element) and node.__ns__ is not None and child.__ns__ is not None and issubclass(child.__ns__, node.__ns__): 
    175175                    warnings.warn(ElementWarning(node, child)) 
    176176 
     
    204204                if badtext(child): 
    205205                    warnings.warn(IllegalTextWarning(node, child)) 
    206                 elif isinstance(child, xsc.Element) and node.xmlns is not None and not isinstance(child, self.elements): 
     206                elif isinstance(child, xsc.Element) and node.__ns__ is not None and not isinstance(child, self.elements): 
    207207                    if ns is None: 
    208                         ns = tuple(el.xmlns for el in self.elements if el.xmlns is not None) 
    209                     if child.xmlns is not None and issubclass(child.xmlns, ns): 
     208                        ns = tuple(el.__ns__ for el in self.elements if el.__ns__ is not None) 
     209                    if child.__ns__ is not None and issubclass(child.__ns__, ns): 
    210210                        warnings.warn(WrongElementWarning(node, child, self.elements)) 
    211211 
     
    235235        if isinstance(node, xsc.Element): 
    236236            for child in node.content: 
    237                 if isinstance(child, xsc.Element) and node.xmlns is not None and not isinstance(child, self.elements): 
     237                if isinstance(child, xsc.Element) and node.__ns__ is not None and not isinstance(child, self.elements): 
    238238                    if ns is None: 
    239                         ns = tuple(el.xmlns for el in self.elements if el.xmlns is not None) 
    240                     if child.xmlns is not None and issubclass(child.xmlns, ns): 
     239                        ns = tuple(el.__ns__ for el in self.elements if el.__ns__ is not None) 
     240                    if child.__ns__ is not None and issubclass(child.__ns__, ns): 
    241241                        warnings.warn(WrongElementWarning(node, child, self.elements)) 
    242242 
  • _xist/xnd.py

    r2221 r2235  
    166166 
    167167        # assign name to the namespace itself 
    168         self.assignname(names, "xmlns") 
     168        self.assignname(names, "__ns__") 
    169169 
    170170        lines.append([level, "#!/usr/bin/env python"]) 
  • _xist/xsc.py

    r2230 r2235  
    226226        if "register" not in dict: 
    227227            dict["register"] = True 
    228         dict["xmlns"] = None 
     228        dict["__ns__"] = None 
    229229        # needsxmlns may be defined as a constant, this magically turns it into method 
    230230        if "needsxmlns" in dict: 
    231231            needsxmlns_value = dict["needsxmlns"] 
    232232            if not isinstance(needsxmlns_value, classmethod): 
     233                @classmethod 
    233234                def needsxmlns(cls, publisher=None): 
    234235                    return needsxmlns_value 
    235                 dict["needsxmlns"] = classmethod(needsxmlns) 
     236                dict["needsxmlns"] = needsxmlns 
    236237        if "xmlprefix" in dict: 
    237238            xmlprefix_value = dict["xmlprefix"] 
    238239            if not isinstance(xmlprefix_value, classmethod): 
     240                @classmethod 
    239241                def xmlprefix(cls, publisher=None): 
    240242                    return xmlprefix_value 
    241                 dict["xmlprefix"] = classmethod(xmlprefix) 
     243                dict["xmlprefix"] = xmlprefix 
    242244        pyname = unicode(name.split(".")[-1]) 
    243245        if "xmlname" in dict: 
     
    500502        from the namespace if <arg>publisher</arg> is <lit>None</lit>). 
    501503        """ 
    502         if cls.xmlns is None: 
     504        if cls.__ns__ is None: 
    503505            return None 
    504506        else: 
    505507            if publisher is None: 
    506                 return cls.xmlns.xmlname[True] 
     508                return cls.__ns__.xmlname[True] 
    507509            else: 
    508                 return publisher.prefixes.prefix4ns(cls.xmlns)[0] 
     510                return publisher.prefixes.prefix4ns(cls.__ns__)[0] 
    509511 
    510512    def _publishname(self, publisher): 
     
    796798    but omits a few methods.</par> 
    797799    """ 
    798     __slots__ = ("__content",) 
     800    __slots__ = ("_content",) 
    799801 
    800802    def __init__(self, *content): 
    801         self.__content = u"".join(unicode(x) for x in content) 
    802  
    803     def __getcontent(self): 
    804         return self.__content 
    805  
    806     content = property(__getcontent, None, None, "<par>The text content of the node as a <class>unicode</class> object.</par>") 
     803        self._content = u"".join(unicode(x) for x in content) 
     804 
     805    class content(ll.propclass): 
     806        """ 
     807        The text content of the node as a <class>unicode</class> object. 
     808        """ 
     809        def __get__(self): 
     810            return self._content 
    807811 
    808812    def __hash__(self): 
    809         return self.__content.__hash__() 
     813        return self._content.__hash__() 
    810814 
    811815    def __eq__(self, other): 
    812         return self.__class__ is other.__class__ and self.__content==other.__content 
     816        return self.__class__ is other.__class__ and self._content==other._content 
    813817 
    814818    def __len__(self): 
    815         return self.__content.__len__() 
     819        return self._content.__len__() 
    816820 
    817821    def __getitem__(self, index): 
    818         return self.__class__(self.__content.__getitem__(index)) 
     822        return self.__class__(self._content.__getitem__(index)) 
    819823 
    820824    def __add__(self, other): 
    821         return self.__class__(self.__content + other) 
     825        return self.__class__(self._content + other) 
    822826 
    823827    def __radd__(self, other): 
    824         return self.__class__(unicode(other) + self.__content) 
     828        return self.__class__(unicode(other) + self._content) 
    825829 
    826830    def __mul__(self, n): 
    827         return self.__class__(n * self.__content) 
     831        return self.__class__(n * self._content) 
    828832 
    829833    def __rmul__(self, n): 
    830         return self.__class__(n * self.__content) 
     834        return self.__class__(n * self._content) 
    831835 
    832836    def __getslice__(self, index1, index2): 
    833         return self.__class__(self.__content.__getslice__(index1, index2)) 
     837        return self.__class__(self._content.__getslice__(index1, index2)) 
    834838 
    835839    def capitalize(self): 
    836         return self.__class__(self.__content.capitalize()) 
     840        return self.__class__(self._content.capitalize()) 
    837841 
    838842    def center(self, width): 
    839         return self.__class__(self.__content.center(width)) 
     843        return self.__class__(self._content.center(width)) 
    840844 
    841845    def count(self, sub, start=0, end=sys.maxint): 
    842         return self.__content.count(sub, start, end) 
     846        return self._content.count(sub, start, end) 
    843847 
    844848    # find will be the one inherited from Node 
    845849 
    846850    def endswith(self, suffix, start=0, end=sys.maxint): 
    847         return self.__content.endswith(suffix, start, end) 
     851        return self._content.endswith(suffix, start, end) 
    848852 
    849853    def index(self, sub, start=0, end=sys.maxint): 
    850         return self.__content.index(sub, start, end) 
     854        return self._content.index(sub, start, end) 
    851855 
    852856    def isalpha(self): 
    853         return self.__content.isalpha() 
     857        return self._content.isalpha() 
    854858 
    855859    def isalnum(self): 
    856         return self.__content.isalnum() 
     860        return self._content.isalnum() 
    857861 
    858862    def isdecimal(self): 
    859         return self.__content.isdecimal() 
     863        return self._content.isdecimal() 
    860864 
    861865    def isdigit(self): 
    862         return self.__content.isdigit() 
     866        return self._content.isdigit() 
    863867 
    864868    def islower(self): 
    865         return self.__content.islower() 
     869        return self._content.islower() 
    866870 
    867871    def isnumeric(self): 
    868         return self.__content.isnumeric() 
     872        return self._content.isnumeric() 
    869873 
    870874    def isspace(self): 
    871         return self.__content.isspace() 
     875        return self._content.isspace() 
    872876 
    873877    def istitle(self): 
    874         return self.__content.istitle() 
     878        return self._content.istitle() 
    875879 
    876880    def isupper(self): 
    877         return self.__content.isupper() 
     881        return self._content.isupper() 
    878882 
    879883    def join(self, frag): 
     
    881885 
    882886    def ljust(self, width): 
    883         return self.__class__(self.__content.ljust(width)) 
     887        return self.__class__(self._content.ljust(width)) 
    884888 
    885889    def lower(self): 
    886         return self.__class__(self.__content.lower()) 
     890        return self.__class__(self._content.lower()) 
    887891 
    888892    def lstrip(self): 
    889         return self.__class__(self.__content.lstrip()) 
     893        return self.__class__(self._content.lstrip()) 
    890894 
    891895    def replace(self, old, new, maxsplit=-1): 
    892         return self.__class__(self.__content.replace(old, new, maxsplit)) 
     896        return self.__class__(self._content.replace(old, new, maxsplit)) 
    893897 
    894898    def rjust(self, width): 
    895         return self.__class__(self.__content.rjust(width)) 
     899        return self.__class__(self._content.rjust(width)) 
    896900 
    897901    def rstrip(self): 
    898         return self.__class__(self.__content.rstrip()) 
     902        return self.__class__(self._content.rstrip()) 
    899903 
    900904    def rfind(self, sub, start=0, end=sys.maxint): 
    901         return self.__content.rfind(sub, start, end) 
     905        return self._content.rfind(sub, start, end) 
    902906 
    903907    def rindex(self, sub, start=0, end=sys.maxint): 
    904         return self.__content.rindex(sub, start, end) 
     908        return self._content.rindex(sub, start, end) 
    905909 
    906910    def split(self, sep=None, maxsplit=-1): 
    907         return Frag(self.__content.split(sep, maxsplit)) 
     911        return Frag(self._content.split(sep, maxsplit)) 
    908912 
    909913    def splitlines(self, keepends=0): 
    910         return Frag(self.__content.splitlines(keepends)) 
     914        return Frag(self._content.splitlines(keepends)) 
    911915 
    912916    def startswith(self, prefix, start=0, end=sys.maxint): 
    913         return self.__content.startswith(prefix, start, end) 
     917        return self._content.startswith(prefix, start, end) 
    914918 
    915919    def strip(self): 
    916         return self.__class__(self.__content.strip()) 
     920        return self.__class__(self._content.strip()) 
    917921 
    918922    def swapcase(self): 
    919         return self.__class__(self.__content.swapcase()) 
     923        return self.__class__(self._content.swapcase()) 
    920924 
    921925    def title(self): 
    922         return self.__class__(self.__content.title()) 
     926        return self.__class__(self._content.title()) 
    923927 
    924928    def translate(self, table): 
    925         return self.__class__(self.__content.translate(table)) 
     929        return self.__class__(self._content.translate(table)) 
    926930 
    927931    def upper(self): 
    928         return self.__class__(self.__content.upper()) 
     932        return self.__class__(self._content.upper()) 
    929933 
    930934 
     
    14721476    @classmethod 
    14731477    def needsxmlns(self, publisher=None): 
    1474         if self.xmlns is not None: 
     1478        if self.__ns__ is not None: 
    14751479            return 2 
    14761480        else: 
     
    19601964                if isinstance(mapping, Namespace.Attrs): 
    19611965                    for (attrname, attrvalue) in mapping._iterallitems(): 
    1962                         self[(attrvalue.xmlns, attrname)] = attrvalue 
     1966                        self[(attrvalue.__ns__, attrname)] = attrvalue 
    19631967                else: 
    19641968                    try: 
     
    19781982                if isinstance(mapping, Namespace.Attrs): 
    19791983                    for (attrname, attrvalue) in mapping._iterallitems(): 
    1980                         if (attrvalue.xmlns, attrname) in self: 
    1981                             self[(attrvalue.xmlns, attrname)] = attrvalue 
     1984                        if (attrvalue.__ns__, attrname) in self: 
     1985                            self[(attrvalue.__ns__, attrname)] = attrvalue 
    19821986                else: 
    19831987                    try: 
     
    20012005                if isinstance(mapping, Namespace.Attrs): 
    20022006                    for (attrname, attrvalue) in mapping._iterallitems(): 
    2003                         if (attrvalue.xmlns, attrname) not in self: 
    2004                             self[(attrvalue.xmlns, attrname)] = attrvalue 
     2007                        if (attrvalue.__ns__, attrname) not in self: 
     2008                            self[(attrvalue.__ns__, attrname)] = attrvalue 
    20052009                else: 
    20062010                    try: 
     
    20802084            if value: 
    20812085                if isinstance(key, tuple): 
    2082                     yield (value.xmlns, value.xmlname[xml]) 
     2086                    yield (value.__ns__, value.xmlname[xml]) 
    20832087                else: 
    20842088                    yield value.xmlname[xml] 
     
    20992103            if value: 
    21002104                if isinstance(key, tuple): 
    2101                     yield ((value.xmlns, value.xmlname[xml]), value) 
     2105                    yield ((value.__ns__, value.xmlname[xml]), value) 
    21022106                else: 
    21032107                    yield (value.xmlname[xml], value) 
     
    21122116        for (key, value) in dict.iteritems(self): 
    21132117            if isinstance(key, tuple): 
    2114                 yield ((value.xmlns, value.xmlname[False]), value) 
     2118                yield ((value.__ns__, value.xmlname[False]), value) 
    21152119            else: 
    21162120                yield (value.xmlname[False], value) 
     
    22492253            def keep(node): 
    22502254                name = node.xmlname[xml] 
    2251                 if node.xmlns is None: 
     2255                if node.__ns__ is None: 
    22522256                    return name in names 
    22532257                else: 
     
    22552259                        return True 
    22562260                    for ns in namespaces: 
    2257                         if issubclass(node.xmlns, ns): 
     2261                        if issubclass(node.__ns__, ns): 
    22582262                            return True 
    22592263                    for testname in names: 
    2260                         if isinstance(testname, tuple) and issubclass(node.xmlns, testname[0]) and name==testname[1]: 
     2264                        if isinstance(testname, tuple) and issubclass(node.__ns__, testname[0]) and name==testname[1]: 
    22612265                            return True 
    22622266                    return False 
     
    22752279            def keep(node): 
    22762280                name = node.xmlname[xml] 
    2277                 if node.xmlns is None: 
     2281                if node.__ns__ is None: 
    22782282                    return name not in names 
    22792283                else: 
     
    22812285                        return False 
    22822286                    for ns in namespaces: 
    2283                         if issubclass(node.xmlns, ns): 
     2287                        if issubclass(node.__ns__, ns): 
    22842288                            return False 
    22852289                    for testname in names: 
    2286                         if isinstance(testname, tuple) and issubclass(node.xmlns, testname[0]) and name==testname[1]: 
     2290                        if isinstance(testname, tuple) and issubclass(node.__ns__, testname[0]) and name==testname[1]: 
    22872291                            return False 
    22882292                    return True 
     
    31833187                    value.__outerclass__ = self 
    31843188                if issubclass(value, (Element, ProcInst, Entity)): 
    3185                     value.xmlns = self 
     3189                    value.__ns__ = self 
    31863190        for attr in self.Attrs.iterallowedvalues(): 
    3187             attr.xmlns = self 
     3191            attr.__ns__ = self 
    31883192        if self.xmlurl is not None: 
    31893193            name = self.xmlname[True] 
     
    32453249        value = self.__dict__.get(key, None) # no inheritance 
    32463250        if isinstance(value, type) and issubclass(value, (Element, ProcInst, CharRef)): 
    3247             value.xmlns = None 
    32483251            self._cache = None 
     3252            value.__ns__ = None 
    32493253        return super(_Namespace_Meta, self).__delattr__(key) 
    32503254 
     
    32533257        oldvalue = self.__dict__.get(key, None) # no inheritance 
    32543258        if isinstance(oldvalue, type) and issubclass(oldvalue, (Element, ProcInst, Entity)): 
    3255             if oldvalue.xmlns is not None: 
    3256                 oldvalue.xmlns._cache = None 
    3257                 oldvalue.xmlns = None 
     3259            if oldvalue.__ns__ is not None: 
     3260                oldvalue.__ns__._cache = None 
     3261                oldvalue.__ns__ = None 
    32583262        # Set new attribute 
    32593263        if isinstance(value, type) and issubclass(value, (Element, ProcInst, Entity)): 
    3260             if value.xmlns is not None: 
    3261                 value.xmlns._cache = None 
    3262                 value.xmlns = None 
     3264            if value.__ns__ is not None: 
     3265                value.__ns__._cache = None 
     3266                value.__ns__ = None 
    32633267            self._cache = None 
    3264             value.xmlns = self 
     3268            value.__ns__ = self 
    32653269        return super(_Namespace_Meta, self).__setattr__(key, value) 
    32663270 
  • demos/media/Media.py

    r2136 r2235  
    132132 
    133133 
    134 class xmlns(xsc.Namespace): 
     134class __ns__(xsc.Namespace): 
    135135    xmlname = "media" 
    136136    xmlurl = "http://xmlns.livinglogic.de/xist/example/media" 
    137 xmlns.update(vars()) 
     137__ns__.update(vars()) 
    138138 
    139139 
    140140if __name__ == "__main__": 
    141     prefixes = xsc.Prefixes(xmlns, xml=xml) 
     141    prefixes = xsc.Prefixes(__ns__, xml=xml) 
    142142    node = parsers.parseFile("Media.xml", prefixes=prefixes) 
    143143    node = node.findfirst(xsc.FindType(media)) 
  • demos/python-quotes/python-quotes.py

    r2136 r2235  
    22# -*- coding: iso-8859-1 -*- 
    33 
    4 from ll.xist import xsc, sims, parsers 
     4from ll.xist import xsc, sims, parsers, xfind 
    55from ll.xist.ns import xml, html, meta 
    66 
     
    8080 
    8181 
    82 class xmlns(xsc.Namespace): 
     82class __ns__(xsc.Namespace): 
    8383    xmlname = "quotations" 
    8484    xmlurl = "http://xmlns.livinglogic.de/xist/examples/python-quotes" 
    85 xmlns.update(vars()) 
     85__ns__.update(vars()) 
    8686 
    8787 
    8888if __name__ == "__main__": 
    89     prefixes = xsc.Prefixes([xmlns, html, xml]) 
     89    prefixes = xsc.Prefixes([__ns__, html, xml]) 
    9090    base = "root:python-quotes.html" 
    9191    # We don't validate, because the XML contains broken HTML (<pre> inside <p>) 
    9292    e = parsers.parseURL(url, base=base, saxparser=parsers.ExpatParser, prefixes=prefixes, validate=False) 
    93     e = e.findfirst(xsc.FindType(quotations)) 
     93    e = xfind.first(e/quotations) 
    9494    e = e.compact().conv() 
    9595    e.write(open("python-quotes.html", "wb"), base=base, encoding="iso-8859-1", validate=False) 
  • test/test.py

    r2230 r2235  
    10451045class NamespaceTest(unittest.TestCase): 
    10461046    def test_mixedattrnames(self): 
    1047         class xmlns(xsc.Namespace): 
     1047        class __ns__(xsc.Namespace): 
    10481048            xmlname = "test" 
    10491049            xmlurl = "test" 
     
    10571057                    class A(xsc.TextAttr): xmlname = "a" 
    10581058 
    1059         node = xmlns.Test( 
     1059        node = __ns__.Test( 
    10601060            { 
    1061                 (xmlns, "a"): "a2", 
    1062                 (xmlns, "A"): "A2", 
     1061                (__ns__, "a"): "a2", 
     1062                (__ns__, "A"): "A2", 
    10631063            }, 
    10641064            a="a", 
     
    10681068                ("a", "a"), 
    10691069                ("A", "A"), 
    1070                 ((xmlns, "a"), "a2"), 
    1071                 ((xmlns, "A"), "A2") 
     1070                ((__ns__, "a"), "a2"), 
     1071                ((__ns__, "A"), "A2") 
    10721072            ): 
    10731073            self.assertEqual(unicode(node[name]), value) 
     
    11241124 
    11251125    def createns(self): 
    1126         class xmlns(xsc.Namespace): 
     1126        class __ns__(xsc.Namespace): 
    11271127            xmlname = "gurk" 
    11281128            xmlurl = "http://www.gurk.com/" 
     
    11311131            class bar(xsc.Element): 
    11321132                pass 
    1133         return xmlns 
     1133        return __ns__ 
    11341134 
    11351135    def test_nsupdate(self): 
     
    11771177    def test_attributeexamples(self): 
    11781178        self.assertEqual(xsc.amp.xmlname, (u"amp", u"amp")) 
    1179         self.assert_(xsc.amp.xmlns is None) 
     1179        self.assert_(xsc.amp.__ns__ is None) 
    11801180        self.assertEqual(xsc.amp.xmlprefix(), None) 
    11811181 
    11821182        self.assertEqual(chars.uuml.xmlname, (u"uuml", u"uuml")) 
    1183         self.assert_(chars.uuml.xmlns is chars) 
     1183        self.assert_(chars.uuml.__ns__ is chars) 
    11841184        self.assertEqual(chars.uuml.xmlprefix(), "chars") 
    11851185 
    11861186        self.assertEqual(html.a.Attrs.class_.xmlname, (u"class_", u"class")) 
    1187         self.assert_(html.a.Attrs.class_.xmlns is None) 
     1187        self.assert_(html.a.Attrs.class_.__ns__ is None) 
    11881188 
    11891189        self.assertEqual(xml.Attrs.lang.xmlname, (u"lang", u"lang")) 
    1190         self.assert_(xml.Attrs.lang.xmlns is xml) 
     1190        self.assert_(xml.Attrs.lang.__ns__ is xml) 
    11911191        self.assertEqual(xml.Attrs.lang.xmlprefix(), "xml") 
    11921192 
     
    11981198                model = False 
    11991199                def convert(self, converter): 
    1200                     e = self.xmlns.bar() 
     1200                    e = self.__ns__.bar() 
    12011201                    return e.convert(converter) 
    12021202            class bar(xsc.Entity): 
     
    15171517    def test_parserequiredattrs(self): 
    15181518        # Parser should complain about required attributes that are missing 
    1519         class xmlns(xsc.Namespace): 
     1519        class __ns__(xsc.Namespace): 
    15201520            class Test(xsc.Element): 
    15211521                class Attrs(xsc.Element.Attrs): 
    15221522                    class required(xsc.TextAttr): required = True 
    15231523 
    1524         prefixes = xsc.Prefixes(xmlns) 
     1524        prefixes = xsc.Prefixes(__ns__) 
    15251525        node = parsers.parseString('<Test required="foo"/>', prefixes=prefixes) 
    15261526        self.assertEqual(str(node[0]["required"]), "foo") 
     
    15311531    def test_parsevalueattrs(self): 
    15321532        # Parser should complain about attributes with illegal values, when a set of values is specified 
    1533         class xmlns(xsc.Namespace): 
     1533        class __ns__(xsc.Namespace): 
    15341534            class Test(xsc.Element): 
    15351535                class Attrs(xsc.Element.Attrs): 
    15361536                    class withvalues(xsc.TextAttr): values = ("foo", "bar") 
    15371537 
    1538         prefixes = xsc.Prefixes(xmlns) 
     1538        prefixes = xsc.Prefixes(__ns__) 
    15391539 
    15401540        warnings.filterwarnings("error", category=errors.IllegalAttrValueWarning) 
     
    15431543        self.assertSAXRaises(errors.IllegalAttrValueWarning, parsers.parseString, '<Test withvalues="baz"/>', prefixes=prefixes) 
    15441544 
    1545     class xmlns(xsc.Namespace): 
     1545    class __ns__(xsc.Namespace): 
    15461546        xmlname = "foo" 
    15471547        xmlurl = "http://www.foo.com/foo" 
     
    15651565        warnings.filterwarnings("error", category=errors.MalformedCharRefWarning) 
    15661566 
    1567         prefixes = xsc.Prefixes([self.__class__.xmlns, chars]) 
     1567        prefixes = xsc.Prefixes([self.__class__.__ns__, chars]) 
    15681568        self.check_parseentities(source, result, prefixes=prefixes, saxparser=parserfactory) 
    15691569        for bad in ("&", "&#x", "&&", "&#x;", "&#fg;", "&#999999999;", "&#;", "&#y;", "&#x;", "&#xy;"): 
     
    15881588        warnings.filterwarnings("ignore", category=errors.MalformedCharRefWarning) 
    15891589 
    1590         prefixes = xsc.Prefixes([self.__class__.xmlns, chars]) 
     1590        prefixes = xsc.Prefixes([self.__class__.__ns__, chars]) 
    15911591        tests = [ 
    15921592            ("&amp;", u"&"), 
     
    16921692        exec code in mod 
    16931693 
    1694         return mod["xmlns"] 
     1694        return mod["__ns__"] 
    16951695 
    16961696    def test_convert(self): 
     
    17161716 
    17171717        self.assert_(issubclass(ns, xsc.Namespace)) 
    1718         self.assertEqual(ns.xmlname, ("xmlns", "foo")) 
    1719         self.assertEqual(ns.xmlurl, "http://xmlns.foo.com/foo") 
     1718        self.assertEqual(ns.xmlname, ("__ns__", "foo")) 
     1719        self.assertEqual(ns.xmlurl, "http://xmlns1.foo.com/foo") 
    17201720        self.assert_(isinstance(ns.foo.model, sims.Elements)) 
    17211721        self.assertEqual(len(ns.foo.model.elements), 1) 
     
    18721872        exec code in mod 
    18731873 
    1874         return mod["xmlns"] 
     1874        return mod["__ns__"] 
    18751875 
    18761876    def test_convert(self): 
     
    19101910        """ 
    19111911        ns = self.tld2ns(tldstring, "foo") 
    1912         self.assertEqual(ns.xmlname, ("xmlns", "foo")) 
     1912        self.assertEqual(ns.xmlname, ("__ns__", "foo")) 
    19131913        self.assertEqual(ns.bar.xmlname, ("bar", "bar")) 
    19141914        self.assert_(isinstance(ns.bar.model, sims.Empty)) 
     
    19301930        exec code in mod 
    19311931 
    1932         return mod["xmlns"] 
     1932        return mod["__ns__"] 
    19331933 
    19341934    def test_procinst(self):