home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / ZSI / parse.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  10.7 KB  |  309 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from xml.dom import expatbuilder
  5. from ZSI import _copyright, _children, _attrs, _child_elements, _stringtypes, _backtrace, EvaluateException, ParseException, _valid_encoding, _Node, _find_attr, _resolve_prefix
  6. from ZSI.TC import AnyElement
  7. import types
  8. from ZSI.wstools.Namespaces import SOAP, XMLNS
  9. from ZSI.wstools.Utility import SplitQName
  10.  
  11. _find_actor = lambda E: if not E.getAttributeNS(SOAP.ENV, 'actor') and E.getAttributeNS(SOAP.ENV12, 'actor'):
  12. pass
  13.  
  14. _find_mu = lambda E: if not E.getAttributeNS(SOAP.ENV, 'mustUnderstand') and E.getAttributeNS(SOAP.ENV12, 'mustUnderstand'):
  15. pass
  16.  
  17. _find_root = lambda E: if not E.getAttributeNS(SOAP.ENC, 'root') and E.getAttributeNS(SOAP.ENC12, 'root'):
  18. pass
  19.  
  20. _find_id = lambda E: _find_attr(E, 'id')
  21.  
  22. class DefaultReader:
  23.     fromString = staticmethod(expatbuilder.parseString)
  24.     fromStream = staticmethod(expatbuilder.parse)
  25.  
  26.  
  27. class ParsedSoap:
  28.     defaultReaderClass = DefaultReader
  29.     
  30.     def __init__(self, input, readerclass = None, keepdom = False, trailers = False, resolver = None, envelope = True, **kw):
  31.         self.readerclass = readerclass
  32.         self.keepdom = keepdom
  33.         if not self.readerclass:
  34.             self.readerclass = self.defaultReaderClass
  35.         
  36.         
  37.         try:
  38.             self.reader = self.readerclass()
  39.             if type(input) in _stringtypes:
  40.                 self.dom = self.reader.fromString(input)
  41.             else:
  42.                 self.dom = self.reader.fromStream(input)
  43.         except Exception:
  44.             e = None
  45.             raise 
  46.  
  47.         self.ns_cache = {
  48.             id(self.dom): {
  49.                 'xml': XMLNS.XML,
  50.                 'xmlns': XMLNS.BASE,
  51.                 '': '' } }
  52.         self.trailers = trailers
  53.         self.resolver = resolver
  54.         self.id_cache = { }
  55.         c = _[1]
  56.         if len(c) == 0:
  57.             raise ParseException('Document has no Envelope', 0)
  58.         len(c) == 0
  59.         if len(c) != 1:
  60.             raise ParseException('Document has extra child elements', 0)
  61.         len(c) != 1
  62.         if envelope is False:
  63.             self.body_root = c[0]
  64.             return None
  65.         elt = c[0]
  66.         if elt.localName != 'Envelope' or elt.namespaceURI not in (SOAP.ENV, SOAP.ENV12):
  67.             raise ParseException('Document has "(%s, %s)" element, not (%s, Envelope)' % (elt.namespaceURI, elt.localName, SOAP.ENV), 0)
  68.         elt.namespaceURI not in (SOAP.ENV, SOAP.ENV12)
  69.         self._check_for_legal_children('Envelope', elt)
  70.         for a in _attrs(elt):
  71.             name = a.nodeName
  72.             if name.find(':') == -1 and name not in ('xmlns', 'id'):
  73.                 raise ParseException('Unqualified attribute "' + name + '" in Envelope', 0)
  74.             name not in ('xmlns', 'id')
  75.         
  76.         self.envelope = elt
  77.         if not _valid_encoding(self.envelope):
  78.             raise ParseException('Envelope has invalid encoding', 0)
  79.         _valid_encoding(self.envelope)
  80.         c = _[2]
  81.         if len(c) == 0:
  82.             raise ParseException('Envelope is empty (no Body)', 0)
  83.         len(c) == 0
  84.         elt = c[0]
  85.         if len(c) == 0:
  86.             raise ParseException('Envelope has header but no Body', 0)
  87.         len(c) == 0
  88.         elt = c.pop(0)
  89.         if elt.localName != 'Body' or elt.namespaceURI not in (SOAP.ENV, SOAP.ENV12):
  90.             if self.header:
  91.                 raise ParseException('Header followed by "' + elt.localName + '" element, not Body', 0, elt, self.dom)
  92.             self.header
  93.             raise ParseException('Document has "' + elt.localName + '" element, not Body', 0, elt, self.dom)
  94.         elt.namespaceURI not in (SOAP.ENV, SOAP.ENV12)
  95.         self._check_for_legal_children('Body', elt, 0)
  96.         self._check_for_pi_nodes(_children(elt), 0)
  97.         self.body = elt
  98.         if not _valid_encoding(self.body):
  99.             raise ParseException('Body has invalid encoding', 0)
  100.         _valid_encoding(self.body)
  101.         self.body_root = None
  102.         no = []
  103.         maybe = []
  104.         for elt in _child_elements(self.body):
  105.             root = _find_root(elt)
  106.             if root == '1':
  107.                 if self.body_root:
  108.                     raise ParseException('Multiple seralization roots found', 0, elt, self.dom)
  109.                 self.body_root
  110.                 self.body_root = elt
  111.                 continue
  112.             [] if not self.trailers else []
  113.             if root == '0':
  114.                 no.append(elt)
  115.                 continue
  116.             if not root:
  117.                 maybe.append(elt)
  118.                 continue
  119.             raise ParseException('Illegal value for root attribute', 0, elt, self.dom)
  120.         
  121.         if self.body_root is None:
  122.             if len(maybe):
  123.                 self.body_root = maybe[0]
  124.             else:
  125.                 raise ParseException('No serialization root found', 0, self.body, self.dom)
  126.         len(maybe)
  127.         if not _valid_encoding(self.body_root):
  128.             raise ParseException('Invalid encoding', 0, elt, self.dom)
  129.         _valid_encoding(self.body_root)
  130.         rootid = id(self.body_root)
  131.         self.data_elements = _[3]
  132.         self._check_for_pi_nodes(self.data_elements, 0)
  133.  
  134.     
  135.     def __del__(self):
  136.         
  137.         try:
  138.             if not self.keepdom:
  139.                 self.reader.releaseNode(self.dom)
  140.         except:
  141.             pass
  142.  
  143.  
  144.     
  145.     def _check_for_legal_children(self, name, elt, mustqualify = 1):
  146.         inheader = name == 'Header'
  147.         for n in _children(elt):
  148.             t = n.nodeType
  149.             if t == _Node.COMMENT_NODE:
  150.                 continue
  151.             
  152.             if t != _Node.ELEMENT_NODE:
  153.                 if t == _Node.TEXT_NODE and n.nodeValue.strip() == '':
  154.                     continue
  155.                 
  156.                 raise ParseException('Non-element child in ' + name, inheader, elt, self.dom)
  157.             t != _Node.ELEMENT_NODE
  158.             if mustqualify and not (n.namespaceURI):
  159.                 raise ParseException('Unqualified element "' + n.nodeName + '" in ' + name, inheader, elt, self.dom)
  160.             not (n.namespaceURI)
  161.         
  162.  
  163.     
  164.     def _check_for_pi_nodes(self, list, inheader):
  165.         list = list[:]
  166.         while list:
  167.             elt = list.pop()
  168.             t = elt.nodeType
  169.             if t == _Node.PROCESSING_INSTRUCTION_NODE:
  170.                 raise ParseException('Found processing instruction "<?' + elt.nodeName + '...>"', inheader, elt.parentNode, self.dom)
  171.             t == _Node.PROCESSING_INSTRUCTION_NODE
  172.             if t == _Node.DOCUMENT_TYPE_NODE:
  173.                 raise ParseException('Found DTD', inheader, elt.parentNode, self.dom)
  174.             t == _Node.DOCUMENT_TYPE_NODE
  175.             list += _children(elt)
  176.  
  177.     
  178.     def Backtrace(self, elt):
  179.         return _backtrace(elt, self.dom)
  180.  
  181.     
  182.     def FindLocalHREF(self, href, elt, headers = 1):
  183.         if href[0] != '#':
  184.             raise EvaluateException('Absolute HREF ("%s") not implemented' % href, self.Backtrace(elt))
  185.         href[0] != '#'
  186.         frag = href[1:]
  187.         e = self.id_cache.get(frag)
  188.         if e:
  189.             return e
  190.         list = self.data_elements[:] + [
  191.             self.body_root]
  192.         if headers:
  193.             list.extend(self.header_elements)
  194.         
  195.         while list:
  196.             e = list.pop()
  197.             if e.nodeType == _Node.ELEMENT_NODE:
  198.                 nodeid = _find_id(e)
  199.                 if nodeid:
  200.                     self.id_cache[nodeid] = e
  201.                     if nodeid == frag:
  202.                         return e
  203.                 
  204.             
  205.             list += _children(e)
  206.         raise EvaluateException('Can\'t find node for HREF "%s"' % href, self.Backtrace(elt))
  207.  
  208.     
  209.     def ResolveHREF(self, uri, tc, **keywords):
  210.         r = getattr(tc, 'resolver', self.resolver)
  211.         if not r:
  212.             raise EvaluateException('No resolver for "' + uri + '"')
  213.         r
  214.         
  215.         try:
  216.             if type(uri) == types.UnicodeType:
  217.                 uri = str(uri)
  218.             
  219.             retval = r(uri, tc, self, **keywords)
  220.         except Exception:
  221.             e = None
  222.             raise EvaluateException('Can\'t resolve "' + uri + '" (' + str(e.__class__) + '): ' + str(e))
  223.  
  224.         return retval
  225.  
  226.     
  227.     def GetMyHeaderElements(self, actorlist = None):
  228.         if actorlist is None:
  229.             actorlist = [
  230.                 None,
  231.                 SOAP.ACTOR_NEXT]
  232.         else:
  233.             actorlist = list(actorlist) + [
  234.                 None,
  235.                 SOAP.ACTOR_NEXT]
  236.         return _[1]
  237.  
  238.     
  239.     def GetElementNSdict(self, elt):
  240.         d = self.ns_cache.get(id(elt))
  241.         if not d:
  242.             if elt != self.dom:
  243.                 d = self.GetElementNSdict(elt.parentNode)
  244.             
  245.             for a in _attrs(elt):
  246.                 if a.namespaceURI == XMLNS.BASE:
  247.                     if a.localName == 'xmlns':
  248.                         d[''] = a.nodeValue
  249.                     else:
  250.                         d[a.localName] = a.nodeValue
  251.                 a.localName == 'xmlns'
  252.             
  253.             self.ns_cache[id(elt)] = d
  254.         
  255.         return d.copy()
  256.  
  257.     
  258.     def GetDomAndReader(self):
  259.         return (self.dom, self.reader)
  260.  
  261.     
  262.     def IsAFault(self):
  263.         e = self.body_root
  264.         if not e:
  265.             return 0
  266.         if e.namespaceURI in (SOAP.ENV, SOAP.ENV12):
  267.             pass
  268.         return e.localName == 'Fault'
  269.  
  270.     
  271.     def Parse(self, how):
  272.         if type(how) == types.ClassType:
  273.             how = how.typecode
  274.         
  275.         return how.parse(self.body_root, self)
  276.  
  277.     
  278.     def WhatMustIUnderstand(self):
  279.         return _[1]
  280.  
  281.     
  282.     def WhatActorsArePresent(self):
  283.         results = []
  284.         for E in self.header_elements:
  285.             a = _find_actor(E)
  286.             if a not in [
  287.                 None,
  288.                 SOAP.ACTOR_NEXT]:
  289.                 results.append(a)
  290.                 continue
  291.         
  292.         return results
  293.  
  294.     
  295.     def ParseHeaderElements(self, ofwhat):
  296.         d = { }
  297.         lenofwhat = len(ofwhat)
  298.         c = self.header_elements[:]
  299.         crange = range(len(self.header_elements))
  300.         for i in range(lenofwhat):
  301.             pass
  302.         
  303.         return d
  304.  
  305.  
  306. if __name__ == '__main__':
  307.     print _copyright
  308.  
  309.