home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / xmlbuilder.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2003-12-30  |  19KB  |  427 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.3)
  3.  
  4. """Implementation of the DOM Level 3 'LS-Load' feature."""
  5. import copy
  6. import xml.dom as xml
  7. from xml.dom.minicompat import *
  8. from xml.dom.NodeFilter import NodeFilter
  9. __all__ = [
  10.     'DOMBuilder',
  11.     'DOMEntityResolver',
  12.     'DOMInputSource']
  13.  
  14. class Options:
  15.     '''Features object that has variables set for each DOMBuilder feature.
  16.  
  17.     The DOMBuilder class uses an instance of this class to pass settings to
  18.     the ExpatBuilder class.
  19.     '''
  20.     namespaces = 1
  21.     namespace_declarations = True
  22.     validation = False
  23.     external_parameter_entities = True
  24.     external_general_entities = True
  25.     external_dtd_subset = True
  26.     validate_if_schema = False
  27.     validate = False
  28.     datatype_normalization = False
  29.     create_entity_ref_nodes = True
  30.     entities = True
  31.     whitespace_in_element_content = True
  32.     cdata_sections = True
  33.     comments = True
  34.     charset_overrides_xml_encoding = True
  35.     infoset = False
  36.     supported_mediatypes_only = False
  37.     errorHandler = None
  38.     filter = None
  39.  
  40.  
  41. class DOMBuilder:
  42.     entityResolver = None
  43.     errorHandler = None
  44.     filter = None
  45.     ACTION_REPLACE = 1
  46.     ACTION_APPEND_AS_CHILDREN = 2
  47.     ACTION_INSERT_AFTER = 3
  48.     ACTION_INSERT_BEFORE = 4
  49.     _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)
  50.     
  51.     def __init__(self):
  52.         self._options = Options()
  53.  
  54.     
  55.     def _get_entityResolver(self):
  56.         return self.entityResolver
  57.  
  58.     
  59.     def _set_entityResolver(self, entityResolver):
  60.         self.entityResolver = entityResolver
  61.  
  62.     
  63.     def _get_errorHandler(self):
  64.         return self.errorHandler
  65.  
  66.     
  67.     def _set_errorHandler(self, errorHandler):
  68.         self.errorHandler = errorHandler
  69.  
  70.     
  71.     def _get_filter(self):
  72.         return self.filter
  73.  
  74.     
  75.     def _set_filter(self, filter):
  76.         self.filter = filter
  77.  
  78.     
  79.     def setFeature(self, name, state):
  80.         if self.supportsFeature(name):
  81.             if not state and 1:
  82.                 pass
  83.             state = 0
  84.             
  85.             try:
  86.                 settings = self._settings[(_name_xform(name), state)]
  87.             except KeyError:
  88.                 raise xml.dom.NotSupportedErr('unsupported feature: ' + `name`)
  89.  
  90.             for name, value in settings:
  91.                 setattr(self._options, name, value)
  92.             
  93.         else:
  94.             raise xml.dom.NotFoundErr('unknown feature: ' + repr(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 and 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.             
  180.             raise xml.dom.NotFoundErr('feature %s not known' % repr(name))
  181.  
  182.  
  183.     
  184.     def parseURI(self, uri):
  185.         if self.entityResolver:
  186.             input = self.entityResolver.resolveEntity(None, uri)
  187.         else:
  188.             input = DOMEntityResolver().resolveEntity(None, uri)
  189.         return self.parse(input)
  190.  
  191.     
  192.     def parse(self, input):
  193.         options = copy.copy(self._options)
  194.         options.filter = self.filter
  195.         options.errorHandler = self.errorHandler
  196.         fp = input.byteStream
  197.         if fp is None and options.systemId:
  198.             import urllib2
  199.             fp = urllib2.urlopen(input.systemId)
  200.         
  201.         return self._parse_bytestream(fp, options)
  202.  
  203.     
  204.     def parseWithContext(self, input, cnode, action):
  205.         if action not in self._legal_actions:
  206.             raise ValueError('not a legal action')
  207.         
  208.         raise NotImplementedError("Haven't written this yet...")
  209.  
  210.     
  211.     def _parse_bytestream(self, stream, options):
  212.         import xml.dom.expatbuilder as xml
  213.         builder = xml.dom.expatbuilder.makeBuilder(options)
  214.         return builder.parseFile(stream)
  215.  
  216.  
  217.  
  218. def _name_xform(name):
  219.     return name.lower().replace('-', '_')
  220.  
  221.  
  222. class DOMEntityResolver(NewStyle):
  223.     __slots__ = ('_opener',)
  224.     
  225.     def resolveEntity(self, publicId, systemId):
  226.         if not systemId is not None:
  227.             raise AssertionError
  228.         source = DOMInputSource()
  229.         source.publicId = publicId
  230.         source.systemId = systemId
  231.         source.byteStream = self._get_opener().open(systemId)
  232.         source.encoding = self._guess_media_encoding(source)
  233.         import posixpath
  234.         import urlparse
  235.         parts = urlparse.urlparse(systemId)
  236.         (scheme, netloc, path, params, query, fragment) = parts
  237.         if path and not path.endswith('/'):
  238.             path = posixpath.dirname(path) + '/'
  239.             parts = (scheme, netloc, path, params, query, fragment)
  240.             source.baseURI = urlparse.urlunparse(parts)
  241.         
  242.         return source
  243.  
  244.     
  245.     def _get_opener(self):
  246.         
  247.         try:
  248.             return self._opener
  249.         except AttributeError:
  250.             self._opener = self._create_opener()
  251.             return self._opener
  252.  
  253.  
  254.     
  255.     def _create_opener(self):
  256.         import urllib2
  257.         return urllib2.build_opener()
  258.  
  259.     
  260.     def _guess_media_encoding(self, source):
  261.         info = source.byteStream.info()
  262.         if info.has_key('Content-Type'):
  263.             for param in info.getplist():
  264.                 if param.startswith('charset='):
  265.                     return param.split('=', 1)[1].lower()
  266.                     continue
  267.             
  268.         
  269.  
  270.  
  271.  
  272. class DOMInputSource(NewStyle):
  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.         
  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.         
  410.         if mode == self.MODE_SYNCHRONOUS:
  411.             return DOMBuilder()
  412.         
  413.         if mode == self.MODE_ASYNCHRONOUS:
  414.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  415.         
  416.         raise ValueError('unknown value for mode')
  417.  
  418.     
  419.     def createDOMWriter(self):
  420.         raise NotImplementedError("the writer interface hasn't been written yet!")
  421.  
  422.     
  423.     def createDOMInputSource(self):
  424.         return DOMInputSource()
  425.  
  426.  
  427.