home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / ZSI / TC.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  43.2 KB  |  1,453 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from ZSI import _copyright, _children, _child_elements, _floattypes, _stringtypes, _seqtypes, _find_attr, _find_attrNS, _find_attrNodeNS, _find_arraytype, _find_default_namespace, _find_href, _find_encstyle, _resolve_prefix, _find_xsi_attr, _find_type, _find_xmlns_prefix, _get_element_nsuri_name, _get_idstr, _Node, EvaluateException, UNICODE_ENCODING, _valid_encoding, ParseException
  5. from ZSI.wstools.Namespaces import SCHEMA, SOAP
  6. from ZSI.wstools.Utility import SplitQName
  7. from ZSI.wstools.c14n import Canonicalize
  8. from ZSI.wstools.logging import getLogger as _GetLogger
  9. import re
  10. import types
  11. import time
  12. import copy
  13. from base64 import decodestring as b64decode, encodestring as b64encode
  14. from urllib import unquote as urldecode, quote as urlencode
  15. from binascii import unhexlify as hexdecode, hexlify as hexencode
  16.  
  17. try:
  18.     from cStringIO import StringIO
  19. except ImportError:
  20.     from StringIO import StringIO
  21.  
  22.  
  23. _is_xsd_or_soap_ns = lambda ns: ns in [
  24. SCHEMA.XSD3,
  25. SOAP.ENC,
  26. SOAP.ENC12,
  27. SCHEMA.XSD1,
  28. SCHEMA.XSD2]
  29.  
  30. _find_nil = lambda E: if not _find_xsi_attr(E, 'null'):
  31. pass_find_xsi_attr(E, 'nil')
  32.  
  33. def _get_xsitype(pyclass):
  34.     if hasattr(pyclass, 'type') and type(pyclass.type) in _seqtypes:
  35.         return pyclass.type
  36.     if hasattr(pyclass, 'type') and hasattr(pyclass, 'schema'):
  37.         return (pyclass.schema, pyclass.type)
  38.     return (None, None)
  39.  
  40. Nilled = None
  41. UNBOUNDED = 'unbounded'
  42.  
  43. class TypeCode:
  44.     tag = None
  45.     type = (None, None)
  46.     typechecks = True
  47.     attribute_typecode_dict = None
  48.     logger = _GetLogger('ZSI.TC.TypeCode')
  49.     
  50.     def __init__(self, pname = None, aname = None, minOccurs = 1, maxOccurs = 1, nillable = False, typed = True, unique = True, pyclass = None, attrs_aname = '_attrs', **kw):
  51.         if type(pname) in _seqtypes:
  52.             (self.nspname, self.pname) = pname
  53.         else:
  54.             self.nspname = None
  55.             self.pname = pname
  56.         if self.pname:
  57.             self.pname = str(self.pname).split(':')[-1]
  58.         
  59.         if not aname:
  60.             pass
  61.         self.aname = self.pname
  62.         self.minOccurs = minOccurs
  63.         self.maxOccurs = maxOccurs
  64.         self.nillable = nillable
  65.         self.typed = typed
  66.         self.unique = unique
  67.         self.attrs_aname = attrs_aname
  68.         self.pyclass = pyclass
  69.         encoded = kw.get('encoded')
  70.         if encoded is not None:
  71.             self.nspname = kw['encoded']
  72.         
  73.  
  74.     
  75.     def parse(self, elt, ps):
  76.         raise EvaluateException('Unimplemented evaluation', ps.Backtrace(elt))
  77.  
  78.     
  79.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  80.         raise EvaluateException('Unimplemented evaluation', sw.Backtrace(elt))
  81.  
  82.     
  83.     def text_to_data(self, text, elt, ps):
  84.         raise EvaluateException('Unimplemented evaluation', ps.Backtrace(elt))
  85.  
  86.     
  87.     def serialize_as_nil(self, elt):
  88.         elt.setAttributeNS(SCHEMA.XSI3, 'nil', '1')
  89.  
  90.     
  91.     def SimpleHREF(self, elt, ps, tag):
  92.         if len(_children(elt)):
  93.             return elt
  94.         href = _find_href(elt)
  95.         if not href:
  96.             if self.minOccurs is 0:
  97.                 return None
  98.             raise EvaluateException('Required' + tag + ' missing', ps.Backtrace(elt))
  99.         href
  100.         return ps.FindLocalHREF(href, elt, 0)
  101.  
  102.     
  103.     def get_parse_and_errorlist(self):
  104.         d = self.__class__.__dict__
  105.         parselist = d.get('parselist')
  106.         errorlist = d.get('errorlist')
  107.         if parselist and not errorlist:
  108.             errorlist = []
  109.             for t in parselist:
  110.                 if t[1] not in errorlist:
  111.                     errorlist.append(t[1])
  112.                     continue
  113.             
  114.             errorlist = ' or '.join(errorlist)
  115.             d['errorlist'] = errorlist
  116.         
  117.         return (parselist, errorlist)
  118.  
  119.     
  120.     def checkname(self, elt, ps):
  121.         (parselist, errorlist) = self.get_parse_and_errorlist()
  122.         (ns, name) = _get_element_nsuri_name(elt)
  123.         if ns in (SOAP.ENC, SOAP.ENC12):
  124.             if parselist and (None, name) not in parselist and (ns, name) not in parselist:
  125.                 raise EvaluateException('Element mismatch (got %s wanted %s) (SOAP encoding namespace)' % (name, errorlist), ps.Backtrace(elt))
  126.             (ns, name) not in parselist
  127.             return (ns, name)
  128.         if self.nspname and ns != self.nspname:
  129.             raise EvaluateException('Element NS mismatch (got %s wanted %s)' % (ns, self.nspname), ps.Backtrace(elt))
  130.         ns != self.nspname
  131.         if self.pname and name != self.pname:
  132.             raise EvaluateException('Element Name mismatch (got %s wanted %s)' % (name, self.pname), ps.Backtrace(elt))
  133.         name != self.pname
  134.         return self.checktype(elt, ps)
  135.  
  136.     
  137.     def checktype(self, elt, ps):
  138.         typeName = _find_type(elt)
  139.         if typeName is None or typeName == '':
  140.             return (None, None)
  141.         (prefix, typeName) = SplitQName(typeName)
  142.         uri = ps.GetElementNSdict(elt).get(prefix)
  143.         if uri is None:
  144.             uri = self.nspname
  145.         
  146.         (parselist, errorlist) = self.get_parse_and_errorlist()
  147.         if (not parselist and (uri, typeName) in parselist or _is_xsd_or_soap_ns(uri)) and (None, typeName) in parselist:
  148.             return (uri, typeName)
  149.         raise EvaluateException('Type mismatch (%s namespace) (got %s wanted %s)' % (uri, typeName, errorlist), ps.Backtrace(elt))
  150.  
  151.     
  152.     def name_match(self, elt):
  153.         if self.pname == elt.localName:
  154.             pass
  155.         return self.nspname in [
  156.             None,
  157.             '',
  158.             elt.namespaceURI]
  159.  
  160.     
  161.     def nilled(self, elt, ps):
  162.         if _find_nil(elt) not in ('true', '1'):
  163.             return False
  164.         if self.nillable is False:
  165.             raise EvaluateException('Non-nillable element is NIL', ps.Backtrace(elt))
  166.         self.nillable is False
  167.         return True
  168.  
  169.     
  170.     def simple_value(self, elt, ps, mixed = False):
  171.         if not _valid_encoding(elt):
  172.             raise EvaluateException('Invalid encoding', ps.Backtrace(elt))
  173.         _valid_encoding(elt)
  174.         c = _children(elt)
  175.         if mixed is False:
  176.             if len(c) == 0:
  177.                 raise EvaluateException('Value missing', ps.Backtrace(elt))
  178.             len(c) == 0
  179.             for c_elt in c:
  180.                 if c_elt.nodeType == _Node.ELEMENT_NODE:
  181.                     raise EvaluateException('Sub-elements in value', ps.Backtrace(c_elt))
  182.                 c_elt.nodeType == _Node.ELEMENT_NODE
  183.             
  184.         
  185.         return [](_[1])
  186.  
  187.     
  188.     def parse_attributes(self, elt, ps):
  189.         if self.attribute_typecode_dict is None:
  190.             return None
  191.         attributes = { }
  192.         for attr, what in self.attribute_typecode_dict.items():
  193.             namespaceURI = None
  194.             localName = attr
  195.             if type(attr) in _seqtypes:
  196.                 (namespaceURI, localName) = attr
  197.             
  198.             value = _find_attrNodeNS(elt, namespaceURI, localName)
  199.             self.logger.debug('Parsed Attribute (%s,%s) -- %s', namespaceURI, localName, value)
  200.             if value is None:
  201.                 continue
  202.             
  203.             attributes[attr] = what.text_to_data(value, elt, ps)
  204.         
  205.         return attributes
  206.  
  207.     
  208.     def set_attributes(self, el, pyobj):
  209.         if not hasattr(pyobj, self.attrs_aname):
  210.             return None
  211.         if not isinstance(getattr(pyobj, self.attrs_aname), dict):
  212.             raise TypeError, 'pyobj.%s must be a dictionary of names and values' % self.attrs_aname
  213.         isinstance(getattr(pyobj, self.attrs_aname), dict)
  214.         for attr, value in getattr(pyobj, self.attrs_aname).items():
  215.             namespaceURI = None
  216.             localName = attr
  217.             if type(attr) in _seqtypes:
  218.                 (namespaceURI, localName) = attr
  219.             
  220.             what = None
  221.             if getattr(self, 'attribute_typecode_dict', None) is not None:
  222.                 what = self.attribute_typecode_dict.get(attr)
  223.                 if what is None and namespaceURI is None:
  224.                     what = self.attribute_typecode_dict.get(localName)
  225.                 
  226.             
  227.             if hasattr(value, 'typecode') and not isinstance(what, AnyType):
  228.                 if what is not None and not isinstance(value.typecode, what):
  229.                     raise EvaluateException, 'self-describing attribute must subclass %s' % what.__class__
  230.                 not isinstance(value.typecode, what)
  231.                 what = value.typecode
  232.             
  233.             self.logger.debug('attribute create -- %s', value)
  234.             if isinstance(what, QName):
  235.                 what.set_prefix(el, value)
  236.             
  237.             if what is None:
  238.                 value = str(value)
  239.             else:
  240.                 value = what.get_formatted_content(value)
  241.             el.setAttributeNS(namespaceURI, localName, value)
  242.         
  243.  
  244.     
  245.     def set_attribute_xsi_type(self, el, **kw):
  246.         if kw.get('typed', self.typed):
  247.             (namespaceURI, typeName) = kw.get('type', _get_xsitype(self))
  248.             if namespaceURI and typeName:
  249.                 self.logger.debug('attribute: (%s, %s)', namespaceURI, typeName)
  250.                 el.setAttributeType(namespaceURI, typeName)
  251.             
  252.         
  253.  
  254.     
  255.     def set_attribute_href(self, el, objid):
  256.         el.setAttributeNS(None, 'href', '#%s' % objid)
  257.  
  258.     
  259.     def set_attribute_id(self, el, objid):
  260.         if self.unique is False:
  261.             el.setAttributeNS(None, 'id', '%s' % objid)
  262.         
  263.  
  264.     
  265.     def get_name(self, name, objid):
  266.         if type(name) is tuple:
  267.             return name
  268.         ns = self.nspname
  269.         if not name and self.pname:
  270.             pass
  271.         n = 'E' + objid
  272.         return (ns, n)
  273.  
  274.     
  275.     def has_attributes(self):
  276.         if self.attribute_typecode_dict is None:
  277.             return False
  278.         return len(self.attribute_typecode_dict) > 0
  279.  
  280.  
  281.  
  282. class SimpleType(TypeCode):
  283.     empty_content = None
  284.     logger = _GetLogger('ZSI.TC.SimpleType')
  285.     
  286.     def parse(self, elt, ps):
  287.         self.checkname(elt, ps)
  288.         pyobj = self.text_to_data(v, elt, ps)
  289.         if self.attribute_typecode_dict is not None:
  290.             attributes = self.parse_attributes(elt, ps)
  291.             if attributes:
  292.                 setattr(pyobj, self.attrs_aname, attributes)
  293.             
  294.         
  295.         return pyobj
  296.  
  297.     
  298.     def get_formatted_content(self, pyobj):
  299.         raise NotImplementedError, 'method get_formatted_content is not implemented'
  300.  
  301.     
  302.     def serialize_text_node(self, elt, sw, pyobj):
  303.         textNode = None
  304.         if pyobj is not None:
  305.             text = self.get_formatted_content(pyobj)
  306.             if type(text) not in _stringtypes:
  307.                 raise TypeError, 'pyobj must be a formatted string'
  308.             type(text) not in _stringtypes
  309.             textNode = elt.createAppendTextNode(text)
  310.         
  311.         return textNode
  312.  
  313.     
  314.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  315.         objid = _get_idstr(pyobj)
  316.         (ns, n) = self.get_name(name, objid)
  317.         el = elt.createAppendElement(ns, n)
  318.         if self.nillable is True and pyobj is Nilled:
  319.             self.serialize_as_nil(el)
  320.             return None
  321.         self.set_attributes(el, pyobj)
  322.         if not self.unique:
  323.             pass
  324.         unique = kw.get('unique', False)
  325.         if unique is False:
  326.             if not orig:
  327.                 pass
  328.             if sw.Known(pyobj):
  329.                 self.set_attribute_href(el, objid)
  330.                 return None
  331.         if self.unique is False:
  332.             self.set_attribute_id(el, objid)
  333.         
  334.         self.serialize_text_node(el, sw, pyobj)
  335.         return el
  336.  
  337.  
  338.  
  339. class Any(TypeCode):
  340.     logger = _GetLogger('ZSI.TC.Any')
  341.     parsemap = { }
  342.     serialmap = { }
  343.     
  344.     def __init__(self, pname = None, aslist = False, minOccurs = 0, unique = False, **kw):
  345.         TypeCode.__init__(self, pname, minOccurs = minOccurs, unique = unique, **kw)
  346.         self.aslist = aslist
  347.         self.kwargs = dict(aslist = aslist, unique = unique)
  348.         self.kwargs.update(kw)
  349.  
  350.     
  351.     def listify(self, v):
  352.         if self.aslist:
  353.             return [ k for j, k in v ]
  354.         return dict(v)
  355.  
  356.     
  357.     def parse_into_dict_or_list(self, elt, ps):
  358.         c = _child_elements(elt)
  359.         count = len(c)
  360.         v = []
  361.         if self.nilled(elt, ps):
  362.             return Nilled
  363.         for c_elt in c:
  364.             v.append((str(c_elt.localName), self.__class__(**self.kwargs).parse(c_elt, ps)))
  365.         
  366.         return self.listify(v)
  367.  
  368.     
  369.     def parse(self, elt, ps):
  370.         (ns, type) = self.checkname(elt, ps)
  371.         if not type and self.nilled(elt, ps):
  372.             return Nilled
  373.         if len(_children(elt)) == 0:
  374.             href = _find_href(elt)
  375.             if not href:
  376.                 if self.minOccurs < 1:
  377.                     if not (ns, type) == (SOAP.ENC, 'Array') and (ns, type) == (SOAP.ENC12, 'Array'):
  378.                         if not _find_arraytype(elt):
  379.                             pass
  380.                         if ''.endswith('[0]'):
  381.                             return []
  382.                         return None
  383.                     raise EvaluateException('Required Any missing', ps.Backtrace(elt))
  384.             self.minOccurs < 1
  385.             elt = ps.FindLocalHREF(href, elt)
  386.             (ns, type) = self.checktype(elt, ps)
  387.         
  388.         if not type and elt.namespaceURI in (SOAP.ENC, SOAP.ENC12):
  389.             ns = SOAP.ENC
  390.             type = elt.localName
  391.         
  392.         if not type or (ns, type) in ((SOAP.ENC, 'Array'), (SOAP.ENC12, 'Array')):
  393.             if self.aslist or _find_arraytype(elt):
  394.                 return [ self.__class__(**self.kwargs).parse(e, ps) for e in _child_elements(elt) ]
  395.             if len(_child_elements(elt)) == 0:
  396.                 return self.simple_value(elt, ps)
  397.             return self.parse_into_dict_or_list(elt, ps)
  398.         parser = Any.parsemap.get((ns, type))
  399.         if not parser and _is_xsd_or_soap_ns(ns):
  400.             parser = Any.parsemap.get((None, type))
  401.         
  402.         if not parser:
  403.             raise EvaluateException("Any can't parse element", ps.Backtrace(elt))
  404.         parser
  405.         return parser.parse(elt, ps)
  406.  
  407.     
  408.     def get_formatted_content(self, pyobj):
  409.         tc = type(pyobj)
  410.         if tc == types.InstanceType:
  411.             tc = pyobj.__class__
  412.             if hasattr(pyobj, 'typecode'):
  413.                 serializer = pyobj.typecode
  414.             else:
  415.                 serializer = Any.serialmap.get(tc)
  416.             if not serializer:
  417.                 tc = (types.ClassType, pyobj.__class__.__name__)
  418.                 serializer = Any.serialmap.get(tc)
  419.             
  420.         else:
  421.             serializer = Any.serialmap.get(tc)
  422.             if not serializer and isinstance(pyobj, time.struct_time):
  423.                 gDateTime = gDateTime
  424.                 import ZSI.TCtimes
  425.                 serializer = gDateTime()
  426.             
  427.         if serializer:
  428.             return serializer.get_formatted_content(pyobj)
  429.         raise EvaluateException, 'Failed to find serializer for pyobj %s' % pyobj
  430.  
  431.     
  432.     def serialize(self, elt, sw, pyobj, name = None, **kw):
  433.         if hasattr(pyobj, 'typecode') and pyobj.typecode is not self:
  434.             pyobj.typecode.serialize(elt, sw, pyobj, **kw)
  435.             return None
  436.         objid = _get_idstr(pyobj)
  437.         (ns, n) = self.get_name(name, objid)
  438.         kw.setdefault('typed', self.typed)
  439.         tc = type(pyobj)
  440.         self.logger.debug('Any serialize -- %s', tc)
  441.         if tc in _seqtypes:
  442.             if self.aslist:
  443.                 array = elt.createAppendElement(ns, n)
  444.                 array.setAttributeType(SOAP.ENC, 'Array')
  445.                 array.setAttributeNS(self.nspname, 'SOAP-ENC:arrayType', 'xsd:anyType[' + str(len(pyobj)) + ']')
  446.                 for o in pyobj:
  447.                     serializer = getattr(o, 'typecode', Any(**self.kwargs))
  448.                     serializer.serialize(array, sw, o, name = 'element', **kw)
  449.                 
  450.             else:
  451.                 struct = elt.createAppendElement(ns, n)
  452.                 for o in pyobj:
  453.                     serializer = getattr(o, 'typecode', Any(**self.kwargs))
  454.                     serializer.serialize(struct, sw, o, **kw)
  455.                 
  456.             return None
  457.         kw['name'] = (ns, n)
  458.         if tc == types.DictType:
  459.             el = elt.createAppendElement(ns, n)
  460.             parentNspname = self.nspname
  461.             self.nspname = None
  462.             for o, m in pyobj.items():
  463.                 if type(o) != types.StringType and type(o) != types.UnicodeType:
  464.                     raise Exception, 'Dictionary implementation requires keys to be of type string (or unicode).' % pyobj
  465.                 type(o) != types.UnicodeType
  466.                 kw['name'] = o
  467.                 kw.setdefault('typed', True)
  468.                 self.serialize(el, sw, m, **kw)
  469.             
  470.             self.nspname = parentNspname
  471.             return None
  472.         if tc == types.InstanceType:
  473.             tc = pyobj.__class__
  474.             if not serializer:
  475.                 tc = (types.ClassType, pyobj.__class__.__name__)
  476.                 serializer = Any.serialmap.get(tc)
  477.             
  478.         else:
  479.             serializer = Any.serialmap.get(tc)
  480.             if not serializer and isinstance(pyobj, time.struct_time):
  481.                 gDateTime = gDateTime
  482.                 import ZSI.TCtimes
  483.                 serializer = gDateTime()
  484.             
  485.         if not serializer:
  486.             if pyobj is None:
  487.                 self.serialize_as_nil(elt.createAppendElement(ns, n))
  488.             elif type(pyobj) != types.InstanceType:
  489.                 raise EvaluateException("Any can't serialize " + repr(pyobj))
  490.             else:
  491.                 self.serialize(elt, sw, pyobj.__dict__, **kw)
  492.         else:
  493.             tag = getattr(serializer, 'tag', None)
  494.             if self.pname is not None:
  495.                 if 'typed' not in kw:
  496.                     kw['typed'] = False
  497.                 
  498.             elif tag:
  499.                 if tag.find(':') == -1:
  500.                     tag = 'SOAP-ENC:' + tag
  501.                 
  502.                 kw['name'] = tag
  503.                 kw['typed'] = False
  504.             
  505.             serializer.unique = self.unique
  506.             serializer.serialize(elt, sw, pyobj, **kw)
  507.  
  508.  
  509.  
  510. class String(SimpleType):
  511.     empty_content = ''
  512.     parselist = [
  513.         (None, 'string')]
  514.     seriallist = [
  515.         types.StringType,
  516.         types.UnicodeType]
  517.     type = (SCHEMA.XSD3, 'string')
  518.     logger = _GetLogger('ZSI.TC.String')
  519.     
  520.     def __init__(self, pname = None, strip = True, **kw):
  521.         TypeCode.__init__(self, pname, **kw)
  522.         if kw.has_key('resolver'):
  523.             self.resolver = kw['resolver']
  524.         
  525.         self.strip = strip
  526.  
  527.     
  528.     def text_to_data(self, text, elt, ps):
  529.         if self.strip:
  530.             text = text.strip()
  531.         
  532.         if self.pyclass is not None:
  533.             return self.pyclass(text.encode(UNICODE_ENCODING))
  534.         return text.encode(UNICODE_ENCODING)
  535.  
  536.     
  537.     def get_formatted_content(self, pyobj):
  538.         if type(pyobj) not in _stringtypes:
  539.             pyobj = str(pyobj)
  540.         
  541.         if type(pyobj) == unicode:
  542.             return pyobj.encode(UNICODE_ENCODING)
  543.         return pyobj
  544.  
  545.  
  546.  
  547. class URI(String):
  548.     parselist = [
  549.         (None, 'anyURI'),
  550.         (SCHEMA.XSD3, 'anyURI')]
  551.     type = (SCHEMA.XSD3, 'anyURI')
  552.     logger = _GetLogger('ZSI.TC.URI')
  553.     reserved = ';/?:@&=+$,'
  554.     
  555.     def text_to_data(self, text, elt, ps):
  556.         return String.text_to_data(self, urldecode(text), elt, ps)
  557.  
  558.     
  559.     def get_formatted_content(self, pyobj):
  560.         u = urlencode(pyobj, self.reserved)
  561.         return String.get_formatted_content(self, u)
  562.  
  563.  
  564.  
  565. class QName(String):
  566.     parselist = [
  567.         (None, 'QName')]
  568.     type = (SCHEMA.XSD3, 'QName')
  569.     logger = _GetLogger('ZSI.TC.QName')
  570.     
  571.     def __init__(self, pname = None, strip = 1, **kw):
  572.         String.__init__(self, pname, strip, **kw)
  573.         self.prefix = None
  574.  
  575.     
  576.     def get_formatted_content(self, pyobj):
  577.         value = pyobj
  578.         if isinstance(pyobj, tuple):
  579.             (namespaceURI, localName) = pyobj
  580.             if self.prefix is not None:
  581.                 value = '%s:%s' % (self.prefix, localName)
  582.             
  583.         
  584.         return String.get_formatted_content(self, value)
  585.  
  586.     
  587.     def set_prefix(self, elt, pyobj):
  588.         if isinstance(pyobj, tuple):
  589.             (namespaceURI, localName) = pyobj
  590.             self.prefix = elt.getPrefix(namespaceURI)
  591.         
  592.  
  593.     
  594.     def text_to_data(self, text, elt, ps):
  595.         (prefix, localName) = SplitQName(text)
  596.         nsdict = ps.GetElementNSdict(elt)
  597.         if not prefix:
  598.             pass
  599.         prefix = ''
  600.         
  601.         try:
  602.             namespaceURI = nsdict[prefix]
  603.         except KeyError:
  604.             ex = None
  605.             raise EvaluateException('cannot resolve prefix(%s)' % prefix, ps.Backtrace(elt))
  606.  
  607.         v = (namespaceURI, localName)
  608.         if self.pyclass is not None:
  609.             return self.pyclass(v)
  610.         return v
  611.  
  612.     
  613.     def serialize_text_node(self, elt, sw, pyobj):
  614.         self.set_prefix(elt, pyobj)
  615.         return String.serialize_text_node(self, elt, sw, pyobj)
  616.  
  617.  
  618.  
  619. class Token(String):
  620.     parselist = [
  621.         (None, 'token')]
  622.     type = (SCHEMA.XSD3, 'token')
  623.     logger = _GetLogger('ZSI.TC.Token')
  624.  
  625.  
  626. class Base64String(String):
  627.     parselist = [
  628.         (None, 'base64Binary'),
  629.         (SOAP.ENC, 'base64'),
  630.         (SOAP.ENC12, 'base64')]
  631.     type = (SOAP.ENC, 'base64')
  632.     logger = _GetLogger('ZSI.TC.Base64String')
  633.     
  634.     def text_to_data(self, text, elt, ps):
  635.         val = b64decode(text.replace(' ', '').replace('\n', '').replace('\r', ''))
  636.         if self.pyclass is not None:
  637.             return self.pyclass(val)
  638.         return val
  639.  
  640.     
  641.     def get_formatted_content(self, pyobj):
  642.         pyobj = '\n' + b64encode(pyobj)
  643.         return String.get_formatted_content(self, pyobj)
  644.  
  645.  
  646.  
  647. class Base64Binary(String):
  648.     parselist = [
  649.         (None, 'base64Binary')]
  650.     type = (SCHEMA.XSD3, 'base64Binary')
  651.     logger = _GetLogger('ZSI.TC.Base64Binary')
  652.     
  653.     def text_to_data(self, text, elt, ps):
  654.         val = b64decode(text)
  655.         if self.pyclass is not None:
  656.             return self.pyclass(val)
  657.         return val
  658.  
  659.     
  660.     def get_formatted_content(self, pyobj):
  661.         pyobj = b64encode(pyobj).strip()
  662.         return pyobj
  663.  
  664.  
  665.  
  666. class HexBinaryString(String):
  667.     parselist = [
  668.         (None, 'hexBinary')]
  669.     type = (SCHEMA.XSD3, 'hexBinary')
  670.     logger = _GetLogger('ZSI.TC.HexBinaryString')
  671.     
  672.     def text_to_data(self, text, elt, ps):
  673.         val = hexdecode(text)
  674.         if self.pyclass is not None:
  675.             return self.pyclass(val)
  676.         return val
  677.  
  678.     
  679.     def get_formatted_content(self, pyobj):
  680.         pyobj = hexencode(pyobj).upper()
  681.         return String.get_formatted_content(self, pyobj)
  682.  
  683.  
  684.  
  685. class XMLString(String):
  686.     logger = _GetLogger('ZSI.TC.XMLString')
  687.     
  688.     def __init__(self, pname = None, readerclass = None, **kw):
  689.         String.__init__(self, pname, **kw)
  690.         self.readerclass = readerclass
  691.  
  692.     
  693.     def parse(self, elt, ps):
  694.         if not self.readerclass:
  695.             PyExpat = PyExpat
  696.             import xml.dom.ext.reader
  697.             self.readerclass = PyExpat.Reader
  698.         
  699.         v = String.parse(self, elt, ps)
  700.         return self.readerclass().fromString(v)
  701.  
  702.     
  703.     def get_formatted_content(self, pyobj):
  704.         return String.get_formatted_content(self, pyobj)
  705.  
  706.  
  707.  
  708. class Enumeration(String):
  709.     logger = _GetLogger('ZSI.TC.Enumeration')
  710.     
  711.     def __init__(self, choices, pname = None, **kw):
  712.         String.__init__(self, pname, **kw)
  713.         t = type(choices)
  714.         if t in _seqtypes:
  715.             self.choices = tuple(choices)
  716.         elif TypeCode.typechecks:
  717.             raise TypeError('Enumeration choices must be list or sequence, not ' + str(t))
  718.         
  719.         if TypeCode.typechecks:
  720.             for c in self.choices:
  721.                 if type(c) not in _stringtypes:
  722.                     raise TypeError('Enumeration choice ' + str(c) + ' is not a string')
  723.                 type(c) not in _stringtypes
  724.             
  725.         
  726.  
  727.     
  728.     def parse(self, elt, ps):
  729.         val = String.parse(self, elt, ps)
  730.         if val not in self.choices:
  731.             raise EvaluateException('Value not in enumeration list', ps.Backtrace(elt))
  732.         val not in self.choices
  733.         return val
  734.  
  735.     
  736.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  737.         if pyobj not in self.choices:
  738.             raise EvaluateException('Value not in enumeration list', sw.Backtrace(elt))
  739.         pyobj not in self.choices
  740.         String.serialize(self, elt, sw, pyobj, name = name, orig = orig, **kw)
  741.  
  742.  
  743. _ignored = []
  744.  
  745. class Integer(SimpleType):
  746.     ranges = {
  747.         'unsignedByte': (0, 255),
  748.         'unsignedShort': (0, 65535),
  749.         'unsignedInt': (0, 0xFFFFFFFFL),
  750.         'unsignedLong': (0, 0xFFFFFFFFFFFFFFFFL),
  751.         'byte': (-128, 127),
  752.         'short': (-32768, 32767),
  753.         'int': (-0x80000000L, 2147483647),
  754.         'long': (-0x8000000000000000L, 0x7FFFFFFFFFFFFFFFL),
  755.         'negativeInteger': (_ignored, -1),
  756.         'nonPositiveInteger': (_ignored, 0),
  757.         'nonNegativeInteger': (0, _ignored),
  758.         'positiveInteger': (1, _ignored),
  759.         'integer': (_ignored, _ignored) }
  760.     parselist = [ (None, k) for k in ranges.keys() ]
  761.     seriallist = [
  762.         types.IntType,
  763.         types.LongType]
  764.     logger = _GetLogger('ZSI.TC.Integer')
  765.     
  766.     def __init__(self, pname = None, format = '%d', **kw):
  767.         TypeCode.__init__(self, pname, **kw)
  768.         self.format = format
  769.  
  770.     
  771.     def text_to_data(self, text, elt, ps):
  772.         if self.pyclass is not None:
  773.             v = self.pyclass(text)
  774.         else:
  775.             
  776.             try:
  777.                 v = int(text)
  778.             except:
  779.                 
  780.                 try:
  781.                     v = long(text)
  782.                 raise EvaluateException('Unparseable integer', ps.Backtrace(elt))
  783.  
  784.  
  785.         return v
  786.  
  787.     
  788.     def parse(self, elt, ps):
  789.         (ns, type) = self.checkname(elt, ps)
  790.         if self.nilled(elt, ps):
  791.             return Nilled
  792.         elt = self.SimpleHREF(elt, ps, 'integer')
  793.         if not elt:
  794.             return None
  795.         if type is None:
  796.             type = self.type[1]
  797.         elif self.type[1] is not None and type != self.type[1]:
  798.             raise EvaluateException('Integer type mismatch; got %s wanted %s' % (type, self.type[1]), ps.Backtrace(elt))
  799.         
  800.         v = self.simple_value(elt, ps)
  801.         v = self.text_to_data(v, elt, ps)
  802.         (rmin, rmax) = Integer.ranges.get(type, (_ignored, _ignored))
  803.         if rmin != _ignored and v < rmin:
  804.             raise EvaluateException('Underflow, less than ' + repr(rmin), ps.Backtrace(elt))
  805.         v < rmin
  806.         if rmax != _ignored and v > rmax:
  807.             raise EvaluateException('Overflow, greater than ' + repr(rmax), ps.Backtrace(elt))
  808.         v > rmax
  809.         return v
  810.  
  811.     
  812.     def get_formatted_content(self, pyobj):
  813.         return self.format % pyobj
  814.  
  815.  
  816.  
  817. def _make_inf():
  818.     x = 2
  819.     x2 = x * x
  820.     i = 0
  821.     while i < 100 and x != x2:
  822.         x = x2
  823.         x2 = x * x
  824.         i = i + 1
  825.     if x != x2:
  826.         raise ValueError("This machine's floats go on forever!")
  827.     x != x2
  828.     return x
  829.  
  830. _magicnums = { }
  831.  
  832. try:
  833.     _magicnums['INF'] = float('INF')
  834.     _magicnums['-INF'] = float('-INF')
  835. except:
  836.     _magicnums['INF'] = _make_inf()
  837.     _magicnums['-INF'] = -_magicnums['INF']
  838.  
  839.  
  840. def isnan(x):
  841.     if x * 1 < x:
  842.         return 1
  843.     if 1 == x:
  844.         pass
  845.     return x == 2
  846.  
  847.  
  848. class Decimal(SimpleType):
  849.     parselist = [
  850.         (None, 'decimal'),
  851.         (None, 'float'),
  852.         (None, 'double')]
  853.     seriallist = _floattypes
  854.     type = None
  855.     ranges = {
  856.         'float': (7.00649e-46, -3.40282e+38, 3.40282e+38),
  857.         'double': (0, -1.79769e+308, 1.79769e+308) }
  858.     zeropat = re.compile('[1-9]')
  859.     logger = _GetLogger('ZSI.TC.Decimal')
  860.     
  861.     def __init__(self, pname = None, format = '%f', **kw):
  862.         TypeCode.__init__(self, pname, **kw)
  863.         self.format = format
  864.  
  865.     
  866.     def text_to_data(self, text, elt, ps):
  867.         v = text
  868.         if self.pyclass is not None:
  869.             return self.pyclass(v)
  870.         m = _magicnums.get(v)
  871.         if m:
  872.             return m
  873.         
  874.         try:
  875.             return float(v)
  876.         except:
  877.             m
  878.             self.pyclass is not None
  879.             raise EvaluateException('Unparseable floating point number', ps.Backtrace(elt))
  880.  
  881.  
  882.     
  883.     def parse(self, elt, ps):
  884.         (ns, type) = self.checkname(elt, ps)
  885.         elt = self.SimpleHREF(elt, ps, 'floating-point')
  886.         if not elt:
  887.             return None
  888.         tag = getattr(self.__class__, 'type')
  889.         if tag:
  890.             if type is None:
  891.                 type = tag
  892.             elif tag != (ns, type):
  893.                 raise EvaluateException('Floating point type mismatch; got (%s,%s) wanted %s' % (ns, type, tag), ps.Backtrace(elt))
  894.             
  895.         
  896.         if self.nilled(elt, ps):
  897.             return Nilled
  898.         v = self.simple_value(elt, ps)
  899.         
  900.         try:
  901.             fp = self.text_to_data(v, elt, ps)
  902.         except EvaluateException:
  903.             self.nilled(elt, ps)
  904.             ex = self.nilled(elt, ps)
  905.             ex.args.append(ps.Backtrace(elt))
  906.             raise ex
  907.         except:
  908.             self.nilled(elt, ps)
  909.  
  910.         m = _magicnums.get(v)
  911.         if m:
  912.             return m
  913.         if str(fp).lower() in ('inf', '-inf', 'nan', '-nan'):
  914.             raise EvaluateException('Floating point number parsed as "' + str(fp) + '"', ps.Backtrace(elt))
  915.         str(fp).lower() in ('inf', '-inf', 'nan', '-nan')
  916.         if fp == 0 and Decimal.zeropat.search(v):
  917.             raise EvaluateException('Floating point number parsed as zero', ps.Backtrace(elt))
  918.         Decimal.zeropat.search(v)
  919.         (rtiny, rneg, rpos) = Decimal.ranges.get(type, (None, None, None))
  920.         if rneg and fp < 0 and fp < rneg:
  921.             raise EvaluateException('Negative underflow', ps.Backtrace(elt))
  922.         fp < rneg
  923.         if rtiny and fp > 0 and fp < rtiny:
  924.             raise EvaluateException('Positive underflow', ps.Backtrace(elt))
  925.         fp < rtiny
  926.         if rpos and fp > 0 and fp > rpos:
  927.             raise EvaluateException('Overflow', ps.Backtrace(elt))
  928.         fp > rpos
  929.         return fp
  930.  
  931.     
  932.     def get_formatted_content(self, pyobj):
  933.         if pyobj == _magicnums['INF']:
  934.             return 'INF'
  935.         if pyobj == _magicnums['-INF']:
  936.             return '-INF'
  937.         if isnan(pyobj):
  938.             return 'NaN'
  939.         return self.format % pyobj
  940.  
  941.  
  942.  
  943. class Boolean(SimpleType):
  944.     parselist = [
  945.         (None, 'boolean')]
  946.     seriallist = [
  947.         bool]
  948.     type = (SCHEMA.XSD3, 'boolean')
  949.     logger = _GetLogger('ZSI.TC.Boolean')
  950.     
  951.     def text_to_data(self, text, elt, ps):
  952.         v = text
  953.         if v == 'false':
  954.             if self.pyclass is None:
  955.                 return False
  956.             return self.pyclass(False)
  957.         if v == 'true':
  958.             if self.pyclass is None:
  959.                 return True
  960.             return self.pyclass(True)
  961.         
  962.         try:
  963.             v = int(v)
  964.         except:
  965.             v == 'true'
  966.             v == 'false'
  967.             
  968.             try:
  969.                 v = long(v)
  970.             raise EvaluateException('Unparseable boolean', ps.Backtrace(elt))
  971.  
  972.  
  973.         if v:
  974.             if self.pyclass is None:
  975.                 return True
  976.             return self.pyclass(True)
  977.         if self.pyclass is None:
  978.             return False
  979.         return self.pyclass(False)
  980.  
  981.     
  982.     def parse(self, elt, ps):
  983.         self.checkname(elt, ps)
  984.         elt = self.SimpleHREF(elt, ps, 'boolean')
  985.         if not elt:
  986.             return None
  987.         if self.nilled(elt, ps):
  988.             return Nilled
  989.         v = self.simple_value(elt, ps).lower()
  990.         return self.text_to_data(v, elt, ps)
  991.  
  992.     
  993.     def get_formatted_content(self, pyobj):
  994.         if pyobj:
  995.             return 'true'
  996.         return 'false'
  997.  
  998.  
  999.  
  1000. class XML(TypeCode):
  1001.     copyit = 0
  1002.     logger = _GetLogger('ZSI.TC.XML')
  1003.     
  1004.     def __init__(self, pname = None, comments = 0, inline = 0, wrapped = True, **kw):
  1005.         TypeCode.__init__(self, pname, **kw)
  1006.         self.comments = comments
  1007.         self.inline = inline
  1008.         if kw.has_key('resolver'):
  1009.             self.resolver = kw['resolver']
  1010.         
  1011.         self.wrapped = wrapped
  1012.         self.copyit = kw.get('copyit', XML.copyit)
  1013.  
  1014.     
  1015.     def parse(self, elt, ps):
  1016.         if self.wrapped is False:
  1017.             return elt
  1018.         c = _child_elements(elt)
  1019.         if _find_encstyle(elt) != '':
  1020.             pass
  1021.         
  1022.         if len(c) != 1:
  1023.             raise EvaluateException('Embedded XML has more than one child', ps.Backtrace(elt))
  1024.         len(c) != 1
  1025.         if self.copyit:
  1026.             return c[0].cloneNode(1)
  1027.         return c[0]
  1028.  
  1029.     
  1030.     def serialize(self, elt, sw, pyobj, name = None, unsuppressedPrefixes = [], **kw):
  1031.         objid = _get_idstr(pyobj)
  1032.         (ns, n) = self.get_name(name, objid)
  1033.         xmlelt = elt
  1034.         if self.wrapped:
  1035.             xmlelt = elt.createAppendElement(ns, n)
  1036.         
  1037.         self.cb(xmlelt, sw, pyobj, unsuppressedPrefixes)
  1038.  
  1039.     
  1040.     def cb(self, elt, sw, pyobj, unsuppressedPrefixes = []):
  1041.         if type(pyobj) in _stringtypes:
  1042.             elt.createAppendTextNode(pyobj)
  1043.             return None
  1044.         doc = elt.getDocument()
  1045.         node = doc.importNode(pyobj, deep = 1)
  1046.         child = elt.node.appendChild(node)
  1047.         parent = pyobj.parentNode
  1048.         while parent.nodeType == _Node.ELEMENT_NODE:
  1049.             for attr in (filter,)((lambda a: if a.name.startswith('xmlns:'):
  1050. passa.name not in child.attributes.keys()), parent.attributes):
  1051.                 child.setAttributeNode(attr.cloneNode(1))
  1052.             
  1053.             parent = parent.parentNode
  1054.             continue
  1055.             type(pyobj) in _stringtypes
  1056.  
  1057.  
  1058.  
  1059. class AnyType(TypeCode):
  1060.     all = '#all'
  1061.     other = '#other'
  1062.     type = (SCHEMA.XSD3, 'anyType')
  1063.     logger = _GetLogger('ZSI.TC.AnyType')
  1064.     
  1065.     def __init__(self, pname = None, namespaces = [
  1066.         '#all'], minOccurs = 1, maxOccurs = 1, strip = 1, **kw):
  1067.         TypeCode.__init__(self, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, **kw)
  1068.         self.namespaces = namespaces
  1069.  
  1070.     
  1071.     def get_formatted_content(self, pyobj):
  1072.         what = getattr(pyobj, 'typecode', Any())
  1073.         return what.get_formatted_content(pyobj)
  1074.  
  1075.     
  1076.     def text_to_data(self, text, elt, ps):
  1077.         return text
  1078.  
  1079.     
  1080.     def serialize(self, elt, sw, pyobj, **kw):
  1081.         (nsuri, typeName) = _get_xsitype(pyobj)
  1082.         if self.all not in self.namespaces and nsuri not in self.namespaces:
  1083.             raise EvaluateException('<anyType> unsupported use of namespaces "%s"' % self.namespaces)
  1084.         nsuri not in self.namespaces
  1085.         what = getattr(pyobj, 'typecode', None)
  1086.         if what is None:
  1087.             what = Any(pname = (self.nspname, self.pname), unique = True, aslist = False)
  1088.             kw['typed'] = True
  1089.             what.serialize(elt, sw, pyobj, **kw)
  1090.             return None
  1091.         if not self.nspname:
  1092.             pass
  1093.         if not self.pname:
  1094.             pass
  1095.         what.serialize(elt, sw, pyobj, name = (what.nspname, what.pname), **kw)
  1096.  
  1097.     
  1098.     def parse(self, elt, ps):
  1099.         (nspname, pname) = _get_element_nsuri_name(elt)
  1100.         if nspname != self.nspname or pname != self.pname:
  1101.             raise EvaluateException('<anyType> instance is (%s,%s) found (%s,%s)' % (self.nspname, self.pname, nspname, pname), ps.Backtrace(elt))
  1102.         pname != self.pname
  1103.         (prefix, typeName) = SplitQName(_find_type(elt))
  1104.         namespaceURI = _resolve_prefix(elt, prefix)
  1105.         pyclass = GTD(namespaceURI, typeName)
  1106.         if not pyclass:
  1107.             if _is_xsd_or_soap_ns(namespaceURI):
  1108.                 pyclass = Any
  1109.             elif str(namespaceURI).lower() == str(Apache.Map.type[0]).lower() and str(typeName).lower() == str(Apache.Map.type[1]).lower():
  1110.                 pyclass = Apache.Map
  1111.             else:
  1112.                 pyobj = Any().parse_into_dict_or_list(elt, ps)
  1113.                 return pyobj
  1114.         str(typeName).lower() == str(Apache.Map.type[1]).lower()
  1115.         what = pyclass(pname = (self.nspname, self.pname))
  1116.         pyobj = what.parse(elt, ps)
  1117.         return pyobj
  1118.  
  1119.  
  1120.  
  1121. class AnyElement(AnyType):
  1122.     tag = (SCHEMA.XSD3, 'any')
  1123.     logger = _GetLogger('ZSI.TC.AnyElement')
  1124.     
  1125.     def __init__(self, namespaces = [
  1126.         '#all'], pname = None, minOccurs = 1, maxOccurs = 1, strip = 1, processContents = 'strict', **kw):
  1127.         if processContents not in ('lax', 'skip', 'strict'):
  1128.             raise ValueError('processContents(%s) must be lax, skip, or strict')
  1129.         processContents not in ('lax', 'skip', 'strict')
  1130.         self.processContents = processContents
  1131.         AnyType.__init__(self, namespaces = namespaces, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, strip = strip, **kw)
  1132.  
  1133.     
  1134.     def serialize(self, elt, sw, pyobj, **kw):
  1135.         if isinstance(pyobj, TypeCode):
  1136.             raise TypeError, 'pyobj is a typecode instance.'
  1137.         isinstance(pyobj, TypeCode)
  1138.         what = getattr(pyobj, 'typecode', None)
  1139.         if what is not None and type(pyobj) is types.InstanceType:
  1140.             tc = pyobj.__class__
  1141.             what = Any.serialmap.get(tc)
  1142.             if not what:
  1143.                 tc = (types.ClassType, pyobj.__class__.__name__)
  1144.                 what = Any.serialmap.get(tc)
  1145.             
  1146.         
  1147.         self.logger.debug('processContents: %s', self.processContents)
  1148.         if what is None:
  1149.             what = Any(pname = (self.nspname, self.pname))
  1150.         
  1151.         self.logger.debug('serialize with %s', what.__class__.__name__)
  1152.         what.serialize(elt, sw, pyobj, **kw)
  1153.  
  1154.     
  1155.     def parse(self, elt, ps):
  1156.         skip = self.processContents == 'skip'
  1157.         (nspname, pname) = _get_element_nsuri_name(elt)
  1158.         what = GED(nspname, pname)
  1159.         if not skip and what is not None:
  1160.             pyobj = what.parse(elt, ps)
  1161.             
  1162.             try:
  1163.                 pyobj.typecode = what
  1164.             except AttributeError:
  1165.                 ex = None
  1166.                 pyobj = WrapImmutable(pyobj, what)
  1167.  
  1168.             return pyobj
  1169.         (prefix, typeName) = SplitQName(_find_type(elt))
  1170.         if not skip and typeName:
  1171.             if not prefix:
  1172.                 pass
  1173.             namespaceURI = _resolve_prefix(elt, 'xmlns')
  1174.             if not GTD(namespaceURI, typeName):
  1175.                 pass
  1176.             pyclass = Any
  1177.             what = pyclass(pname = (nspname, pname))
  1178.             pyobj = what.parse(elt, ps)
  1179.             
  1180.             try:
  1181.                 pyobj.typecode = what
  1182.             except AttributeError:
  1183.                 what is not None
  1184.                 ex = what is not None
  1185.                 pyobj = WrapImmutable(pyobj, what)
  1186.             except:
  1187.                 what is not None
  1188.  
  1189.             what.typed = True
  1190.             return pyobj
  1191.         if skip:
  1192.             what = XML(pname = (nspname, pname), wrapped = False)
  1193.         elif self.processContents == 'lax':
  1194.             what = Any(pname = (nspname, pname), unique = True)
  1195.         else:
  1196.             what = Any(pname = (nspname, pname), unique = True)
  1197.         
  1198.         try:
  1199.             pyobj = what.parse(elt, ps)
  1200.         except EvaluateException:
  1201.             ex = None
  1202.             self.logger.debug('error parsing:  %s' % str(ex))
  1203.             if len(_children(elt)) != 0:
  1204.                 self.logger.debug('parse <any>, return as dict')
  1205.                 return Any(aslist = False).parse_into_dict_or_list(elt, ps)
  1206.             self.logger.debug('Give up, parse (%s,%s) as a String', what.nspname, what.pname)
  1207.             what = String(pname = (nspname, pname), typed = False)
  1208.             return WrapImmutable(what.parse(elt, ps), what)
  1209.             len(_children(elt)) != 0
  1210.  
  1211.         if pyobj is None:
  1212.             return None
  1213.         if type(pyobj) is dict:
  1214.             return pyobj
  1215.         
  1216.         try:
  1217.             pyobj.typecode = what
  1218.         except AttributeError:
  1219.             type(pyobj) is dict
  1220.             type(pyobj) is dict
  1221.             pyobj is None
  1222.             pyobj = WrapImmutable(pyobj, what)
  1223.         except:
  1224.             type(pyobj) is dict
  1225.  
  1226.         return pyobj
  1227.  
  1228.  
  1229.  
  1230. class Union(SimpleType):
  1231.     memberTypes = None
  1232.     logger = _GetLogger('ZSI.TC.Union')
  1233.     
  1234.     def __init__(self, pname = None, minOccurs = 1, maxOccurs = 1, **kw):
  1235.         SimpleType.__init__(self, pname = pname, minOccurs = minOccurs, maxOccurs = maxOccurs, **kw)
  1236.         self.memberTypeCodes = []
  1237.  
  1238.     
  1239.     def setMemberTypeCodes(self):
  1240.         if len(self.memberTypeCodes) > 0:
  1241.             return None
  1242.         if self.__class__.memberTypes is None:
  1243.             raise EvaluateException, 'uninitialized class variable memberTypes [(namespace,name),]'
  1244.         self.__class__.memberTypes is None
  1245.         for nsuri, name in self.__class__.memberTypes:
  1246.             tcclass = GTD(nsuri, name)
  1247.             if tcclass is None:
  1248.                 if not Any.parsemap.get((nsuri, name)):
  1249.                     pass
  1250.                 tc = Any.parsemap.get((None, name))
  1251.                 typecode = tc.__class__(pname = (self.nspname, self.pname))
  1252.             else:
  1253.                 typecode = tcclass(pname = (self.nspname, self.pname))
  1254.             if typecode is None:
  1255.                 raise EvaluateException, 'Typecode class for Union memberType (%s,%s) is missing' % (nsuri, name)
  1256.             typecode is None
  1257.             if isinstance(typecode, Struct):
  1258.                 raise EvaluateException, 'Illegal: Union memberType (%s,%s) is complexType' % (nsuri, name)
  1259.             isinstance(typecode, Struct)
  1260.             self.memberTypeCodes.append(typecode)
  1261.         
  1262.  
  1263.     
  1264.     def parse(self, elt, ps, **kw):
  1265.         self.setMemberTypeCodes()
  1266.         (nsuri, typeName) = self.checkname(elt, ps)
  1267.         for indx in range(len(self.memberTypeCodes)):
  1268.             typecode = self.memberTypeCodes[indx]
  1269.             
  1270.             try:
  1271.                 pyobj = typecode.parse(elt, ps)
  1272.             except ParseException:
  1273.                 ex = None
  1274.                 continue
  1275.             except Exception:
  1276.                 ex = None
  1277.                 continue
  1278.  
  1279.             if indx > 0:
  1280.                 self.memberTypeCodes.remove(typecode)
  1281.                 self.memberTypeCodes.insert(0, typecode)
  1282.             
  1283.         else:
  1284.             raise 
  1285.  
  1286.     
  1287.     def get_formatted_content(self, pyobj, **kw):
  1288.         self.setMemberTypeCodes()
  1289.         for indx in range(len(self.memberTypeCodes)):
  1290.             typecode = self.memberTypeCodes[indx]
  1291.             
  1292.             try:
  1293.                 content = typecode.get_formatted_content(copy.copy(pyobj))
  1294.             except (ParseException, TypeError):
  1295.                 pass
  1296.  
  1297.             if indx > 0:
  1298.                 self.memberTypeCodes.remove(typecode)
  1299.                 self.memberTypeCodes.insert(0, typecode)
  1300.                 continue
  1301.         else:
  1302.             raise 
  1303.  
  1304.  
  1305.  
  1306. class List(SimpleType):
  1307.     itemType = None
  1308.     logger = _GetLogger('ZSI.TC.List')
  1309.     
  1310.     def __init__(self, pname = None, itemType = None, **kw):
  1311.         SimpleType.__init__(self, pname = pname, **kw)
  1312.         if not itemType:
  1313.             pass
  1314.         self.itemType = self.itemType
  1315.         self.itemTypeCode = self.itemType
  1316.         itemTypeCode = None
  1317.         if type(self.itemTypeCode) in _seqtypes:
  1318.             (namespaceURI, name) = self.itemTypeCode
  1319.             
  1320.             try:
  1321.                 itemTypeCode = GTD(*self.itemType)(None)
  1322.             except:
  1323.                 if _is_xsd_or_soap_ns(namespaceURI) is False:
  1324.                     raise 
  1325.                 _is_xsd_or_soap_ns(namespaceURI) is False
  1326.                 for pyclass in TYPES:
  1327.                     if pyclass.type == self.itemTypeCode:
  1328.                         itemTypeCode = pyclass(None)
  1329.                         break
  1330.                         continue
  1331.                     if pyclass.type[1] == name:
  1332.                         itemTypeCode = pyclass(None)
  1333.                         continue
  1334.                 
  1335.                 if itemTypeCode is None:
  1336.                     raise EvaluateException('Failed to locate %s' % str(self.itemTypeCode))
  1337.                 itemTypeCode is None
  1338.  
  1339.             if hasattr(itemTypeCode, 'text_to_data') is False:
  1340.                 raise EvaluateException('TypeCode class %s missing text_to_data method' % itemTypeCode)
  1341.             hasattr(itemTypeCode, 'text_to_data') is False
  1342.             self.itemTypeCode = itemTypeCode
  1343.         
  1344.  
  1345.     
  1346.     def text_to_data(self, text, elt, ps):
  1347.         v = []
  1348.         items = text.split()
  1349.         for item in items:
  1350.             v.append(self.itemTypeCode.text_to_data(item, elt, ps))
  1351.         
  1352.         if self.pyclass is not None:
  1353.             return self.pyclass(v)
  1354.         return v
  1355.  
  1356.     
  1357.     def parse(self, elt, ps):
  1358.         self.checkname(elt, ps)
  1359.         if len(_children(elt)) == 0:
  1360.             href = _find_href(elt)
  1361.             if not href:
  1362.                 if self.nilled(elt, ps) is False:
  1363.                     return []
  1364.                 if self.nillable is True:
  1365.                     return Nilled
  1366.                 raise EvaluateException('Required string missing', ps.Backtrace(elt))
  1367.             href
  1368.             if href[0] != '#':
  1369.                 return ps.ResolveHREF(href, self)
  1370.             elt = ps.FindLocalHREF(href, elt)
  1371.             self.checktype(elt, ps)
  1372.         
  1373.         if self.nilled(elt, ps):
  1374.             return Nilled
  1375.         if len(_children(elt)) == 0:
  1376.             return []
  1377.         v = self.simple_value(elt, ps)
  1378.         return self.text_to_data(v, elt, ps)
  1379.  
  1380.     
  1381.     def serialize(self, elt, sw, pyobj, name = None, orig = None, **kw):
  1382.         if pyobj is not None and type(pyobj) not in _seqtypes:
  1383.             raise EvaluateException, 'expecting a list or None'
  1384.         type(pyobj) not in _seqtypes
  1385.         objid = _get_idstr(pyobj)
  1386.         (ns, n) = self.get_name(name, objid)
  1387.         el = elt.createAppendElement(ns, n)
  1388.         if self.nillable is True and pyobj is None:
  1389.             self.serialize_as_nil(el)
  1390.             return None
  1391.         tc = self.itemTypeCode
  1392.         s = StringIO()
  1393.         sep = ' '
  1394.         for item in pyobj:
  1395.             s.write(tc.get_formatted_content(item))
  1396.             s.write(sep)
  1397.         
  1398.         el.createAppendTextNode(s.getvalue())
  1399.  
  1400.  
  1401.  
  1402. def RegisterType(C, clobber = 0, *args, **keywords):
  1403.     instance = apply(C, args, keywords)
  1404.     for t in C.__dict__.get('parselist', []):
  1405.         prev = Any.parsemap.get(t)
  1406.         if prev:
  1407.             if prev.__class__ == C:
  1408.                 continue
  1409.             
  1410.             if not clobber:
  1411.                 raise TypeError(str(C) + ' duplicating parse registration for ' + str(t))
  1412.             clobber
  1413.         
  1414.         Any.parsemap[t] = instance
  1415.     
  1416.     for t in C.__dict__.get('seriallist', []):
  1417.         ti = type(t)
  1418.         if ti in [
  1419.             types.TypeType,
  1420.             types.ClassType]:
  1421.             key = t
  1422.         elif ti in _stringtypes:
  1423.             key = (types.ClassType, t)
  1424.         else:
  1425.             raise TypeError(str(t) + ' is not a class name')
  1426.         prev = (ti in [
  1427.             types.TypeType,
  1428.             types.ClassType]).serialmap.get(key)
  1429.         if prev:
  1430.             if prev.__class__ == C:
  1431.                 continue
  1432.             
  1433.             if not clobber:
  1434.                 raise TypeError(str(C) + ' duplicating serial registration for ' + str(t))
  1435.             clobber
  1436.         
  1437.         Any.serialmap[key] = instance
  1438.     
  1439.  
  1440. from TCnumbers import *
  1441. from TCtimes import *
  1442. from schema import GTD, GED, WrapImmutable
  1443. from TCcompound import *
  1444. from TCapache import *
  1445. (_get_type_definition, _get_global_element_declaration, Wrap) = (GTD, GED, WrapImmutable)
  1446.  
  1447. f = lambda x: if type(x) == types.ClassType and issubclass(x, TypeCode):
  1448. passgetattr(x, 'type', None) is not None
  1449. TYPES = filter(f, map((lambda y: eval(y)), dir()))
  1450. if __name__ == '__main__':
  1451.     print _copyright
  1452.  
  1453.