home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2011 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.3 KB  |  262 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from xml.sax.handler import ContentHandler
  5. from lxml import etree
  6. from lxml.etree import ElementTree, SubElement
  7. from lxml.etree import Comment, ProcessingInstruction
  8.  
  9. class SaxError(etree.LxmlError):
  10.     pass
  11.  
  12.  
  13. def _getNsTag(tag):
  14.     if tag[0] == '{':
  15.         return tuple(tag[1:].split('}', 1))
  16.     return (None, tag)
  17.  
  18.  
  19. class ElementTreeContentHandler(ContentHandler):
  20.     
  21.     def __init__(self, makeelement = None):
  22.         self._root = None
  23.         self._root_siblings = []
  24.         self._element_stack = []
  25.         self._default_ns = None
  26.         self._ns_mapping = {
  27.             None: [
  28.                 None] }
  29.         self._new_mappings = { }
  30.         if makeelement is None:
  31.             makeelement = etree.Element
  32.         
  33.         self._makeelement = makeelement
  34.  
  35.     
  36.     def _get_etree(self):
  37.         return ElementTree(self._root)
  38.  
  39.     etree = property(_get_etree, doc = _get_etree.__doc__)
  40.     
  41.     def setDocumentLocator(self, locator):
  42.         pass
  43.  
  44.     
  45.     def startDocument(self):
  46.         pass
  47.  
  48.     
  49.     def endDocument(self):
  50.         pass
  51.  
  52.     
  53.     def startPrefixMapping(self, prefix, uri):
  54.         self._new_mappings[prefix] = uri
  55.         
  56.         try:
  57.             self._ns_mapping[prefix].append(uri)
  58.         except KeyError:
  59.             self._ns_mapping[prefix] = [
  60.                 uri]
  61.  
  62.         if prefix is None:
  63.             self._default_ns = uri
  64.         
  65.  
  66.     
  67.     def endPrefixMapping(self, prefix):
  68.         ns_uri_list = self._ns_mapping[prefix]
  69.         ns_uri_list.pop()
  70.         if prefix is None:
  71.             self._default_ns = ns_uri_list[-1]
  72.         
  73.  
  74.     
  75.     def startElementNS(self, ns_name, qname, attributes = None):
  76.         (ns_uri, local_name) = ns_name
  77.         if ns_uri:
  78.             el_name = '{%s}%s' % ns_name
  79.         elif self._default_ns:
  80.             el_name = '{%s}%s' % (self._default_ns, local_name)
  81.         else:
  82.             el_name = local_name
  83.         if attributes:
  84.             attrs = { }
  85.             
  86.             try:
  87.                 iter_attributes = attributes.iteritems()
  88.             except AttributeError:
  89.                 iter_attributes = attributes.items()
  90.  
  91.             for name_tuple, value in iter_attributes:
  92.                 if name_tuple[0]:
  93.                     attr_name = '{%s}%s' % name_tuple
  94.                 else:
  95.                     attr_name = name_tuple[1]
  96.                 attrs[attr_name] = value
  97.             
  98.         else:
  99.             attrs = None
  100.         element_stack = self._element_stack
  101.         if self._root is None:
  102.             element = self._root = self._makeelement(el_name, attrs, self._new_mappings)
  103.             if self._root_siblings and hasattr(element, 'addprevious'):
  104.                 for sibling in self._root_siblings:
  105.                     element.addprevious(sibling)
  106.                 
  107.             
  108.             del self._root_siblings[:]
  109.         else:
  110.             element = SubElement(element_stack[-1], el_name, attrs, self._new_mappings)
  111.         element_stack.append(element)
  112.         self._new_mappings.clear()
  113.  
  114.     
  115.     def processingInstruction(self, target, data):
  116.         pi = ProcessingInstruction(target, data)
  117.         if self._root is None:
  118.             self._root_siblings.append(pi)
  119.         else:
  120.             self._element_stack[-1].append(pi)
  121.  
  122.     
  123.     def endElementNS(self, ns_name, qname):
  124.         element = self._element_stack.pop()
  125.         if ns_name != _getNsTag(element.tag):
  126.             raise SaxError('Unexpected element closed: {%s}%s' % ns_name)
  127.         ns_name != _getNsTag(element.tag)
  128.  
  129.     
  130.     def startElement(self, name, attributes = None):
  131.         self.startElementNS((None, name), name, attributes)
  132.  
  133.     
  134.     def endElement(self, name):
  135.         self.endElementNS((None, name), name)
  136.  
  137.     
  138.     def characters(self, data):
  139.         last_element = self._element_stack[-1]
  140.         
  141.         try:
  142.             last_element = last_element[-1]
  143.             if not last_element.tail:
  144.                 pass
  145.             last_element.tail = '' + data
  146.         except IndexError:
  147.             if not last_element.text:
  148.                 pass
  149.             last_element.text = '' + data
  150.  
  151.  
  152.     ignorableWhitespace = characters
  153.  
  154.  
  155. class ElementTreeProducer(object):
  156.     
  157.     def __init__(self, element_or_tree, content_handler):
  158.         
  159.         try:
  160.             element = element_or_tree.getroot()
  161.         except AttributeError:
  162.             element = element_or_tree
  163.  
  164.         self._element = element
  165.         self._content_handler = content_handler
  166.         attr_class = AttributesNSImpl
  167.         import xml.sax.xmlreader
  168.         self._attr_class = attr_class
  169.         self._empty_attributes = attr_class({ }, { })
  170.  
  171.     
  172.     def saxify(self):
  173.         self._content_handler.startDocument()
  174.         element = self._element
  175.         if hasattr(element, 'getprevious'):
  176.             siblings = []
  177.             sibling = element.getprevious()
  178.             while getattr(sibling, 'tag', None) is ProcessingInstruction:
  179.                 siblings.append(sibling)
  180.                 sibling = sibling.getprevious()
  181.             for sibling in siblings[::-1]:
  182.                 self._recursive_saxify(sibling, { })
  183.             
  184.         
  185.         self._recursive_saxify(element, { })
  186.         if hasattr(element, 'getnext'):
  187.             sibling = element.getnext()
  188.             while getattr(sibling, 'tag', None) is ProcessingInstruction:
  189.                 self._recursive_saxify(sibling, { })
  190.                 sibling = sibling.getnext()
  191.         
  192.         self._content_handler.endDocument()
  193.  
  194.     
  195.     def _recursive_saxify(self, element, prefixes):
  196.         content_handler = self._content_handler
  197.         tag = element.tag
  198.         if tag is Comment or tag is ProcessingInstruction:
  199.             if tag is ProcessingInstruction:
  200.                 content_handler.processingInstruction(element.target, element.text)
  201.             
  202.             if element.tail:
  203.                 content_handler.characters(element.tail)
  204.             
  205.             return None
  206.         new_prefixes = []
  207.         build_qname = self._build_qname
  208.         attribs = element.items()
  209.         if attribs:
  210.             attr_values = { }
  211.             attr_qnames = { }
  212.             for attr_ns_name, value in attribs:
  213.                 attr_ns_tuple = _getNsTag(attr_ns_name)
  214.                 attr_values[attr_ns_tuple] = value
  215.                 attr_qnames[attr_ns_tuple] = build_qname(attr_ns_tuple[0], attr_ns_tuple[1], prefixes, new_prefixes)
  216.             
  217.             sax_attributes = self._attr_class(attr_values, attr_qnames)
  218.         else:
  219.             sax_attributes = self._empty_attributes
  220.         (ns_uri, local_name) = _getNsTag(tag)
  221.         qname = build_qname(ns_uri, local_name, prefixes, new_prefixes)
  222.         for prefix, uri in new_prefixes:
  223.             content_handler.startPrefixMapping(prefix, uri)
  224.         
  225.         content_handler.startElementNS((ns_uri, local_name), qname, sax_attributes)
  226.         if element.text:
  227.             content_handler.characters(element.text)
  228.         
  229.         for child in element:
  230.             self._recursive_saxify(child, prefixes)
  231.         
  232.         content_handler.endElementNS((ns_uri, local_name), qname)
  233.         for prefix, uri in new_prefixes:
  234.             content_handler.endPrefixMapping(prefix)
  235.         
  236.         if element.tail:
  237.             content_handler.characters(element.tail)
  238.         
  239.  
  240.     
  241.     def _build_qname(self, ns_uri, local_name, prefixes, new_prefixes):
  242.         if ns_uri is None:
  243.             return local_name
  244.         
  245.         try:
  246.             prefix = prefixes[ns_uri]
  247.         except KeyError:
  248.             ns_uri is None
  249.             ns_uri is None
  250.             prefix = prefixes[ns_uri] = 'ns%02d' % len(prefixes)
  251.             new_prefixes.append((prefix, ns_uri))
  252.         except:
  253.             ns_uri is None
  254.  
  255.         return prefix + ':' + local_name
  256.  
  257.  
  258.  
  259. def saxify(element_or_tree, content_handler):
  260.     return ElementTreeProducer(element_or_tree, content_handler).saxify()
  261.  
  262.