home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / xmlextra.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  11.4 KB  |  364 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: xmlextra.py,v 1.15 2004/10/11 18:33:51 jajcus Exp $'
  5. __docformat__ = 'restructuredtext en'
  6. import sys
  7. import libxml2
  8. import threading
  9. import re
  10. import logging
  11. from pyxmpp.exceptions import StreamParseError
  12. common_doc = libxml2.newDoc('1.0')
  13. common_root = common_doc.newChild(None, 'root', None)
  14. COMMON_NS = 'http://pyxmpp.jajcus.net/xmlns/common'
  15. common_ns = common_root.newNs(COMMON_NS, None)
  16. common_root.setNs(common_ns)
  17. common_doc.setRootElement(common_root)
  18. logger = logging.getLogger('pyxmpp.xmlextra')
  19.  
  20. class StreamHandler:
  21.     
  22.     def __init__(self):
  23.         pass
  24.  
  25.     
  26.     def _stream_start(self, _doc):
  27.         doc = libxml2.xmlDoc(_doc)
  28.         self.stream_start(doc)
  29.  
  30.     
  31.     def _stream_end(self, _doc):
  32.         doc = libxml2.xmlDoc(_doc)
  33.         self.stream_end(doc)
  34.  
  35.     
  36.     def _stanza(self, _doc, _node):
  37.         doc = libxml2.xmlDoc(_doc)
  38.         node = libxml2.xmlNode(_node)
  39.         self.stanza(doc, node)
  40.  
  41.     
  42.     def stream_start(self, doc):
  43.         print >>sys.stderr, 'Unhandled stream start:', `doc.serialize()`
  44.  
  45.     
  46.     def stream_end(self, doc):
  47.         print >>sys.stderr, 'Unhandled stream end', `doc.serialize()`
  48.  
  49.     
  50.     def stanza(self, _unused, node):
  51.         print >>sys.stderr, 'Unhandled stanza', `node.serialize()`
  52.  
  53.     
  54.     def error(self, descr):
  55.         raise StreamParseError, descr
  56.  
  57.     
  58.     def warning(self, desc):
  59.         if desc.startswith('xmlns: URI vcard-temp is not absolute'):
  60.             return None
  61.         if desc.startswith('xmlns: http://www.xmpp.org/extensions/xep-0084.html#'):
  62.             return None
  63.         logger.warning('XML STREAM WARNING: {0}'.format(desc))
  64.  
  65.  
  66.  
  67. try:
  68.     import _xmlextra
  69.     from _xmlextra import error
  70. except ImportError:
  71.     print >>sys.stderr, 'WARNING: using SLOW xmlextra'
  72.     
  73.     class error(Exception):
  74.         pass
  75.  
  76.     
  77.     def _escape(data):
  78.         data = data.replace('&', '&')
  79.         data = data.replace('<', '<')
  80.         data = data.replace('>', '>')
  81.         data = data.replace("'", ''')
  82.         data = data.replace('"', '"')
  83.         return data
  84.  
  85.     
  86.     class _SAXCallback(libxml2.SAXCallback):
  87.         
  88.         def __init__(self, handler):
  89.             self._handler = handler
  90.             self._head = ''
  91.             self._tail = ''
  92.             self._current = ''
  93.             self._level = 0
  94.             self._doc = None
  95.             self._root = None
  96.  
  97.         
  98.         def cdataBlock(self, data):
  99.             if self._level > 1:
  100.                 self._current += _escape(data)
  101.             
  102.  
  103.         
  104.         def characters(self, data):
  105.             if self._level > 1:
  106.                 self._current += _escape(data)
  107.             
  108.  
  109.         
  110.         def comment(self, content):
  111.             pass
  112.  
  113.         
  114.         def endDocument(self):
  115.             pass
  116.  
  117.         
  118.         def endElement(self, tag):
  119.             self._current += '</%s>' % (tag,)
  120.             self._level -= 1
  121.             if self._level > 1:
  122.                 return None
  123.  
  124.         
  125.         def error(self, msg):
  126.             self._handler.error(msg)
  127.  
  128.         fatalError = error
  129.         ignorableWhitespace = characters
  130.         
  131.         def reference(self, name):
  132.             self._current += '&' + name + ';'
  133.  
  134.         
  135.         def startDocument(self):
  136.             pass
  137.  
  138.         
  139.         def startElement(self, tag, attrs):
  140.             s = '<' + tag
  141.             if attrs:
  142.                 for a, v in attrs.items():
  143.                     s += " %s='%s'" % (a, _escape(v))
  144.                 
  145.             
  146.             s += '>'
  147.             if self._level == 0:
  148.                 self._head = s
  149.                 self._tail = '</%s>' % (tag,)
  150.                 xml = self._head + self._tail
  151.                 self._doc = libxml2.parseDoc(xml)
  152.                 self._handler.stream_start(self._doc)
  153.                 self._root = self._doc.getRootElement()
  154.             elif self._level == 1:
  155.                 self._current = s
  156.             else:
  157.                 self._current += s
  158.             self._level += 1
  159.  
  160.         
  161.         def warning(self):
  162.             pass
  163.  
  164.  
  165.     
  166.     class _PythonReader:
  167.         
  168.         def __init__(self, handler):
  169.             self.handler = handler
  170.             self.sax = _SAXCallback(handler)
  171.             self.parser = libxml2.createPushParser(self.sax, '', 0, 'stream')
  172.  
  173.         
  174.         def feed(self, data):
  175.             return self.parser.parseChunk(data, len(data), 0)
  176.  
  177.  
  178.     _create_reader = _PythonReader
  179.     
  180.     def _get_ns(node):
  181.         
  182.         try:
  183.             return node.ns()
  184.         except libxml2.treeError:
  185.             return None
  186.  
  187.  
  188.     
  189.     def replace_ns(node, old_ns, new_ns):
  190.         if old_ns is not None:
  191.             old_ns_uri = old_ns.content
  192.             old_ns_prefix = old_ns.name
  193.         else:
  194.             old_ns_uri = None
  195.             old_ns_prefix = None
  196.         ns = _get_ns(node)
  197.         if ns is None and old_ns is None:
  198.             node.setNs(new_ns)
  199.         elif ns and ns.content == old_ns_uri and ns.name == old_ns_prefix:
  200.             node.setNs(new_ns)
  201.         
  202.         p = node.properties
  203.         while p:
  204.             ns = _get_ns(p)
  205.             if ns is None and old_ns is None:
  206.                 p.setNs(new_ns)
  207.             
  208.             if ns and ns.content == old_ns_uri and ns.name == old_ns_prefix:
  209.                 p.setNs(new_ns)
  210.             
  211.             p = p.next
  212.         n = node.children
  213.         while n:
  214.             if n.type == 'element':
  215.                 skip_element = False
  216.                 
  217.                 try:
  218.                     nsd = n.nsDefs()
  219.                 except libxml2.treeError:
  220.                     nsd = None
  221.  
  222.                 while nsd:
  223.                     if nsd.name == old_ns_prefix:
  224.                         skip_element = True
  225.                         break
  226.                     
  227.                     nsd = nsd.next
  228.                 if not skip_element:
  229.                     replace_ns(n, old_ns, new_ns)
  230.                 
  231.             
  232.             n = n.next
  233.  
  234.     pure_python = True
  235.  
  236. _create_reader = _xmlextra.sax_reader_new
  237.  
  238. def replace_ns(node, old_ns, new_ns):
  239.     if old_ns is None:
  240.         old_ns__o = None
  241.     else:
  242.         old_ns__o = old_ns._o
  243.     if new_ns is None:
  244.         new_ns__o = None
  245.     else:
  246.         new_ns__o = new_ns._o
  247.     if node is None:
  248.         node__o = None
  249.     else:
  250.         node__o = node._o
  251.     _xmlextra.replace_ns(node__o, old_ns__o, new_ns__o)
  252.     if old_ns__o:
  253.         _xmlextra.remove_ns(node__o, old_ns__o)
  254.     
  255.  
  256. pure_python = False
  257.  
  258. def get_node_ns(xmlnode):
  259.     
  260.     try:
  261.         return xmlnode.ns()
  262.     except libxml2.treeError:
  263.         return None
  264.  
  265.  
  266.  
  267. def get_node_ns_uri(xmlnode):
  268.     ns = get_node_ns(xmlnode)
  269.     if ns:
  270.         return unicode(ns.getContent(), 'utf-8')
  271.     return None
  272.  
  273.  
  274. def xml_node_iter(nodelist):
  275.     node = nodelist
  276.     while node:
  277.         yield node
  278.         node = node.next
  279.  
  280.  
  281. def xml_element_iter(nodelist):
  282.     node = nodelist
  283.     while node:
  284.         if node.type == 'element':
  285.             yield node
  286.         
  287.         node = node.next
  288.  
  289.  
  290. def xml_element_ns_iter(nodelist, ns_uri):
  291.     node = nodelist
  292.     while node:
  293.         if node.type == 'element' and get_node_ns_uri(node) == ns_uri:
  294.             yield node
  295.         
  296.         node = node.next
  297.  
  298. evil_characters_re = re.compile('[\\000-\\010\\013\\014\\016-\\037]', re.UNICODE)
  299. utf8_replacement_char = u'∩┐╜'.encode('utf-8')
  300.  
  301. def remove_evil_characters(s):
  302.     if isinstance(s, unicode):
  303.         return evil_characters_re.sub(u'∩┐╜', s)
  304.     return evil_characters_re.sub(utf8_replacement_char, s)
  305.  
  306. bad_nsdef_replace_re = re.compile('^([^<]*\\<[^><]*\\s+)(xmlns=((\\"[^\\"]*\\")|(\\\'[^\\\']*\\\')))')
  307.  
  308. def safe_serialize(xmlnode):
  309.     
  310.     try:
  311.         ns = xmlnode.ns()
  312.     except libxml2.treeError:
  313.         ns = None
  314.  
  315.     
  316.     try:
  317.         nsdef = xmlnode.nsDefs()
  318.     except libxml2.treeError:
  319.         nsdef = None
  320.  
  321.     s = xmlnode.serialize(encoding = 'UTF-8')
  322.     while nsdef:
  323.         if nsdef.name is None:
  324.             if not ns or (nsdef.name, nsdef.content) != (ns.name, ns.content):
  325.                 s = bad_nsdef_replace_re.sub('\\1', s, 1)
  326.                 break
  327.             
  328.         nsdef = nsdef.next
  329.     s = remove_evil_characters(s)
  330.     return s
  331.  
  332.  
  333. class StreamReader:
  334.     
  335.     def __init__(self, handler):
  336.         self.reader = _create_reader(handler)
  337.         self.lock = threading.RLock()
  338.         self.in_use = 0
  339.  
  340.     
  341.     def doc(self):
  342.         ret = self.reader.doc()
  343.         if ret:
  344.             return libxml2.xmlDoc(ret)
  345.         return None
  346.  
  347.     
  348.     def feed(self, s):
  349.         self.lock.acquire()
  350.         if self.in_use:
  351.             self.lock.release()
  352.             raise StreamParseError, 'StreamReader.feed() is not reentrant!'
  353.         self.in_use
  354.         self.in_use = 1
  355.         
  356.         try:
  357.             return self.reader.feed(s)
  358.         finally:
  359.             self.in_use = 0
  360.             self.lock.release()
  361.  
  362.  
  363.  
  364.