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.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2003-12-30  |  19KB  |  425 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (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.         source = DOMInputSource()
  227.         source.publicId = publicId
  228.         source.systemId = systemId
  229.         source.byteStream = self._get_opener().open(systemId)
  230.         source.encoding = self._guess_media_encoding(source)
  231.         import posixpath
  232.         import urlparse
  233.         parts = urlparse.urlparse(systemId)
  234.         (scheme, netloc, path, params, query, fragment) = parts
  235.         if path and not path.endswith('/'):
  236.             path = posixpath.dirname(path) + '/'
  237.             parts = (scheme, netloc, path, params, query, fragment)
  238.             source.baseURI = urlparse.urlunparse(parts)
  239.         
  240.         return source
  241.  
  242.     
  243.     def _get_opener(self):
  244.         
  245.         try:
  246.             return self._opener
  247.         except AttributeError:
  248.             self._opener = self._create_opener()
  249.             return self._opener
  250.  
  251.  
  252.     
  253.     def _create_opener(self):
  254.         import urllib2
  255.         return urllib2.build_opener()
  256.  
  257.     
  258.     def _guess_media_encoding(self, source):
  259.         info = source.byteStream.info()
  260.         if info.has_key('Content-Type'):
  261.             for param in info.getplist():
  262.                 if param.startswith('charset='):
  263.                     return param.split('=', 1)[1].lower()
  264.                     continue
  265.             
  266.         
  267.  
  268.  
  269.  
  270. class DOMInputSource(NewStyle):
  271.     __slots__ = ('byteStream', 'characterStream', 'stringData', 'encoding', 'publicId', 'systemId', 'baseURI')
  272.     
  273.     def __init__(self):
  274.         self.byteStream = None
  275.         self.characterStream = None
  276.         self.stringData = None
  277.         self.encoding = None
  278.         self.publicId = None
  279.         self.systemId = None
  280.         self.baseURI = None
  281.  
  282.     
  283.     def _get_byteStream(self):
  284.         return self.byteStream
  285.  
  286.     
  287.     def _set_byteStream(self, byteStream):
  288.         self.byteStream = byteStream
  289.  
  290.     
  291.     def _get_characterStream(self):
  292.         return self.characterStream
  293.  
  294.     
  295.     def _set_characterStream(self, characterStream):
  296.         self.characterStream = characterStream
  297.  
  298.     
  299.     def _get_stringData(self):
  300.         return self.stringData
  301.  
  302.     
  303.     def _set_stringData(self, data):
  304.         self.stringData = data
  305.  
  306.     
  307.     def _get_encoding(self):
  308.         return self.encoding
  309.  
  310.     
  311.     def _set_encoding(self, encoding):
  312.         self.encoding = encoding
  313.  
  314.     
  315.     def _get_publicId(self):
  316.         return self.publicId
  317.  
  318.     
  319.     def _set_publicId(self, publicId):
  320.         self.publicId = publicId
  321.  
  322.     
  323.     def _get_systemId(self):
  324.         return self.systemId
  325.  
  326.     
  327.     def _set_systemId(self, systemId):
  328.         self.systemId = systemId
  329.  
  330.     
  331.     def _get_baseURI(self):
  332.         return self.baseURI
  333.  
  334.     
  335.     def _set_baseURI(self, uri):
  336.         self.baseURI = uri
  337.  
  338.  
  339.  
  340. class DOMBuilderFilter:
  341.     '''Element filter which can be used to tailor construction of
  342.     a DOM instance.
  343.     '''
  344.     FILTER_ACCEPT = 1
  345.     FILTER_REJECT = 2
  346.     FILTER_SKIP = 3
  347.     FILTER_INTERRUPT = 4
  348.     whatToShow = NodeFilter.SHOW_ALL
  349.     
  350.     def _get_whatToShow(self):
  351.         return self.whatToShow
  352.  
  353.     
  354.     def acceptNode(self, element):
  355.         return self.FILTER_ACCEPT
  356.  
  357.     
  358.     def startContainer(self, element):
  359.         return self.FILTER_ACCEPT
  360.  
  361.  
  362. del NodeFilter
  363.  
  364. class DocumentLS:
  365.     '''Mixin to create documents that conform to the load/save spec.'''
  366.     async = False
  367.     
  368.     def _get_async(self):
  369.         return False
  370.  
  371.     
  372.     def _set_async(self, async):
  373.         if async:
  374.             raise xml.dom.NotSupportedErr('asynchronous document loading is not supported')
  375.         
  376.  
  377.     
  378.     def abort(self):
  379.         raise NotImplementedError("haven't figured out what this means yet")
  380.  
  381.     
  382.     def load(self, uri):
  383.         raise NotImplementedError("haven't written this yet")
  384.  
  385.     
  386.     def loadXML(self, source):
  387.         raise NotImplementedError("haven't written this yet")
  388.  
  389.     
  390.     def saveXML(self, snode):
  391.         if snode is None:
  392.             snode = self
  393.         elif snode.ownerDocument is not self:
  394.             raise xml.dom.WrongDocumentErr()
  395.         
  396.         return snode.toxml()
  397.  
  398.  
  399.  
  400. class DOMImplementationLS:
  401.     MODE_SYNCHRONOUS = 1
  402.     MODE_ASYNCHRONOUS = 2
  403.     
  404.     def createDOMBuilder(self, mode, schemaType):
  405.         if schemaType is not None:
  406.             raise xml.dom.NotSupportedErr('schemaType not yet supported')
  407.         
  408.         if mode == self.MODE_SYNCHRONOUS:
  409.             return DOMBuilder()
  410.         
  411.         if mode == self.MODE_ASYNCHRONOUS:
  412.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  413.         
  414.         raise ValueError('unknown value for mode')
  415.  
  416.     
  417.     def createDOMWriter(self):
  418.         raise NotImplementedError("the writer interface hasn't been written yet!")
  419.  
  420.     
  421.     def createDOMInputSource(self):
  422.         return DOMInputSource()
  423.  
  424.  
  425.