home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2867 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  22.9 KB  |  878 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'Comment',
  6.     'dump',
  7.     'Element',
  8.     'ElementTree',
  9.     'fromstring',
  10.     'iselement',
  11.     'iterparse',
  12.     'parse',
  13.     'PI',
  14.     'ProcessingInstruction',
  15.     'QName',
  16.     'SubElement',
  17.     'tostring',
  18.     'TreeBuilder',
  19.     'VERSION',
  20.     'XML',
  21.     'XMLParser',
  22.     'XMLTreeBuilder']
  23. import string
  24. import sys
  25. import re
  26.  
  27. class _SimpleElementPath:
  28.     
  29.     def find(self, element, tag):
  30.         for elem in element:
  31.             if elem.tag == tag:
  32.                 return elem
  33.         
  34.  
  35.     
  36.     def findtext(self, element, tag, default = None):
  37.         for elem in element:
  38.             if elem.tag == tag:
  39.                 if not elem.text:
  40.                     pass
  41.                 return ''
  42.         
  43.         return default
  44.  
  45.     
  46.     def findall(self, element, tag):
  47.         if tag[:3] == './/':
  48.             return element.getiterator(tag[3:])
  49.         result = []
  50.         for elem in element:
  51.             if elem.tag == tag:
  52.                 result.append(elem)
  53.                 continue
  54.             tag[:3] == './/'
  55.         
  56.         return result
  57.  
  58.  
  59.  
  60. try:
  61.     import ElementPath
  62. except ImportError:
  63.     ElementPath = _SimpleElementPath()
  64.  
  65. VERSION = '1.2.6'
  66.  
  67. class _ElementInterface:
  68.     tag = None
  69.     attrib = None
  70.     text = None
  71.     tail = None
  72.     
  73.     def __init__(self, tag, attrib):
  74.         self.tag = tag
  75.         self.attrib = attrib
  76.         self._children = []
  77.  
  78.     
  79.     def __repr__(self):
  80.         return '<Element %s at %x>' % (self.tag, id(self))
  81.  
  82.     
  83.     def makeelement(self, tag, attrib):
  84.         return Element(tag, attrib)
  85.  
  86.     
  87.     def __len__(self):
  88.         return len(self._children)
  89.  
  90.     
  91.     def __getitem__(self, index):
  92.         return self._children[index]
  93.  
  94.     
  95.     def __setitem__(self, index, element):
  96.         self._children[index] = element
  97.  
  98.     
  99.     def __delitem__(self, index):
  100.         del self._children[index]
  101.  
  102.     
  103.     def __getslice__(self, start, stop):
  104.         return self._children[start:stop]
  105.  
  106.     
  107.     def __setslice__(self, start, stop, elements):
  108.         for element in elements:
  109.             pass
  110.         
  111.         self._children[start:stop] = list(elements)
  112.  
  113.     
  114.     def __delslice__(self, start, stop):
  115.         del self._children[start:stop]
  116.  
  117.     
  118.     def append(self, element):
  119.         self._children.append(element)
  120.  
  121.     
  122.     def insert(self, index, element):
  123.         self._children.insert(index, element)
  124.  
  125.     
  126.     def remove(self, element):
  127.         self._children.remove(element)
  128.  
  129.     
  130.     def getchildren(self):
  131.         return self._children
  132.  
  133.     
  134.     def find(self, path):
  135.         return ElementPath.find(self, path)
  136.  
  137.     
  138.     def findtext(self, path, default = None):
  139.         return ElementPath.findtext(self, path, default)
  140.  
  141.     
  142.     def findall(self, path):
  143.         return ElementPath.findall(self, path)
  144.  
  145.     
  146.     def clear(self):
  147.         self.attrib.clear()
  148.         self._children = []
  149.         self.text = None
  150.         self.tail = None
  151.  
  152.     
  153.     def get(self, key, default = None):
  154.         return self.attrib.get(key, default)
  155.  
  156.     
  157.     def set(self, key, value):
  158.         self.attrib[key] = value
  159.  
  160.     
  161.     def keys(self):
  162.         return self.attrib.keys()
  163.  
  164.     
  165.     def items(self):
  166.         return self.attrib.items()
  167.  
  168.     
  169.     def getiterator(self, tag = None):
  170.         nodes = []
  171.         if tag == '*':
  172.             tag = None
  173.         
  174.         if tag is None or self.tag == tag:
  175.             nodes.append(self)
  176.         
  177.         for node in self._children:
  178.             nodes.extend(node.getiterator(tag))
  179.         
  180.         return nodes
  181.  
  182.  
  183. _Element = _ElementInterface
  184.  
  185. def Element(tag, attrib = { }, **extra):
  186.     attrib = attrib.copy()
  187.     attrib.update(extra)
  188.     return _ElementInterface(tag, attrib)
  189.  
  190.  
  191. def SubElement(parent, tag, attrib = { }, **extra):
  192.     attrib = attrib.copy()
  193.     attrib.update(extra)
  194.     element = parent.makeelement(tag, attrib)
  195.     parent.append(element)
  196.     return element
  197.  
  198.  
  199. def Comment(text = None):
  200.     element = Element(Comment)
  201.     element.text = text
  202.     return element
  203.  
  204.  
  205. def ProcessingInstruction(target, text = None):
  206.     element = Element(ProcessingInstruction)
  207.     element.text = target
  208.     if text:
  209.         element.text = element.text + ' ' + text
  210.     
  211.     return element
  212.  
  213. PI = ProcessingInstruction
  214.  
  215. class QName:
  216.     
  217.     def __init__(self, text_or_uri, tag = None):
  218.         if tag:
  219.             text_or_uri = '{%s}%s' % (text_or_uri, tag)
  220.         
  221.         self.text = text_or_uri
  222.  
  223.     
  224.     def __str__(self):
  225.         return self.text
  226.  
  227.     
  228.     def __hash__(self):
  229.         return hash(self.text)
  230.  
  231.     
  232.     def __cmp__(self, other):
  233.         if isinstance(other, QName):
  234.             return cmp(self.text, other.text)
  235.         return cmp(self.text, other)
  236.  
  237.  
  238.  
  239. class ElementTree:
  240.     
  241.     def __init__(self, element = None, file = None):
  242.         self._root = element
  243.         if file:
  244.             self.parse(file)
  245.         
  246.  
  247.     
  248.     def getroot(self):
  249.         return self._root
  250.  
  251.     
  252.     def _setroot(self, element):
  253.         self._root = element
  254.  
  255.     
  256.     def parse(self, source, parser = None):
  257.         if not hasattr(source, 'read'):
  258.             source = open(source, 'rb')
  259.         
  260.         if not parser:
  261.             parser = XMLTreeBuilder()
  262.         
  263.         while None:
  264.             data = source.read(32768)
  265.             if not data:
  266.                 break
  267.             
  268.             continue
  269.             self._root = parser.close()
  270.             return self._root
  271.  
  272.     
  273.     def getiterator(self, tag = None):
  274.         return self._root.getiterator(tag)
  275.  
  276.     
  277.     def find(self, path):
  278.         if path[:1] == '/':
  279.             path = '.' + path
  280.         
  281.         return self._root.find(path)
  282.  
  283.     
  284.     def findtext(self, path, default = None):
  285.         if path[:1] == '/':
  286.             path = '.' + path
  287.         
  288.         return self._root.findtext(path, default)
  289.  
  290.     
  291.     def findall(self, path):
  292.         if path[:1] == '/':
  293.             path = '.' + path
  294.         
  295.         return self._root.findall(path)
  296.  
  297.     
  298.     def write(self, file, encoding = 'us-ascii'):
  299.         if not hasattr(file, 'write'):
  300.             file = open(file, 'wb')
  301.         
  302.         if not encoding:
  303.             encoding = 'us-ascii'
  304.         elif encoding != 'utf-8' and encoding != 'us-ascii':
  305.             file.write("<?xml version='1.0' encoding='%s'?>\n" % encoding)
  306.         
  307.         self._write(file, self._root, encoding, { })
  308.  
  309.     
  310.     def _write(self, file, node, encoding, namespaces):
  311.         tag = node.tag
  312.         if tag is Comment:
  313.             file.write('<!-- %s -->' % _escape_cdata(node.text, encoding))
  314.         elif tag is ProcessingInstruction:
  315.             file.write('<?%s?>' % _escape_cdata(node.text, encoding))
  316.         else:
  317.             items = node.items()
  318.             xmlns_items = []
  319.             
  320.             try:
  321.                 if isinstance(tag, QName) or tag[:1] == '{':
  322.                     (tag, xmlns) = fixtag(tag, namespaces)
  323.                     if xmlns:
  324.                         xmlns_items.append(xmlns)
  325.                     
  326.             except TypeError:
  327.                 _raise_serialization_error(tag)
  328.  
  329.             file.write('<' + _encode(tag, encoding))
  330.             if items or xmlns_items:
  331.                 items.sort()
  332.                 for k, v in items:
  333.                     
  334.                     try:
  335.                         if isinstance(k, QName) or k[:1] == '{':
  336.                             (k, xmlns) = fixtag(k, namespaces)
  337.                             if xmlns:
  338.                                 xmlns_items.append(xmlns)
  339.                             
  340.                     except TypeError:
  341.                         _raise_serialization_error(k)
  342.  
  343.                     
  344.                     try:
  345.                         if isinstance(v, QName):
  346.                             (v, xmlns) = fixtag(v, namespaces)
  347.                             if xmlns:
  348.                                 xmlns_items.append(xmlns)
  349.                             
  350.                     except TypeError:
  351.                         _raise_serialization_error(v)
  352.  
  353.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  354.                 
  355.                 for k, v in xmlns_items:
  356.                     file.write(' %s="%s"' % (_encode(k, encoding), _escape_attrib(v, encoding)))
  357.                 
  358.             
  359.             if node.text or len(node):
  360.                 file.write('>')
  361.                 if node.text:
  362.                     file.write(_escape_cdata(node.text, encoding))
  363.                 
  364.                 for n in node:
  365.                     self._write(file, n, encoding, namespaces)
  366.                 
  367.                 file.write('</' + _encode(tag, encoding) + '>')
  368.             else:
  369.                 file.write(' />')
  370.             for k, v in xmlns_items:
  371.                 del namespaces[v]
  372.             
  373.         if node.tail:
  374.             file.write(_escape_cdata(node.tail, encoding))
  375.         
  376.  
  377.  
  378.  
  379. def iselement(element):
  380.     if not isinstance(element, _ElementInterface):
  381.         pass
  382.     return hasattr(element, 'tag')
  383.  
  384.  
  385. def dump(elem):
  386.     if not isinstance(elem, ElementTree):
  387.         elem = ElementTree(elem)
  388.     
  389.     elem.write(sys.stdout)
  390.     tail = elem.getroot().tail
  391.     if not tail or tail[-1] != '\n':
  392.         sys.stdout.write('\n')
  393.     
  394.  
  395.  
  396. def _encode(s, encoding):
  397.     
  398.     try:
  399.         return s.encode(encoding)
  400.     except AttributeError:
  401.         return s
  402.  
  403.  
  404. if sys.version[:3] == '1.5':
  405.     _escape = re.compile('[&<>\\"\\x80-\\xff]+')
  406. else:
  407.     _escape = re.compile(eval('u"[&<>\\"\\u0080-\\uffff]+"'))
  408. _escape_map = {
  409.     '&': '&',
  410.     '<': '<',
  411.     '>': '>',
  412.     '"': '"' }
  413. _namespace_map = {
  414.     'http://www.w3.org/XML/1998/namespace': 'xml',
  415.     'http://www.w3.org/1999/xhtml': 'html',
  416.     'http://www.w3.org/1999/02/22-rdf-syntax-ns#': 'rdf',
  417.     'http://schemas.xmlsoap.org/wsdl/': 'wsdl' }
  418.  
  419. def _raise_serialization_error(text):
  420.     raise TypeError('cannot serialize %r (type %s)' % (text, type(text).__name__))
  421.  
  422.  
  423. def _encode_entity(text, pattern = _escape):
  424.     
  425.     def escape_entities(m, map = _escape_map):
  426.         out = []
  427.         append = out.append
  428.         for char in m.group():
  429.             text = map.get(char)
  430.             if text is None:
  431.                 text = '&#%d;' % ord(char)
  432.             
  433.             append(text)
  434.         
  435.         return string.join(out, '')
  436.  
  437.     
  438.     try:
  439.         return _encode(pattern.sub(escape_entities, text), 'ascii')
  440.     except TypeError:
  441.         _raise_serialization_error(text)
  442.  
  443.  
  444.  
  445. def _escape_cdata(text, encoding = None, replace = string.replace):
  446.     
  447.     try:
  448.         if encoding:
  449.             
  450.             try:
  451.                 text = _encode(text, encoding)
  452.             except UnicodeError:
  453.                 return _encode_entity(text)
  454.             
  455.  
  456.         None<EXCEPTION MATCH>UnicodeError
  457.         text = replace(text, '&', '&')
  458.         text = replace(text, '<', '<')
  459.         text = replace(text, '>', '>')
  460.         return text
  461.     except (TypeError, AttributeError):
  462.         _raise_serialization_error(text)
  463.  
  464.  
  465.  
  466. def _escape_attrib(text, encoding = None, replace = string.replace):
  467.     
  468.     try:
  469.         if encoding:
  470.             
  471.             try:
  472.                 text = _encode(text, encoding)
  473.             except UnicodeError:
  474.                 return _encode_entity(text)
  475.             
  476.  
  477.         None<EXCEPTION MATCH>UnicodeError
  478.         text = replace(text, '&', '&')
  479.         text = replace(text, "'", ''')
  480.         text = replace(text, '"', '"')
  481.         text = replace(text, '<', '<')
  482.         text = replace(text, '>', '>')
  483.         return text
  484.     except (TypeError, AttributeError):
  485.         _raise_serialization_error(text)
  486.  
  487.  
  488.  
  489. def fixtag(tag, namespaces):
  490.     if isinstance(tag, QName):
  491.         tag = tag.text
  492.     
  493.     (namespace_uri, tag) = string.split(tag[1:], '}', 1)
  494.     prefix = namespaces.get(namespace_uri)
  495.     if prefix is None:
  496.         prefix = _namespace_map.get(namespace_uri)
  497.         if prefix is None:
  498.             prefix = 'ns%d' % len(namespaces)
  499.         
  500.         namespaces[namespace_uri] = prefix
  501.         if prefix == 'xml':
  502.             xmlns = None
  503.         else:
  504.             xmlns = ('xmlns:%s' % prefix, namespace_uri)
  505.     else:
  506.         xmlns = None
  507.     return ('%s:%s' % (prefix, tag), xmlns)
  508.  
  509.  
  510. def parse(source, parser = None):
  511.     tree = ElementTree()
  512.     tree.parse(source, parser)
  513.     return tree
  514.  
  515.  
  516. class iterparse:
  517.     
  518.     def __init__(self, source, events = None):
  519.         if not hasattr(source, 'read'):
  520.             source = open(source, 'rb')
  521.         
  522.         self._file = source
  523.         self._events = []
  524.         self._index = 0
  525.         self.root = None
  526.         self._root = None
  527.         self._parser = XMLTreeBuilder()
  528.         parser = self._parser._parser
  529.         append = self._events.append
  530.         if events is None:
  531.             events = [
  532.                 'end']
  533.         
  534.         for event in events:
  535.             if event == 'start':
  536.                 
  537.                 try:
  538.                     parser.ordered_attributes = 1
  539.                     parser.specified_attributes = 1
  540.                     
  541.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start_list):
  542.                         append((event, start(tag, attrib_in)))
  543.  
  544.                     parser.StartElementHandler = handler
  545.                 except AttributeError:
  546.                     
  547.                     def handler(tag, attrib_in, event = event, append = append, start = self._parser._start):
  548.                         append((event, start(tag, attrib_in)))
  549.  
  550.                     parser.StartElementHandler = handler
  551.                 except:
  552.                     None<EXCEPTION MATCH>AttributeError
  553.                 
  554.  
  555.             None<EXCEPTION MATCH>AttributeError
  556.             if event == 'end':
  557.                 
  558.                 def handler(tag, event = event, append = append, end = self._parser._end):
  559.                     append((event, end(tag)))
  560.  
  561.                 parser.EndElementHandler = handler
  562.                 continue
  563.             if event == 'start-ns':
  564.                 
  565.                 def handler(prefix, uri, event = event, append = append):
  566.                     
  567.                     try:
  568.                         uri = _encode(uri, 'ascii')
  569.                     except UnicodeError:
  570.                         pass
  571.  
  572.                     if not prefix:
  573.                         pass
  574.                     append((event, ('', uri)))
  575.  
  576.                 parser.StartNamespaceDeclHandler = handler
  577.                 continue
  578.             if event == 'end-ns':
  579.                 
  580.                 def handler(prefix, event = event, append = append):
  581.                     append((event, None))
  582.  
  583.                 parser.EndNamespaceDeclHandler = handler
  584.                 continue
  585.         
  586.  
  587.     
  588.     def next(self):
  589.         while None:
  590.             
  591.             try:
  592.                 item = self._events[self._index]
  593.             except IndexError:
  594.                 if self._parser is None:
  595.                     self.root = self._root
  596.                     
  597.                     try:
  598.                         raise StopIteration
  599.                     except NameError:
  600.                         raise IndexError
  601.                     except:
  602.                         None<EXCEPTION MATCH>NameError
  603.                     
  604.  
  605.                 None<EXCEPTION MATCH>NameError
  606.                 del self._events[:]
  607.                 self._index = 0
  608.                 data = self._file.read(16384)
  609.                 if data:
  610.                     self._parser.feed(data)
  611.                 else:
  612.                     self._root = self._parser.close()
  613.                     self._parser = None
  614.                 data
  615.  
  616.             self._index = self._index + 1
  617.             return item
  618.             continue
  619.             return None
  620.  
  621.     
  622.     try:
  623.         iter
  624.         
  625.         def __iter__(self):
  626.             return self
  627.  
  628.     except NameError:
  629.         
  630.         def __getitem__(self, index):
  631.             return self.next()
  632.  
  633.  
  634.  
  635.  
  636. def XML(text):
  637.     parser = XMLTreeBuilder()
  638.     parser.feed(text)
  639.     return parser.close()
  640.  
  641.  
  642. def XMLID(text):
  643.     parser = XMLTreeBuilder()
  644.     parser.feed(text)
  645.     tree = parser.close()
  646.     ids = { }
  647.     for elem in tree.getiterator():
  648.         id = elem.get('id')
  649.         if id:
  650.             ids[id] = elem
  651.             continue
  652.     
  653.     return (tree, ids)
  654.  
  655. fromstring = XML
  656.  
  657. def tostring(element, encoding = None):
  658.     
  659.     class dummy:
  660.         pass
  661.  
  662.     data = []
  663.     file = dummy()
  664.     file.write = data.append
  665.     ElementTree(element).write(file, encoding)
  666.     return string.join(data, '')
  667.  
  668.  
  669. class TreeBuilder:
  670.     
  671.     def __init__(self, element_factory = None):
  672.         self._data = []
  673.         self._elem = []
  674.         self._last = None
  675.         self._tail = None
  676.         if element_factory is None:
  677.             element_factory = _ElementInterface
  678.         
  679.         self._factory = element_factory
  680.  
  681.     
  682.     def close(self):
  683.         return self._last
  684.  
  685.     
  686.     def _flush(self):
  687.         if self._data:
  688.             if self._last is not None:
  689.                 text = string.join(self._data, '')
  690.                 if self._tail:
  691.                     self._last.tail = text
  692.                 else:
  693.                     self._last.text = text
  694.             
  695.             self._data = []
  696.         
  697.  
  698.     
  699.     def data(self, data):
  700.         self._data.append(data)
  701.  
  702.     
  703.     def start(self, tag, attrs):
  704.         self._flush()
  705.         self._last = elem = self._factory(tag, attrs)
  706.         if self._elem:
  707.             self._elem[-1].append(elem)
  708.         
  709.         self._elem.append(elem)
  710.         self._tail = 0
  711.         return elem
  712.  
  713.     
  714.     def end(self, tag):
  715.         self._flush()
  716.         self._last = self._elem.pop()
  717.         self._tail = 1
  718.         return self._last
  719.  
  720.  
  721.  
  722. class XMLTreeBuilder:
  723.     
  724.     def __init__(self, html = 0, target = None):
  725.         
  726.         try:
  727.             expat = expat
  728.             import xml.parsers
  729.         except ImportError:
  730.             raise ImportError('No module named expat; use SimpleXMLTreeBuilder instead')
  731.  
  732.         self._parser = parser = expat.ParserCreate(None, '}')
  733.         if target is None:
  734.             target = TreeBuilder()
  735.         
  736.         self._target = target
  737.         self._names = { }
  738.         parser.DefaultHandlerExpand = self._default
  739.         parser.StartElementHandler = self._start
  740.         parser.EndElementHandler = self._end
  741.         parser.CharacterDataHandler = self._data
  742.         
  743.         try:
  744.             self._parser.buffer_text = 1
  745.         except AttributeError:
  746.             pass
  747.  
  748.         
  749.         try:
  750.             self._parser.ordered_attributes = 1
  751.             self._parser.specified_attributes = 1
  752.             parser.StartElementHandler = self._start_list
  753.         except AttributeError:
  754.             pass
  755.  
  756.         encoding = None
  757.         if not parser.returns_unicode:
  758.             encoding = 'utf-8'
  759.         
  760.         self._doctype = None
  761.         self.entity = { }
  762.  
  763.     
  764.     def _fixtext(self, text):
  765.         
  766.         try:
  767.             return _encode(text, 'ascii')
  768.         except UnicodeError:
  769.             return text
  770.  
  771.  
  772.     
  773.     def _fixname(self, key):
  774.         
  775.         try:
  776.             name = self._names[key]
  777.         except KeyError:
  778.             name = key
  779.             if '}' in name:
  780.                 name = '{' + name
  781.             
  782.             self._names[key] = name = self._fixtext(name)
  783.  
  784.         return name
  785.  
  786.     
  787.     def _start(self, tag, attrib_in):
  788.         fixname = self._fixname
  789.         tag = fixname(tag)
  790.         attrib = { }
  791.         for key, value in attrib_in.items():
  792.             attrib[fixname(key)] = self._fixtext(value)
  793.         
  794.         return self._target.start(tag, attrib)
  795.  
  796.     
  797.     def _start_list(self, tag, attrib_in):
  798.         fixname = self._fixname
  799.         tag = fixname(tag)
  800.         attrib = { }
  801.         if attrib_in:
  802.             for i in range(0, len(attrib_in), 2):
  803.                 attrib[fixname(attrib_in[i])] = self._fixtext(attrib_in[i + 1])
  804.             
  805.         
  806.         return self._target.start(tag, attrib)
  807.  
  808.     
  809.     def _data(self, text):
  810.         return self._target.data(self._fixtext(text))
  811.  
  812.     
  813.     def _end(self, tag):
  814.         return self._target.end(self._fixname(tag))
  815.  
  816.     
  817.     def _default(self, text):
  818.         prefix = text[:1]
  819.         if prefix == '&':
  820.             
  821.             try:
  822.                 self._target.data(self.entity[text[1:-1]])
  823.             except KeyError:
  824.                 expat = expat
  825.                 import xml.parsers
  826.                 raise expat.error('undefined entity %s: line %d, column %d' % (text, self._parser.ErrorLineNumber, self._parser.ErrorColumnNumber))
  827.             except:
  828.                 None<EXCEPTION MATCH>KeyError
  829.             
  830.  
  831.         None<EXCEPTION MATCH>KeyError
  832.         if prefix == '<' and text[:9] == '<!DOCTYPE':
  833.             self._doctype = []
  834.         elif self._doctype is not None:
  835.             if prefix == '>':
  836.                 self._doctype = None
  837.                 return None
  838.             text = string.strip(text)
  839.             if not text:
  840.                 return None
  841.             self._doctype.append(text)
  842.             n = len(self._doctype)
  843.             if n > 2:
  844.                 type = self._doctype[1]
  845.                 if type == 'PUBLIC' and n == 4:
  846.                     (name, type, pubid, system) = self._doctype
  847.                 elif type == 'SYSTEM' and n == 3:
  848.                     (name, type, system) = self._doctype
  849.                     pubid = None
  850.                 else:
  851.                     return None
  852.                 if prefix == '>':
  853.                     pubid = pubid[1:-1]
  854.                 
  855.                 self.doctype(name, pubid, system[1:-1])
  856.                 self._doctype = None
  857.             
  858.         
  859.  
  860.     
  861.     def doctype(self, name, pubid, system):
  862.         pass
  863.  
  864.     
  865.     def feed(self, data):
  866.         self._parser.Parse(data, 0)
  867.  
  868.     
  869.     def close(self):
  870.         self._parser.Parse('', 1)
  871.         tree = self._target.close()
  872.         del self._target
  873.         del self._parser
  874.         return tree
  875.  
  876.  
  877. XMLParser = XMLTreeBuilder
  878.