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