home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2861 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  14.6 KB  |  414 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import copy
  5. import xml.dom as xml
  6. from xml.dom.NodeFilter import NodeFilter
  7. __all__ = [
  8.     'DOMBuilder',
  9.     'DOMEntityResolver',
  10.     'DOMInputSource']
  11.  
  12. class Options:
  13.     namespaces = 1
  14.     namespace_declarations = True
  15.     validation = False
  16.     external_parameter_entities = True
  17.     external_general_entities = True
  18.     external_dtd_subset = True
  19.     validate_if_schema = False
  20.     validate = False
  21.     datatype_normalization = False
  22.     create_entity_ref_nodes = True
  23.     entities = True
  24.     whitespace_in_element_content = True
  25.     cdata_sections = True
  26.     comments = True
  27.     charset_overrides_xml_encoding = True
  28.     infoset = False
  29.     supported_mediatypes_only = False
  30.     errorHandler = None
  31.     filter = None
  32.  
  33.  
  34. class DOMBuilder:
  35.     entityResolver = None
  36.     errorHandler = None
  37.     filter = None
  38.     ACTION_REPLACE = 1
  39.     ACTION_APPEND_AS_CHILDREN = 2
  40.     ACTION_INSERT_AFTER = 3
  41.     ACTION_INSERT_BEFORE = 4
  42.     _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)
  43.     
  44.     def __init__(self):
  45.         self._options = Options()
  46.  
  47.     
  48.     def _get_entityResolver(self):
  49.         return self.entityResolver
  50.  
  51.     
  52.     def _set_entityResolver(self, entityResolver):
  53.         self.entityResolver = entityResolver
  54.  
  55.     
  56.     def _get_errorHandler(self):
  57.         return self.errorHandler
  58.  
  59.     
  60.     def _set_errorHandler(self, errorHandler):
  61.         self.errorHandler = errorHandler
  62.  
  63.     
  64.     def _get_filter(self):
  65.         return self.filter
  66.  
  67.     
  68.     def _set_filter(self, filter):
  69.         self.filter = filter
  70.  
  71.     
  72.     def setFeature(self, name, state):
  73.         if self.supportsFeature(name):
  74.             if not state or 1:
  75.                 pass
  76.             state = 0
  77.             
  78.             try:
  79.                 settings = self._settings[(_name_xform(name), state)]
  80.             except KeyError:
  81.                 raise xml.dom.NotSupportedErr('unsupported feature: %r' % (name,))
  82.  
  83.             for name, value in settings:
  84.                 setattr(self._options, name, value)
  85.             
  86.         else:
  87.             raise xml.dom.NotFoundErr('unknown feature: ' + repr(name))
  88.         return self.supportsFeature(name)
  89.  
  90.     
  91.     def supportsFeature(self, name):
  92.         return hasattr(self._options, _name_xform(name))
  93.  
  94.     
  95.     def canSetFeature(self, name, state):
  96.         if not state or 1:
  97.             pass
  98.         key = (_name_xform(name), 0)
  99.         return self._settings.has_key(key)
  100.  
  101.     _settings = {
  102.         ('namespace_declarations', 0): [
  103.             ('namespace_declarations', 0)],
  104.         ('namespace_declarations', 1): [
  105.             ('namespace_declarations', 1)],
  106.         ('validation', 0): [
  107.             ('validation', 0)],
  108.         ('external_general_entities', 0): [
  109.             ('external_general_entities', 0)],
  110.         ('external_general_entities', 1): [
  111.             ('external_general_entities', 1)],
  112.         ('external_parameter_entities', 0): [
  113.             ('external_parameter_entities', 0)],
  114.         ('external_parameter_entities', 1): [
  115.             ('external_parameter_entities', 1)],
  116.         ('validate_if_schema', 0): [
  117.             ('validate_if_schema', 0)],
  118.         ('create_entity_ref_nodes', 0): [
  119.             ('create_entity_ref_nodes', 0)],
  120.         ('create_entity_ref_nodes', 1): [
  121.             ('create_entity_ref_nodes', 1)],
  122.         ('entities', 0): [
  123.             ('create_entity_ref_nodes', 0),
  124.             ('entities', 0)],
  125.         ('entities', 1): [
  126.             ('entities', 1)],
  127.         ('whitespace_in_element_content', 0): [
  128.             ('whitespace_in_element_content', 0)],
  129.         ('whitespace_in_element_content', 1): [
  130.             ('whitespace_in_element_content', 1)],
  131.         ('cdata_sections', 0): [
  132.             ('cdata_sections', 0)],
  133.         ('cdata_sections', 1): [
  134.             ('cdata_sections', 1)],
  135.         ('comments', 0): [
  136.             ('comments', 0)],
  137.         ('comments', 1): [
  138.             ('comments', 1)],
  139.         ('charset_overrides_xml_encoding', 0): [
  140.             ('charset_overrides_xml_encoding', 0)],
  141.         ('charset_overrides_xml_encoding', 1): [
  142.             ('charset_overrides_xml_encoding', 1)],
  143.         ('infoset', 0): [],
  144.         ('infoset', 1): [
  145.             ('namespace_declarations', 0),
  146.             ('validate_if_schema', 0),
  147.             ('create_entity_ref_nodes', 0),
  148.             ('entities', 0),
  149.             ('cdata_sections', 0),
  150.             ('datatype_normalization', 1),
  151.             ('whitespace_in_element_content', 1),
  152.             ('comments', 1),
  153.             ('charset_overrides_xml_encoding', 1)],
  154.         ('supported_mediatypes_only', 0): [
  155.             ('supported_mediatypes_only', 0)],
  156.         ('namespaces', 0): [
  157.             ('namespaces', 0)],
  158.         ('namespaces', 1): [
  159.             ('namespaces', 1)] }
  160.     
  161.     def getFeature(self, name):
  162.         xname = _name_xform(name)
  163.         
  164.         try:
  165.             return getattr(self._options, xname)
  166.         except AttributeError:
  167.             if name == 'infoset':
  168.                 options = self._options
  169.                 if options.datatype_normalization and options.whitespace_in_element_content and options.comments and options.charset_overrides_xml_encoding:
  170.                     if not options.namespace_declarations and options.validate_if_schema and options.create_entity_ref_nodes and options.entities:
  171.                         pass
  172.                 return not (options.cdata_sections)
  173.             raise xml.dom.NotFoundErr('feature %s not known' % repr(name))
  174.         except:
  175.             name == 'infoset'
  176.  
  177.  
  178.     
  179.     def parseURI(self, uri):
  180.         if self.entityResolver:
  181.             input = self.entityResolver.resolveEntity(None, uri)
  182.         else:
  183.             input = DOMEntityResolver().resolveEntity(None, uri)
  184.         return self.parse(input)
  185.  
  186.     
  187.     def parse(self, input):
  188.         options = copy.copy(self._options)
  189.         options.filter = self.filter
  190.         options.errorHandler = self.errorHandler
  191.         fp = input.byteStream
  192.         if fp is None and options.systemId:
  193.             import urllib2
  194.             fp = urllib2.urlopen(input.systemId)
  195.         
  196.         return self._parse_bytestream(fp, options)
  197.  
  198.     
  199.     def parseWithContext(self, input, cnode, action):
  200.         if action not in self._legal_actions:
  201.             raise ValueError('not a legal action')
  202.         action not in self._legal_actions
  203.         raise NotImplementedError("Haven't written this yet...")
  204.  
  205.     
  206.     def _parse_bytestream(self, stream, options):
  207.         import xml.dom.expatbuilder as xml
  208.         builder = xml.dom.expatbuilder.makeBuilder(options)
  209.         return builder.parseFile(stream)
  210.  
  211.  
  212.  
  213. def _name_xform(name):
  214.     return name.lower().replace('-', '_')
  215.  
  216.  
  217. class DOMEntityResolver(object):
  218.     __slots__ = ('_opener',)
  219.     
  220.     def resolveEntity(self, publicId, systemId):
  221.         source = DOMInputSource()
  222.         source.publicId = publicId
  223.         source.systemId = systemId
  224.         source.byteStream = self._get_opener().open(systemId)
  225.         source.encoding = self._guess_media_encoding(source)
  226.         import posixpath
  227.         import urlparse
  228.         parts = urlparse.urlparse(systemId)
  229.         (scheme, netloc, path, params, query, fragment) = parts
  230.         if path and not path.endswith('/'):
  231.             path = posixpath.dirname(path) + '/'
  232.             parts = (scheme, netloc, path, params, query, fragment)
  233.             source.baseURI = urlparse.urlunparse(parts)
  234.         
  235.         return source
  236.  
  237.     
  238.     def _get_opener(self):
  239.         
  240.         try:
  241.             return self._opener
  242.         except AttributeError:
  243.             self._opener = self._create_opener()
  244.             return self._opener
  245.  
  246.  
  247.     
  248.     def _create_opener(self):
  249.         import urllib2
  250.         return urllib2.build_opener()
  251.  
  252.     
  253.     def _guess_media_encoding(self, source):
  254.         info = source.byteStream.info()
  255.         if info.has_key('Content-Type'):
  256.             for param in info.getplist():
  257.                 if param.startswith('charset='):
  258.                     return param.split('=', 1)[1].lower()
  259.             
  260.         
  261.  
  262.  
  263.  
  264. class DOMInputSource(object):
  265.     __slots__ = ('byteStream', 'characterStream', 'stringData', 'encoding', 'publicId', 'systemId', 'baseURI')
  266.     
  267.     def __init__(self):
  268.         self.byteStream = None
  269.         self.characterStream = None
  270.         self.stringData = None
  271.         self.encoding = None
  272.         self.publicId = None
  273.         self.systemId = None
  274.         self.baseURI = None
  275.  
  276.     
  277.     def _get_byteStream(self):
  278.         return self.byteStream
  279.  
  280.     
  281.     def _set_byteStream(self, byteStream):
  282.         self.byteStream = byteStream
  283.  
  284.     
  285.     def _get_characterStream(self):
  286.         return self.characterStream
  287.  
  288.     
  289.     def _set_characterStream(self, characterStream):
  290.         self.characterStream = characterStream
  291.  
  292.     
  293.     def _get_stringData(self):
  294.         return self.stringData
  295.  
  296.     
  297.     def _set_stringData(self, data):
  298.         self.stringData = data
  299.  
  300.     
  301.     def _get_encoding(self):
  302.         return self.encoding
  303.  
  304.     
  305.     def _set_encoding(self, encoding):
  306.         self.encoding = encoding
  307.  
  308.     
  309.     def _get_publicId(self):
  310.         return self.publicId
  311.  
  312.     
  313.     def _set_publicId(self, publicId):
  314.         self.publicId = publicId
  315.  
  316.     
  317.     def _get_systemId(self):
  318.         return self.systemId
  319.  
  320.     
  321.     def _set_systemId(self, systemId):
  322.         self.systemId = systemId
  323.  
  324.     
  325.     def _get_baseURI(self):
  326.         return self.baseURI
  327.  
  328.     
  329.     def _set_baseURI(self, uri):
  330.         self.baseURI = uri
  331.  
  332.  
  333.  
  334. class DOMBuilderFilter:
  335.     FILTER_ACCEPT = 1
  336.     FILTER_REJECT = 2
  337.     FILTER_SKIP = 3
  338.     FILTER_INTERRUPT = 4
  339.     whatToShow = NodeFilter.SHOW_ALL
  340.     
  341.     def _get_whatToShow(self):
  342.         return self.whatToShow
  343.  
  344.     
  345.     def acceptNode(self, element):
  346.         return self.FILTER_ACCEPT
  347.  
  348.     
  349.     def startContainer(self, element):
  350.         return self.FILTER_ACCEPT
  351.  
  352.  
  353. del NodeFilter
  354.  
  355. class DocumentLS:
  356.     async = False
  357.     
  358.     def _get_async(self):
  359.         return False
  360.  
  361.     
  362.     def _set_async(self, async):
  363.         if async:
  364.             raise xml.dom.NotSupportedErr('asynchronous document loading is not supported')
  365.         async
  366.  
  367.     
  368.     def abort(self):
  369.         raise NotImplementedError("haven't figured out what this means yet")
  370.  
  371.     
  372.     def load(self, uri):
  373.         raise NotImplementedError("haven't written this yet")
  374.  
  375.     
  376.     def loadXML(self, source):
  377.         raise NotImplementedError("haven't written this yet")
  378.  
  379.     
  380.     def saveXML(self, snode):
  381.         if snode is None:
  382.             snode = self
  383.         elif snode.ownerDocument is not self:
  384.             raise xml.dom.WrongDocumentErr()
  385.         
  386.         return snode.toxml()
  387.  
  388.  
  389.  
  390. class DOMImplementationLS:
  391.     MODE_SYNCHRONOUS = 1
  392.     MODE_ASYNCHRONOUS = 2
  393.     
  394.     def createDOMBuilder(self, mode, schemaType):
  395.         if schemaType is not None:
  396.             raise xml.dom.NotSupportedErr('schemaType not yet supported')
  397.         schemaType is not None
  398.         if mode == self.MODE_SYNCHRONOUS:
  399.             return DOMBuilder()
  400.         if mode == self.MODE_ASYNCHRONOUS:
  401.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  402.         mode == self.MODE_ASYNCHRONOUS
  403.         raise ValueError('unknown value for mode')
  404.  
  405.     
  406.     def createDOMWriter(self):
  407.         raise NotImplementedError("the writer interface hasn't been written yet!")
  408.  
  409.     
  410.     def createDOMInputSource(self):
  411.         return DOMInputSource()
  412.  
  413.  
  414.