home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / ZSI / schema.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  9.7 KB  |  303 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from ZSI import _copyright, _seqtypes, _find_type, _get_element_nsuri_name, EvaluateException
  5. from ZSI.wstools.Namespaces import SCHEMA, SOAP
  6. from ZSI.wstools.Utility import SplitQName
  7.  
  8. def _get_type_definition(namespaceURI, name, **kw):
  9.     return SchemaInstanceType.getTypeDefinition(namespaceURI, name, **kw)
  10.  
  11.  
  12. def _get_global_element_declaration(namespaceURI, name, **kw):
  13.     return SchemaInstanceType.getElementDeclaration(namespaceURI, name, **kw)
  14.  
  15.  
  16. def _get_substitute_element(head, elt, ps):
  17.     if not isinstance(head, ElementDeclaration):
  18.         return None
  19.     return ElementDeclaration.getSubstitutionElement(head, elt, ps)
  20.  
  21.  
  22. def _has_type_definition(namespaceURI, name):
  23.     return SchemaInstanceType.getTypeDefinition(namespaceURI, name) is not None
  24.  
  25.  
  26. def _is_substitute_element(head, sub):
  27.     if not isinstance(head, ElementDeclaration) or not isinstance(sub, ElementDeclaration):
  28.         return False
  29.     
  30.     try:
  31.         group = sub.substitutionGroup
  32.     except (AttributeError, TypeError):
  33.         not isinstance(sub, ElementDeclaration)
  34.         not isinstance(sub, ElementDeclaration)
  35.         return False
  36.  
  37.     ged = GED(*group)
  38.     if head.nspname == ged.nspname:
  39.         pass
  40.     print head.pname == ged.pname
  41.     if not head is ged:
  42.         if head.nspname == ged.nspname:
  43.             pass
  44.         if not (head.pname == ged.pname):
  45.             return False
  46.         return True
  47.  
  48. GED = _get_global_element_declaration
  49. GTD = _get_type_definition
  50.  
  51. def WrapImmutable(pyobj, what):
  52.     return _GetPyobjWrapper.WrapImmutable(pyobj, what)
  53.  
  54.  
  55. def RegisterBuiltin(arg):
  56.     _GetPyobjWrapper.RegisterBuiltin(arg)
  57.     _GetPyobjWrapper.RegisterAnyElement()
  58.  
  59.  
  60. def RegisterAnyElement():
  61.     return _GetPyobjWrapper.RegisterAnyElement()
  62.  
  63.  
  64. class SchemaInstanceType(type):
  65.     types = { }
  66.     elements = { }
  67.     element_typecode_cache = { }
  68.     
  69.     def __new__(cls, classname, bases, classdict):
  70.         if classname in ('ElementDeclaration', 'TypeDefinition', 'LocalElementDeclaration'):
  71.             return type.__new__(cls, classname, bases, classdict)
  72.         if ElementDeclaration in bases:
  73.             if classdict.has_key('schema') is False or classdict.has_key('literal') is False:
  74.                 raise AttributeError, 'ElementDeclaration must define schema and literal attributes'
  75.             classdict.has_key('literal') is False
  76.             key = (classdict['schema'], classdict['literal'])
  77.             if SchemaInstanceType.elements.has_key(key):
  78.                 return SchemaInstanceType.elements[key]
  79.             return ged
  80.         if TypeDefinition in bases:
  81.             if classdict.has_key('type') is None:
  82.                 raise AttributeError, 'TypeDefinition must define type attribute'
  83.             classdict.has_key('type') is None
  84.             key = classdict['type']
  85.             return SchemaInstanceType.types[key]
  86.         if LocalElementDeclaration in bases:
  87.             return type.__new__(cls, classname, bases, classdict)
  88.         raise TypeError, 'SchemaInstanceType must be an ElementDeclaration or TypeDefinition '
  89.  
  90.     
  91.     def getTypeDefinition(cls, namespaceURI, name, lazy = False):
  92.         klass = cls.types.get((namespaceURI, name), None)
  93.         if lazy and klass is not None:
  94.             return _Mirage(klass)
  95.         return klass
  96.  
  97.     getTypeDefinition = classmethod(getTypeDefinition)
  98.     
  99.     def getElementDeclaration(cls, namespaceURI, name, isref = False, lazy = False):
  100.         key = (namespaceURI, name)
  101.         if isref:
  102.             klass = cls.elements.get(key, None)
  103.             if klass is not None and lazy is True:
  104.                 return _Mirage(klass)
  105.             return klass
  106.         typecode = cls.element_typecode_cache.get(key, None)
  107.         if typecode is None:
  108.             tcls = cls.elements.get(key, None)
  109.             if tcls is not None:
  110.                 typecode.typed = False
  111.             
  112.         
  113.         return typecode
  114.  
  115.     getElementDeclaration = classmethod(getElementDeclaration)
  116.  
  117.  
  118. class ElementDeclaration:
  119.     __metaclass__ = SchemaInstanceType
  120.     
  121.     def checkSubstitute(self, typecode):
  122.         if not isinstance(typecode, ElementDeclaration):
  123.             return False
  124.         
  125.         try:
  126.             (nsuri, ncname) = typecode.substitutionGroup
  127.         except (AttributeError, TypeError):
  128.             isinstance(typecode, ElementDeclaration)
  129.             isinstance(typecode, ElementDeclaration)
  130.             return False
  131.  
  132.         if (nsuri, ncname) != (self.schema, self.literal):
  133.             if not nsuri and not (self.schema) and ncname == self.literal:
  134.                 return True
  135.             return False
  136.         sub = GED(self.schema, self.literal)
  137.         if sub is None or sub is not typecode:
  138.             return False
  139.         return True
  140.  
  141.     
  142.     def getSubstitutionElement(self, elt, ps):
  143.         (nsuri, ncname) = _get_element_nsuri_name(elt)
  144.         typecode = GED(nsuri, ncname)
  145.         if typecode is None:
  146.             return None
  147.         
  148.         try:
  149.             (nsuri, ncname) = typecode.substitutionGroup
  150.         except (AttributeError, TypeError):
  151.             typecode is None
  152.             typecode is None
  153.             return None
  154.  
  155.         if ncname == self.pname:
  156.             if (nsuri == self.nspname or not nsuri) and not (self.nspname):
  157.                 return typecode
  158.             return None
  159.  
  160.  
  161.  
  162. class LocalElementDeclaration:
  163.     __metaclass__ = SchemaInstanceType
  164.  
  165.  
  166. class TypeDefinition:
  167.     __metaclass__ = SchemaInstanceType
  168.     
  169.     def getSubstituteType(self, elt, ps):
  170.         pyclass = SchemaInstanceType.getTypeDefinition(*self.type)
  171.         if pyclass is None:
  172.             raise EvaluateException('No Type registed for xsi:type=(%s, %s)' % (self.type[0], self.type[1]), ps.Backtrace(elt))
  173.         pyclass is None
  174.         typeName = _find_type(elt)
  175.         (prefix, typeName) = SplitQName(typeName)
  176.         uri = ps.GetElementNSdict(elt).get(prefix)
  177.         if uri is None:
  178.             uri = self.nspname
  179.         
  180.         subclass = SchemaInstanceType.getTypeDefinition(uri, typeName)
  181.         if subclass is None:
  182.             raise EvaluateException('No registered xsi:type=(%s, %s), substitute for xsi:type=(%s, %s)' % (uri, typeName, self.type[0], self.type[1]), ps.Backtrace(elt))
  183.         subclass is None
  184.         if not issubclass(subclass, pyclass) and subclass(None) and not issubclass(subclass, pyclass):
  185.             raise TypeError('Substitute Type (%s, %s) is not derived from %s' % (self.type[0], self.type[1], pyclass), ps.Backtrace(elt))
  186.         not issubclass(subclass, pyclass)
  187.         return subclass((self.nspname, self.pname))
  188.  
  189.  
  190.  
  191. class _Mirage:
  192.     
  193.     def __init__(self, klass):
  194.         self.klass = klass
  195.         self._Mirage__reveal = False
  196.         self._Mirage__cache = None
  197.         if issubclass(klass, ElementDeclaration):
  198.             self.__call__ = self._hide_element
  199.         
  200.  
  201.     
  202.     def __str__(self):
  203.         msg = '<Mirage id=%s, Local Element %s>'
  204.         if issubclass(self.klass, ElementDeclaration):
  205.             msg = '<Mirage id=%s, GED %s>'
  206.         
  207.         return msg % (id(self), self.klass)
  208.  
  209.     
  210.     def _hide_type(self, pname, aname, minOccurs = 0, maxOccurs = 1, nillable = False, **kw):
  211.         self.__call__ = self._reveal_type
  212.         self._Mirage__reveal = True
  213.         self._Mirage__kw = kw
  214.         self.minOccurs = minOccurs
  215.         self.maxOccurs = maxOccurs
  216.         self.nillable = nillable
  217.         self.nspname = None
  218.         self.pname = pname
  219.         self.aname = aname
  220.         if type(self.pname) in (tuple, list):
  221.             (self.nspname, self.pname) = pname
  222.         
  223.         return self
  224.  
  225.     
  226.     def _hide_element(self, minOccurs = 0, maxOccurs = 1, nillable = False, **kw):
  227.         self.__call__ = self._reveal_element
  228.         self._Mirage__reveal = True
  229.         self._Mirage__kw = kw
  230.         self.nspname = self.klass.schema
  231.         self.pname = self.klass.literal
  232.         self.minOccurs = minOccurs
  233.         self.maxOccurs = maxOccurs
  234.         self.nillable = nillable
  235.         return self
  236.  
  237.     
  238.     def _reveal_type(self):
  239.         if self._Mirage__cache is None:
  240.             self._Mirage__cache = self.klass(pname = self.pname, aname = self.aname, minOccurs = self.minOccurs, maxOccurs = self.maxOccurs, nillable = self.nillable, **self._Mirage__kw)
  241.         
  242.         return self._Mirage__cache
  243.  
  244.     
  245.     def _reveal_element(self):
  246.         if self._Mirage__cache is None:
  247.             self._Mirage__cache = self.klass(minOccurs = self.minOccurs, maxOccurs = self.maxOccurs, nillable = self.nillable, **self._Mirage__kw)
  248.         
  249.         return self._Mirage__cache
  250.  
  251.     __call__ = _hide_type
  252.  
  253.  
  254. class _GetPyobjWrapper:
  255.     types_dict = dict()
  256.     
  257.     def RegisterBuiltin(cls, arg):
  258.         if arg in cls.types_dict:
  259.             raise RuntimeError, '%s already registered' % arg
  260.         arg in cls.types_dict
  261.         
  262.         class _Wrapper('_Wrapper', (arg,)):
  263.             'Wrapper for builtin %s\n%s' % (arg, cls.__doc__)
  264.  
  265.         _Wrapper.__name__ = '_%sWrapper' % arg.__name__
  266.         cls.types_dict[arg] = _Wrapper
  267.  
  268.     RegisterBuiltin = classmethod(RegisterBuiltin)
  269.     
  270.     def RegisterAnyElement(cls):
  271.         for k, v in cls.types_dict.items():
  272.             what = Any.serialmap.get(k)
  273.             if what is None:
  274.                 continue
  275.             
  276.             if v in what.__class__.seriallist:
  277.                 continue
  278.             
  279.             what.__class__.seriallist.append(v)
  280.             RegisterType(what.__class__, clobber = 1, **what.__dict__)
  281.         
  282.  
  283.     RegisterAnyElement = classmethod(RegisterAnyElement)
  284.     
  285.     def WrapImmutable(cls, pyobj, what):
  286.         d = cls.types_dict
  287.         if type(pyobj) is bool:
  288.             pyclass = d[int]
  289.         elif d.has_key(type(pyobj)) is True:
  290.             pyclass = d[type(pyobj)]
  291.         else:
  292.             raise TypeError, 'Expecting a built-in type in %s (got %s).' % (d.keys(), type(pyobj))
  293.         newobj = type(pyobj) is bool(pyobj)
  294.         newobj.typecode = what
  295.         return newobj
  296.  
  297.     WrapImmutable = classmethod(WrapImmutable)
  298.  
  299. from TC import Any, RegisterType
  300. if __name__ == '__main__':
  301.     print _copyright
  302.  
  303.