home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / ZSI / ServiceProxy.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  10.6 KB  |  335 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import weakref
  5. import re
  6. import os
  7. import sys
  8. from ConfigParser import SafeConfigParser as ConfigParser, NoSectionError, NoOptionError
  9. from urlparse import urlparse
  10. from ZSI import TC
  11. from ZSI.client import _Binding
  12. from ZSI.generate import commands, containers
  13. from ZSI.schema import GED, GTD
  14. import wstools
  15.  
  16. def _urn_to_module(urn):
  17.     return '%s_types' % re.sub(_urn_to_module.regex, '_', urn)
  18.  
  19. _urn_to_module.regex = re.compile('[\\W]')
  20.  
  21. class ServiceProxy:
  22.     
  23.     def __init__(self, wsdl, url = None, service = None, port = None, cachedir = os.path.join(os.path.expanduser('~'), '.zsi_service_proxy_dir'), asdict = True, lazy = False, pyclass = False, force = False, **kw):
  24.         self._asdict = asdict
  25.         self._url = url
  26.         self._kw = kw
  27.         self._wsdl = wstools.WSDLTools.WSDLReader().loadFromURL(wsdl)
  28.         if not service:
  29.             pass
  30.         self._service = self._wsdl.services[0]
  31.         self.__doc__ = self._service.documentation
  32.         if not port:
  33.             pass
  34.         self._port = self._service.ports[0]
  35.         self._name = self._service.name
  36.         self._methods = { }
  37.         self._cachedir = cachedir
  38.         self._lazy = lazy
  39.         self._pyclass = pyclass
  40.         self._force = force
  41.         port = self._port
  42.         binding = port.getBinding()
  43.         portType = binding.getPortType()
  44.         for port in self._service.ports:
  45.             for item in port.getPortType().operations:
  46.                 
  47.                 try:
  48.                     callinfo = wstools.WSDLTools.callInfoFromWSDL(port, item.name)
  49.                 except:
  50.                     continue
  51.  
  52.                 method = MethodProxy(self, callinfo)
  53.                 setattr(self, item.name, method)
  54.                 self._methods.setdefault(item.name, []).append(method)
  55.             
  56.         
  57.         self._mod = self._load(wsdl)
  58.  
  59.     
  60.     def _load(self, location):
  61.         cachedir = self._cachedir
  62.         if not os.path.isdir(cachedir):
  63.             os.mkdir(cachedir)
  64.         
  65.         file = os.path.join(cachedir, '.cache')
  66.         section = 'TYPES'
  67.         cp = ConfigParser()
  68.         
  69.         try:
  70.             cp.readfp(open(file, 'r'))
  71.         except IOError:
  72.             del cp
  73.             cp = None
  74.  
  75.         option = location.replace(':', '-')
  76.         if not (self._force) and cp is not None and cp.has_section(section) and cp.has_option(section, option):
  77.             types = cp.get(section, option)
  78.         elif not self._pyclass:
  79.             
  80.             containers.ContainerBase.func_aname = lambda instnc, n: str(n)
  81.         
  82.         args = [
  83.             '-o',
  84.             cachedir,
  85.             location]
  86.         if self._lazy:
  87.             args.insert(0, '-l')
  88.         
  89.         if self._pyclass:
  90.             args.insert(0, '-b')
  91.         
  92.         files = commands.wsdl2py(args)
  93.         if cp is None:
  94.             cp = ConfigParser()
  95.         
  96.         if not cp.has_section(section):
  97.             cp.add_section(section)
  98.         
  99.         types = filter((lambda f: f.endswith('_types.py')), files)[0]
  100.         cp.set(section, option, types)
  101.         cp.write(open(file, 'w'))
  102.         if os.path.abspath(cachedir) not in sys.path:
  103.             sys.path.append(os.path.abspath(cachedir))
  104.         
  105.         mod = os.path.split(types)[-1].rstrip('.py')
  106.         return __import__(mod)
  107.  
  108.     
  109.     def _load_schema(self, location, xml = None):
  110.         cachedir = self._cachedir
  111.         if not os.path.isdir(cachedir):
  112.             os.mkdir(cachedir)
  113.         
  114.         file = os.path.join(cachedir, '.cache')
  115.         section = 'TYPES'
  116.         cp = ConfigParser()
  117.         
  118.         try:
  119.             cp.readfp(open(file, 'r'))
  120.         except IOError:
  121.             del cp
  122.             cp = None
  123.  
  124.         option = location.replace(':', '-')
  125.         if cp is not None and cp.has_section(section) and cp.has_option(section, option):
  126.             types = cp.get(section, option)
  127.         elif not self._pyclass:
  128.             
  129.             containers.ContainerBase.func_aname = lambda instnc, n: str(n)
  130.         
  131.         XMLSchema = XMLSchema
  132.         import ZSI.wstools
  133.         reader = XMLSchema.SchemaReader(base_url = location)
  134.         if xml is not None and isinstance(xml, basestring):
  135.             schema = reader.loadFromString(xml)
  136.         elif xml is not None:
  137.             raise RuntimeError, 'Unsupported: XML must be string'
  138.         elif not os.path.isfile(location):
  139.             schema = reader.loadFromURL(location)
  140.         else:
  141.             schema = reader.reader.loadFromFile(location)
  142.         
  143.         class options('options', ()):
  144.             output_dir = cachedir
  145.             schema = True
  146.             simple_naming = False
  147.             address = False
  148.             lazy = self._lazy
  149.             complexType = self._pyclass
  150.  
  151.         schema.location = location
  152.         files = commands._wsdl2py(options, schema)
  153.         if cp is None:
  154.             cp = ConfigParser()
  155.         
  156.         if not cp.has_section(section):
  157.             cp.add_section(section)
  158.         
  159.         types = filter((lambda f: f.endswith('_types.py')), files)[0]
  160.         cp.set(section, option, types)
  161.         cp.write(open(file, 'w'))
  162.         if os.path.abspath(cachedir) not in sys.path:
  163.             sys.path.append(os.path.abspath(cachedir))
  164.         
  165.         mod = os.path.split(types)[-1].rstrip('.py')
  166.         return __import__(mod)
  167.  
  168.     
  169.     def _call(self, name, soapheaders):
  170.         
  171.         def call_closure(*args, **kwargs):
  172.             if len(args) and len(kwargs):
  173.                 raise TypeError, 'Use positional or keyword argument only.'
  174.             len(kwargs)
  175.             if len(args) > 0:
  176.                 raise TypeError, 'Not supporting SOAPENC:Arrays or XSD:List'
  177.             len(args) > 0
  178.             if len(kwargs):
  179.                 args = kwargs
  180.             
  181.             callinfo = getattr(self, name).callinfo
  182.             for method in self._methods[name]:
  183.                 if len(method.callinfo.inparams) == len(kwargs):
  184.                     callinfo = method.callinfo
  185.                     continue
  186.             
  187.             if not self._url:
  188.                 pass
  189.             binding = _Binding(url = callinfo.location, soapaction = callinfo.soapAction, **self._kw)
  190.             kw = dict(unique = True)
  191.             if callinfo.use == 'encoded':
  192.                 kw['unique'] = False
  193.             
  194.             if callinfo.style == 'rpc':
  195.                 request = TC.Struct(None, ofwhat = [], pname = (callinfo.namespace, name), **kw)
  196.                 response = TC.Struct(None, ofwhat = [], pname = (callinfo.namespace, name + 'Response'), **kw)
  197.                 if len(callinfo.getInParameters()) != len(args):
  198.                     raise RuntimeError('expecting "%s" parts, got %s' % str(callinfo.getInParameters(), str(args)))
  199.                 len(callinfo.getInParameters()) != len(args)
  200.                 for msg, pms in ((request, callinfo.getInParameters()), (response, callinfo.getOutParameters())):
  201.                     msg.ofwhat = []
  202.                     for klass in pms:
  203.                         part = None
  204.                         if klass is None:
  205.                             if part.type:
  206.                                 klass = (filter,)((lambda gt: part.type == gt.type), TC.TYPES)
  207.                                 if len(klass) == 0:
  208.                                     klass = (filter,)((lambda gt: part.type[1] == gt.type[1]), TC.TYPES)
  209.                                     if not len(klass):
  210.                                         klass = [
  211.                                             TC.Any]
  212.                                     
  213.                                 
  214.                                 if len(klass) > 1:
  215.                                     klass = filter((lambda i: i.__dict__.has_key('type')), klass)
  216.                                 
  217.                                 klass = klass[0]
  218.                             else:
  219.                                 klass = TC.Any
  220.                         
  221.                         msg.ofwhat.append(klass(part.name))
  222.                     
  223.                     msg.ofwhat = tuple(msg.ofwhat)
  224.                 
  225.                 if not args:
  226.                     args = { }
  227.                 
  228.             else:
  229.                 ipart = callinfo.getInParameters()
  230.                 opart = callinfo.getOutParameters()
  231.                 if len(ipart) != 1 and not (ipart[0].element_type) or ipart[0].type is None:
  232.                     raise RuntimeError, 'Bad Input Message "%s"' % callinfo.name
  233.                 ipart[0].type is None
  234.                 if len(opart) not in (0, 1) and not (opart[0].element_type) or opart[0].type is None:
  235.                     raise RuntimeError, 'Bad Output Message "%s"' % callinfo.name
  236.                 opart[0].type is None
  237.                 ipart = ipart[0]
  238.                 request = GED(*ipart.type)
  239.                 response = None
  240.                 if opart:
  241.                     response = GED(*opart[0].type)
  242.                 
  243.             msg = args
  244.             if self._asdict:
  245.                 if not msg:
  246.                     msg = dict()
  247.                 
  248.                 self._nullpyclass(request)
  249.             elif request.pyclass is not None:
  250.                 if type(args) is dict:
  251.                     msg = request.pyclass()
  252.                     msg.__dict__.update(args)
  253.                 elif type(args) is list and len(args) == 1:
  254.                     msg = request.pyclass(args[0])
  255.                 else:
  256.                     msg = request.pyclass()
  257.             
  258.             binding.Send(None, None, msg, requesttypecode = request, soapheaders = soapheaders, encodingStyle = callinfo.encodingStyle)
  259.             if response is None:
  260.                 return None
  261.             if self._asdict:
  262.                 self._nullpyclass(response)
  263.             
  264.             return binding.Receive(replytype = response, encodingStyle = callinfo.encodingStyle)
  265.  
  266.         return call_closure
  267.  
  268.     
  269.     def _nullpyclass(cls, typecode):
  270.         typecode.pyclass = None
  271.         if not hasattr(typecode, 'ofwhat'):
  272.             return None
  273.         if type(typecode.ofwhat) not in (list, tuple):
  274.             cls._nullpyclass(typecode.ofwhat)
  275.         else:
  276.             for i in typecode.ofwhat:
  277.                 cls._nullpyclass(i)
  278.             
  279.  
  280.     _nullpyclass = classmethod(_nullpyclass)
  281.  
  282.  
  283. class MethodProxy:
  284.     
  285.     def __init__(self, parent, callinfo):
  286.         self.__name__ = callinfo.methodName
  287.         self.__doc__ = callinfo.documentation
  288.         self.callinfo = callinfo
  289.         self.parent = weakref.ref(parent)
  290.         self.soapheaders = []
  291.  
  292.     
  293.     def __call__(self, *args, **kwargs):
  294.         return self.parent()._call(self.__name__, self.soapheaders)(*args, **kwargs)
  295.  
  296.     
  297.     def add_headers(self, **headers):
  298.         
  299.         class _holder:
  300.             pass
  301.  
  302.         
  303.         def _remap(pyobj, **d):
  304.             pyobj.__dict__ = d
  305.             for k, v in pyobj.__dict__.items():
  306.                 if type(v) is not dict:
  307.                     continue
  308.                 
  309.                 pyobj.__dict__[k] = p = _holder()
  310.                 _remap(p, **v)
  311.             
  312.  
  313.         for k, v in headers.items():
  314.             h = (filter,)((lambda i: k in i.type), self.callinfo.inheaders)[0]
  315.             if h.element_type != 1:
  316.                 raise RuntimeError, 'not implemented'
  317.             h.element_type != 1
  318.             typecode = GED(*h.type)
  319.             if typecode is None:
  320.                 raise RuntimeError, 'no matching element for %s' % str(h.type)
  321.             typecode is None
  322.             pyclass = typecode.pyclass
  323.             if pyclass is None:
  324.                 raise RuntimeError, 'no pyclass for typecode %s' % str(h.type)
  325.             pyclass is None
  326.             if type(v) is not dict:
  327.                 pyobj = pyclass(v)
  328.             else:
  329.                 pyobj = pyclass()
  330.                 _remap(pyobj, **v)
  331.             self.soapheaders.append(pyobj)
  332.         
  333.  
  334.  
  335.