home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / xml / dom / xmlbuilder.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  16.1 KB  |  426 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  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.         return self.supportsFeature(name)
  95.  
  96.     
  97.     def supportsFeature(self, name):
  98.         return hasattr(self._options, _name_xform(name))
  99.  
  100.     
  101.     def canSetFeature(self, name, state):
  102.         if not state or 1:
  103.             pass
  104.         key = (_name_xform(name), 0)
  105.         return self._settings.has_key(key)
  106.  
  107.     _settings = {
  108.         ('namespace_declarations', 0): [
  109.             ('namespace_declarations', 0)],
  110.         ('namespace_declarations', 1): [
  111.             ('namespace_declarations', 1)],
  112.         ('validation', 0): [
  113.             ('validation', 0)],
  114.         ('external_general_entities', 0): [
  115.             ('external_general_entities', 0)],
  116.         ('external_general_entities', 1): [
  117.             ('external_general_entities', 1)],
  118.         ('external_parameter_entities', 0): [
  119.             ('external_parameter_entities', 0)],
  120.         ('external_parameter_entities', 1): [
  121.             ('external_parameter_entities', 1)],
  122.         ('validate_if_schema', 0): [
  123.             ('validate_if_schema', 0)],
  124.         ('create_entity_ref_nodes', 0): [
  125.             ('create_entity_ref_nodes', 0)],
  126.         ('create_entity_ref_nodes', 1): [
  127.             ('create_entity_ref_nodes', 1)],
  128.         ('entities', 0): [
  129.             ('create_entity_ref_nodes', 0),
  130.             ('entities', 0)],
  131.         ('entities', 1): [
  132.             ('entities', 1)],
  133.         ('whitespace_in_element_content', 0): [
  134.             ('whitespace_in_element_content', 0)],
  135.         ('whitespace_in_element_content', 1): [
  136.             ('whitespace_in_element_content', 1)],
  137.         ('cdata_sections', 0): [
  138.             ('cdata_sections', 0)],
  139.         ('cdata_sections', 1): [
  140.             ('cdata_sections', 1)],
  141.         ('comments', 0): [
  142.             ('comments', 0)],
  143.         ('comments', 1): [
  144.             ('comments', 1)],
  145.         ('charset_overrides_xml_encoding', 0): [
  146.             ('charset_overrides_xml_encoding', 0)],
  147.         ('charset_overrides_xml_encoding', 1): [
  148.             ('charset_overrides_xml_encoding', 1)],
  149.         ('infoset', 0): [],
  150.         ('infoset', 1): [
  151.             ('namespace_declarations', 0),
  152.             ('validate_if_schema', 0),
  153.             ('create_entity_ref_nodes', 0),
  154.             ('entities', 0),
  155.             ('cdata_sections', 0),
  156.             ('datatype_normalization', 1),
  157.             ('whitespace_in_element_content', 1),
  158.             ('comments', 1),
  159.             ('charset_overrides_xml_encoding', 1)],
  160.         ('supported_mediatypes_only', 0): [
  161.             ('supported_mediatypes_only', 0)],
  162.         ('namespaces', 0): [
  163.             ('namespaces', 0)],
  164.         ('namespaces', 1): [
  165.             ('namespaces', 1)] }
  166.     
  167.     def getFeature(self, name):
  168.         xname = _name_xform(name)
  169.         
  170.         try:
  171.             return getattr(self._options, xname)
  172.         except AttributeError:
  173.             if name == 'infoset':
  174.                 options = self._options
  175.                 if options.datatype_normalization and options.whitespace_in_element_content and options.comments and options.charset_overrides_xml_encoding:
  176.                     if not options.namespace_declarations and options.validate_if_schema and options.create_entity_ref_nodes and options.entities:
  177.                         pass
  178.                 return not (options.cdata_sections)
  179.             raise xml.dom.NotFoundErr('feature %s not known' % repr(name))
  180.         except:
  181.             name == 'infoset'
  182.  
  183.  
  184.     
  185.     def parseURI(self, uri):
  186.         if self.entityResolver:
  187.             input = self.entityResolver.resolveEntity(None, uri)
  188.         else:
  189.             input = DOMEntityResolver().resolveEntity(None, uri)
  190.         return self.parse(input)
  191.  
  192.     
  193.     def parse(self, input):
  194.         options = copy.copy(self._options)
  195.         options.filter = self.filter
  196.         options.errorHandler = self.errorHandler
  197.         fp = input.byteStream
  198.         if fp is None and options.systemId:
  199.             import urllib2
  200.             fp = urllib2.urlopen(input.systemId)
  201.         
  202.         return self._parse_bytestream(fp, options)
  203.  
  204.     
  205.     def parseWithContext(self, input, cnode, action):
  206.         if action not in self._legal_actions:
  207.             raise ValueError('not a legal action')
  208.         action not in self._legal_actions
  209.         raise NotImplementedError("Haven't written this yet...")
  210.  
  211.     
  212.     def _parse_bytestream(self, stream, options):
  213.         import xml.dom.expatbuilder as xml
  214.         builder = xml.dom.expatbuilder.makeBuilder(options)
  215.         return builder.parseFile(stream)
  216.  
  217.  
  218.  
  219. def _name_xform(name):
  220.     return name.lower().replace('-', '_')
  221.  
  222.  
  223. class DOMEntityResolver(object):
  224.     __slots__ = ('_opener',)
  225.     
  226.     def resolveEntity(self, publicId, systemId):
  227.         if not systemId is not None:
  228.             raise AssertionError
  229.         source = DOMInputSource()
  230.         source.publicId = publicId
  231.         source.systemId = systemId
  232.         source.byteStream = self._get_opener().open(systemId)
  233.         source.encoding = self._guess_media_encoding(source)
  234.         import posixpath
  235.         import urlparse
  236.         parts = urlparse.urlparse(systemId)
  237.         (scheme, netloc, path, params, query, fragment) = parts
  238.         if path and not path.endswith('/'):
  239.             path = posixpath.dirname(path) + '/'
  240.             parts = (scheme, netloc, path, params, query, fragment)
  241.             source.baseURI = urlparse.urlunparse(parts)
  242.         
  243.         return source
  244.  
  245.     
  246.     def _get_opener(self):
  247.         
  248.         try:
  249.             return self._opener
  250.         except AttributeError:
  251.             self._opener = self._create_opener()
  252.             return self._opener
  253.  
  254.  
  255.     
  256.     def _create_opener(self):
  257.         import urllib2
  258.         return urllib2.build_opener()
  259.  
  260.     
  261.     def _guess_media_encoding(self, source):
  262.         info = source.byteStream.info()
  263.         if info.has_key('Content-Type'):
  264.             for param in info.getplist():
  265.                 if param.startswith('charset='):
  266.                     return param.split('=', 1)[1].lower()
  267.             
  268.         
  269.  
  270.  
  271.  
  272. class DOMInputSource(object):
  273.     __slots__ = ('byteStream', 'characterStream', 'stringData', 'encoding', 'publicId', 'systemId', 'baseURI')
  274.     
  275.     def __init__(self):
  276.         self.byteStream = None
  277.         self.characterStream = None
  278.         self.stringData = None
  279.         self.encoding = None
  280.         self.publicId = None
  281.         self.systemId = None
  282.         self.baseURI = None
  283.  
  284.     
  285.     def _get_byteStream(self):
  286.         return self.byteStream
  287.  
  288.     
  289.     def _set_byteStream(self, byteStream):
  290.         self.byteStream = byteStream
  291.  
  292.     
  293.     def _get_characterStream(self):
  294.         return self.characterStream
  295.  
  296.     
  297.     def _set_characterStream(self, characterStream):
  298.         self.characterStream = characterStream
  299.  
  300.     
  301.     def _get_stringData(self):
  302.         return self.stringData
  303.  
  304.     
  305.     def _set_stringData(self, data):
  306.         self.stringData = data
  307.  
  308.     
  309.     def _get_encoding(self):
  310.         return self.encoding
  311.  
  312.     
  313.     def _set_encoding(self, encoding):
  314.         self.encoding = encoding
  315.  
  316.     
  317.     def _get_publicId(self):
  318.         return self.publicId
  319.  
  320.     
  321.     def _set_publicId(self, publicId):
  322.         self.publicId = publicId
  323.  
  324.     
  325.     def _get_systemId(self):
  326.         return self.systemId
  327.  
  328.     
  329.     def _set_systemId(self, systemId):
  330.         self.systemId = systemId
  331.  
  332.     
  333.     def _get_baseURI(self):
  334.         return self.baseURI
  335.  
  336.     
  337.     def _set_baseURI(self, uri):
  338.         self.baseURI = uri
  339.  
  340.  
  341.  
  342. class DOMBuilderFilter:
  343.     '''Element filter which can be used to tailor construction of
  344.     a DOM instance.
  345.     '''
  346.     FILTER_ACCEPT = 1
  347.     FILTER_REJECT = 2
  348.     FILTER_SKIP = 3
  349.     FILTER_INTERRUPT = 4
  350.     whatToShow = NodeFilter.SHOW_ALL
  351.     
  352.     def _get_whatToShow(self):
  353.         return self.whatToShow
  354.  
  355.     
  356.     def acceptNode(self, element):
  357.         return self.FILTER_ACCEPT
  358.  
  359.     
  360.     def startContainer(self, element):
  361.         return self.FILTER_ACCEPT
  362.  
  363.  
  364. del NodeFilter
  365.  
  366. class DocumentLS:
  367.     '''Mixin to create documents that conform to the load/save spec.'''
  368.     async = False
  369.     
  370.     def _get_async(self):
  371.         return False
  372.  
  373.     
  374.     def _set_async(self, async):
  375.         if async:
  376.             raise xml.dom.NotSupportedErr('asynchronous document loading is not supported')
  377.         async
  378.  
  379.     
  380.     def abort(self):
  381.         raise NotImplementedError("haven't figured out what this means yet")
  382.  
  383.     
  384.     def load(self, uri):
  385.         raise NotImplementedError("haven't written this yet")
  386.  
  387.     
  388.     def loadXML(self, source):
  389.         raise NotImplementedError("haven't written this yet")
  390.  
  391.     
  392.     def saveXML(self, snode):
  393.         if snode is None:
  394.             snode = self
  395.         elif snode.ownerDocument is not self:
  396.             raise xml.dom.WrongDocumentErr()
  397.         
  398.         return snode.toxml()
  399.  
  400.  
  401.  
  402. class DOMImplementationLS:
  403.     MODE_SYNCHRONOUS = 1
  404.     MODE_ASYNCHRONOUS = 2
  405.     
  406.     def createDOMBuilder(self, mode, schemaType):
  407.         if schemaType is not None:
  408.             raise xml.dom.NotSupportedErr('schemaType not yet supported')
  409.         schemaType is not None
  410.         if mode == self.MODE_SYNCHRONOUS:
  411.             return DOMBuilder()
  412.         if mode == self.MODE_ASYNCHRONOUS:
  413.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  414.         mode == self.MODE_ASYNCHRONOUS
  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.