home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2875 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.4 KB  |  307 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import urlparse
  6. import urllib
  7. import types
  8. import handler
  9. import xmlreader
  10.  
  11. try:
  12.     _StringTypes = [
  13.         types.StringType,
  14.         types.UnicodeType]
  15. except AttributeError:
  16.     _StringTypes = [
  17.         types.StringType]
  18.  
  19.  
  20. try:
  21.     from codecs import xmlcharrefreplace_errors
  22.     _error_handling = 'xmlcharrefreplace'
  23.     del xmlcharrefreplace_errors
  24. except ImportError:
  25.     _error_handling = 'strict'
  26.  
  27.  
  28. def __dict_replace(s, d):
  29.     for key, value in d.items():
  30.         s = s.replace(key, value)
  31.     
  32.     return s
  33.  
  34.  
  35. def escape(data, entities = { }):
  36.     data = data.replace('&', '&')
  37.     data = data.replace('>', '>')
  38.     data = data.replace('<', '<')
  39.     if entities:
  40.         data = __dict_replace(data, entities)
  41.     
  42.     return data
  43.  
  44.  
  45. def unescape(data, entities = { }):
  46.     data = data.replace('<', '<')
  47.     data = data.replace('>', '>')
  48.     if entities:
  49.         data = __dict_replace(data, entities)
  50.     
  51.     return data.replace('&', '&')
  52.  
  53.  
  54. def quoteattr(data, entities = { }):
  55.     entities = entities.copy()
  56.     entities.update({
  57.         '\n': ' ',
  58.         '\r': ' ',
  59.         '\t': ' ' })
  60.     data = escape(data, entities)
  61.     if '"' in data:
  62.         if "'" in data:
  63.             data = '"%s"' % data.replace('"', '"')
  64.         else:
  65.             data = "'%s'" % data
  66.     else:
  67.         data = '"%s"' % data
  68.     return data
  69.  
  70.  
  71. class XMLGenerator(handler.ContentHandler):
  72.     
  73.     def __init__(self, out = None, encoding = 'iso-8859-1'):
  74.         if out is None:
  75.             import sys
  76.             out = sys.stdout
  77.         
  78.         handler.ContentHandler.__init__(self)
  79.         self._out = out
  80.         self._ns_contexts = [
  81.             { }]
  82.         self._current_context = self._ns_contexts[-1]
  83.         self._undeclared_ns_maps = []
  84.         self._encoding = encoding
  85.  
  86.     
  87.     def _write(self, text):
  88.         if isinstance(text, str):
  89.             self._out.write(text)
  90.         else:
  91.             self._out.write(text.encode(self._encoding, _error_handling))
  92.  
  93.     
  94.     def _qname(self, name):
  95.         if name[0]:
  96.             prefix = self._current_context[name[0]]
  97.             if prefix:
  98.                 return prefix + ':' + name[1]
  99.         
  100.         return name[1]
  101.  
  102.     
  103.     def startDocument(self):
  104.         self._write('<?xml version="1.0" encoding="%s"?>\n' % self._encoding)
  105.  
  106.     
  107.     def startPrefixMapping(self, prefix, uri):
  108.         self._ns_contexts.append(self._current_context.copy())
  109.         self._current_context[uri] = prefix
  110.         self._undeclared_ns_maps.append((prefix, uri))
  111.  
  112.     
  113.     def endPrefixMapping(self, prefix):
  114.         self._current_context = self._ns_contexts[-1]
  115.         del self._ns_contexts[-1]
  116.  
  117.     
  118.     def startElement(self, name, attrs):
  119.         self._write('<' + name)
  120.         for name, value in attrs.items():
  121.             self._write(' %s=%s' % (name, quoteattr(value)))
  122.         
  123.         self._write('>')
  124.  
  125.     
  126.     def endElement(self, name):
  127.         self._write('</%s>' % name)
  128.  
  129.     
  130.     def startElementNS(self, name, qname, attrs):
  131.         self._write('<' + self._qname(name))
  132.         for prefix, uri in self._undeclared_ns_maps:
  133.             if prefix:
  134.                 self._out.write(' xmlns:%s="%s"' % (prefix, uri))
  135.                 continue
  136.             self._out.write(' xmlns="%s"' % uri)
  137.         
  138.         self._undeclared_ns_maps = []
  139.         for name, value in attrs.items():
  140.             self._write(' %s=%s' % (self._qname(name), quoteattr(value)))
  141.         
  142.         self._write('>')
  143.  
  144.     
  145.     def endElementNS(self, name, qname):
  146.         self._write('</%s>' % self._qname(name))
  147.  
  148.     
  149.     def characters(self, content):
  150.         self._write(escape(content))
  151.  
  152.     
  153.     def ignorableWhitespace(self, content):
  154.         self._write(content)
  155.  
  156.     
  157.     def processingInstruction(self, target, data):
  158.         self._write('<?%s %s?>' % (target, data))
  159.  
  160.  
  161.  
  162. class XMLFilterBase(xmlreader.XMLReader):
  163.     
  164.     def __init__(self, parent = None):
  165.         xmlreader.XMLReader.__init__(self)
  166.         self._parent = parent
  167.  
  168.     
  169.     def error(self, exception):
  170.         self._err_handler.error(exception)
  171.  
  172.     
  173.     def fatalError(self, exception):
  174.         self._err_handler.fatalError(exception)
  175.  
  176.     
  177.     def warning(self, exception):
  178.         self._err_handler.warning(exception)
  179.  
  180.     
  181.     def setDocumentLocator(self, locator):
  182.         self._cont_handler.setDocumentLocator(locator)
  183.  
  184.     
  185.     def startDocument(self):
  186.         self._cont_handler.startDocument()
  187.  
  188.     
  189.     def endDocument(self):
  190.         self._cont_handler.endDocument()
  191.  
  192.     
  193.     def startPrefixMapping(self, prefix, uri):
  194.         self._cont_handler.startPrefixMapping(prefix, uri)
  195.  
  196.     
  197.     def endPrefixMapping(self, prefix):
  198.         self._cont_handler.endPrefixMapping(prefix)
  199.  
  200.     
  201.     def startElement(self, name, attrs):
  202.         self._cont_handler.startElement(name, attrs)
  203.  
  204.     
  205.     def endElement(self, name):
  206.         self._cont_handler.endElement(name)
  207.  
  208.     
  209.     def startElementNS(self, name, qname, attrs):
  210.         self._cont_handler.startElementNS(name, qname, attrs)
  211.  
  212.     
  213.     def endElementNS(self, name, qname):
  214.         self._cont_handler.endElementNS(name, qname)
  215.  
  216.     
  217.     def characters(self, content):
  218.         self._cont_handler.characters(content)
  219.  
  220.     
  221.     def ignorableWhitespace(self, chars):
  222.         self._cont_handler.ignorableWhitespace(chars)
  223.  
  224.     
  225.     def processingInstruction(self, target, data):
  226.         self._cont_handler.processingInstruction(target, data)
  227.  
  228.     
  229.     def skippedEntity(self, name):
  230.         self._cont_handler.skippedEntity(name)
  231.  
  232.     
  233.     def notationDecl(self, name, publicId, systemId):
  234.         self._dtd_handler.notationDecl(name, publicId, systemId)
  235.  
  236.     
  237.     def unparsedEntityDecl(self, name, publicId, systemId, ndata):
  238.         self._dtd_handler.unparsedEntityDecl(name, publicId, systemId, ndata)
  239.  
  240.     
  241.     def resolveEntity(self, publicId, systemId):
  242.         return self._ent_handler.resolveEntity(publicId, systemId)
  243.  
  244.     
  245.     def parse(self, source):
  246.         self._parent.setContentHandler(self)
  247.         self._parent.setErrorHandler(self)
  248.         self._parent.setEntityResolver(self)
  249.         self._parent.setDTDHandler(self)
  250.         self._parent.parse(source)
  251.  
  252.     
  253.     def setLocale(self, locale):
  254.         self._parent.setLocale(locale)
  255.  
  256.     
  257.     def getFeature(self, name):
  258.         return self._parent.getFeature(name)
  259.  
  260.     
  261.     def setFeature(self, name, state):
  262.         self._parent.setFeature(name, state)
  263.  
  264.     
  265.     def getProperty(self, name):
  266.         return self._parent.getProperty(name)
  267.  
  268.     
  269.     def setProperty(self, name, value):
  270.         self._parent.setProperty(name, value)
  271.  
  272.     
  273.     def getParent(self):
  274.         return self._parent
  275.  
  276.     
  277.     def setParent(self, parent):
  278.         self._parent = parent
  279.  
  280.  
  281.  
  282. def prepare_input_source(source, base = ''):
  283.     if type(source) in _StringTypes:
  284.         source = xmlreader.InputSource(source)
  285.     elif hasattr(source, 'read'):
  286.         f = source
  287.         source = xmlreader.InputSource()
  288.         source.setByteStream(f)
  289.         if hasattr(f, 'name'):
  290.             source.setSystemId(f.name)
  291.         
  292.     
  293.     if source.getByteStream() is None:
  294.         sysid = source.getSystemId()
  295.         basehead = os.path.dirname(os.path.normpath(base))
  296.         sysidfilename = os.path.join(basehead, sysid)
  297.         if os.path.isfile(sysidfilename):
  298.             source.setSystemId(sysidfilename)
  299.             f = open(sysidfilename, 'rb')
  300.         else:
  301.             source.setSystemId(urlparse.urljoin(base, sysid))
  302.             f = urllib.urlopen(source.getSystemId())
  303.         source.setByteStream(f)
  304.     
  305.     return source
  306.  
  307.