home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / msn / SOAP / xml / wsse.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  14.7 KB  |  404 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import ZSI
  5. import ZSI.TCcompound as ZSI
  6. import ZSI.wstools.Namespaces as NS
  7. from ZSI.schema import LocalElementDeclaration, ElementDeclaration, TypeDefinition, GTD, GED
  8. from ZSI.generate.pyclass import pyclass_type
  9.  
  10. class wsse:
  11.     targetNamespace = NS.OASIS.WSSE
  12.     
  13.     class SecurityTokenReferenceType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  14.         schema = NS.OASIS.WSSE
  15.         type = (schema, 'SecurityTokenReferenceType')
  16.         
  17.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  18.             ns = wsse.SecurityTokenReferenceType_Def.schema
  19.             TClist = [
  20.                 ZSI.TC.AnyElement(aname = '_any', minOccurs = 0, maxOccurs = 'unbounded', nillable = False, processContents = 'lax'),
  21.                 GED(NS.OASIS.WSSE, 'Reference', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 'unbounded', nillable = False, encoded = kw.get('encoded'))]
  22.             if not attributes:
  23.                 pass
  24.             self.attribute_typecode_dict = { }
  25.             if extend:
  26.                 TClist += ofwhat
  27.             
  28.             if restrict:
  29.                 TClist = ofwhat
  30.             else:
  31.                 self.attribute_typecode_dict['Id'] = ZSI.TC.String()
  32.                 self.attribute_typecode_dict['Usage'] = ZSI.TC.String()
  33.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  34.             
  35.             class Holder(()):
  36.                 __metaclass__ = pyclass_type
  37.                 typecode = self
  38.                 
  39.                 def __init__(self):
  40.                     self._any = []
  41.                     self._Reference = None
  42.  
  43.  
  44.             Holder.__name__ = 'SecurityTokenReferenceType_Holder'
  45.             self.pyclass = Holder
  46.  
  47.  
  48.     
  49.     class SecurityHeaderType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  50.         schema = NS.OASIS.WSSE
  51.         type = (schema, 'SecurityHeaderType')
  52.         
  53.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  54.             ns = wsse.SecurityHeaderType_Def.schema
  55.             TClist = [
  56.                 GED(NS.OASIS.WSSE, 'UsernameToken', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded')),
  57.                 GED(NS.OASIS.UTILITY, 'Timestamp', lazy = False, isref = True)(minOccurs = 0, maxOccurs = 1, nillable = False, encoded = kw.get('encoded'))]
  58.             if not attributes:
  59.                 pass
  60.             self.attribute_typecode_dict = { }
  61.             if extend:
  62.                 TClist += ofwhat
  63.             
  64.             if restrict:
  65.                 TClist = ofwhat
  66.             
  67.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  68.             
  69.             class Holder(()):
  70.                 __metaclass__ = pyclass_type
  71.                 typecode = self
  72.                 
  73.                 def __init__(self):
  74.                     self._UsernameToken = None
  75.                     self._Timestamp = None
  76.                     self._Assertion = None
  77.  
  78.  
  79.             Holder.__name__ = 'SecurityHeaderType_Holder'
  80.             self.pyclass = Holder
  81.  
  82.  
  83.     
  84.     class UsernameTokenType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  85.         schema = NS.OASIS.WSSE
  86.         type = (schema, 'UsernameTokenType')
  87.         
  88.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  89.             ns = wsse.UsernameTokenType_Def.schema
  90.             TClist = [
  91.                 GTD(NS.OASIS.WSSE, 'AttributedString', lazy = False)(pname = (ns, 'Username'), aname = '_Username', minOccurs = 1, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded')),
  92.                 GTD(NS.OASIS.WSSE, 'PasswordString', lazy = False)(pname = (ns, 'Password'), aname = '_Password', minOccurs = 1, maxOccurs = 1, nillable = False, typed = False, encoded = kw.get('encoded'))]
  93.             if not attributes:
  94.                 pass
  95.             self.attribute_typecode_dict = { }
  96.             if extend:
  97.                 TClist += ofwhat
  98.             
  99.             if restrict:
  100.                 TClist = ofwhat
  101.             else:
  102.                 self.attribute_typecode_dict[(NS.OASIS.UTILITY, 'Id')] = ZSI.TC.AnyType()
  103.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  104.             
  105.             class Holder(()):
  106.                 __metaclass__ = pyclass_type
  107.                 typecode = self
  108.                 
  109.                 def __init__(self):
  110.                     self._Username = None
  111.                     self._Password = None
  112.  
  113.  
  114.             Holder.__name__ = 'UsernameTokenType_Holder'
  115.             self.pyclass = Holder
  116.  
  117.  
  118.     
  119.     class AttributedString_Def(ZSI.TC.String, TypeDefinition):
  120.         schema = NS.OASIS.WSSE
  121.         type = (schema, 'AttributedString')
  122.         
  123.         def __init__(self, pname, **kw):
  124.             if getattr(self, 'attribute_typecode_dict', None) is None:
  125.                 self.attribute_typecode_dict = { }
  126.             
  127.             self.attribute_typecode_dict['Id'] = ZSI.TC.String()
  128.             ZSI.TC.String.__init__(self, pname, **kw)
  129.             
  130.             class Holder((str,)):
  131.                 __metaclass__ = pyclass_type
  132.                 typecode = self
  133.  
  134.             self.pyclass = Holder
  135.  
  136.  
  137.     
  138.     class PasswordString_Def(TypeDefinition):
  139.         schema = NS.OASIS.WSSE
  140.         type = (schema, 'PasswordString')
  141.         
  142.         def __init__(self, pname, **kw):
  143.             ns = wsse.PasswordString_Def.schema
  144.             if wsse.AttributedString_Def not in wsse.PasswordString_Def.__bases__:
  145.                 bases = list(wsse.PasswordString_Def.__bases__)
  146.                 bases.insert(0, wsse.AttributedString_Def)
  147.                 wsse.PasswordString_Def.__bases__ = tuple(bases)
  148.             
  149.             if getattr(self, 'attribute_typecode_dict', None) is None:
  150.                 self.attribute_typecode_dict = { }
  151.             
  152.             wsse.AttributedString_Def.__init__(self, pname, **kw)
  153.  
  154.  
  155.     
  156.     class EncodedString_Def(TypeDefinition):
  157.         schema = NS.OASIS.WSSE
  158.         type = (schema, 'EncodedString')
  159.         
  160.         def __init__(self, pname, **kw):
  161.             ns = wsse.EncodedString_Def.schema
  162.             if wsse.AttributedString_Def not in wsse.EncodedString_Def.__bases__:
  163.                 bases = list(wsse.EncodedString_Def.__bases__)
  164.                 bases.insert(0, wsse.AttributedString_Def)
  165.                 wsse.EncodedString_Def.__bases__ = tuple(bases)
  166.             
  167.             if getattr(self, 'attribute_typecode_dict', None) is None:
  168.                 self.attribute_typecode_dict = { }
  169.             
  170.             wsse.AttributedString_Def.__init__(self, pname, **kw)
  171.  
  172.  
  173.     
  174.     class ReferenceType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
  175.         schema = NS.OASIS.WSSE
  176.         type = (schema, 'ReferenceType')
  177.         
  178.         def __init__(self, pname, ofwhat = (), attributes = None, extend = False, restrict = False, **kw):
  179.             ns = wsse.ReferenceType_Def.schema
  180.             TClist = []
  181.             if not attributes:
  182.                 pass
  183.             self.attribute_typecode_dict = { }
  184.             if extend:
  185.                 TClist += ofwhat
  186.             
  187.             if restrict:
  188.                 TClist = ofwhat
  189.             else:
  190.                 self.attribute_typecode_dict['URI'] = ZSI.TC.URI()
  191.                 self.attribute_typecode_dict['ValueType'] = ZSI.TC.QName()
  192.                 self.attribute_typecode_dict[(NS.SCHEMA.BASE, 'anyAttribute')] = ZSI.TC.AnyElement()
  193.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname = pname, inorder = 0, **kw)
  194.             
  195.             class Holder(()):
  196.                 __metaclass__ = pyclass_type
  197.                 typecode = self
  198.                 
  199.                 def __init__(self):
  200.                     pass
  201.  
  202.  
  203.             Holder.__name__ = 'ReferenceType_Holder'
  204.             self.pyclass = Holder
  205.  
  206.  
  207.     
  208.     class KeyIdentifierType_Def(TypeDefinition):
  209.         schema = NS.OASIS.WSSE
  210.         type = (schema, 'KeyIdentifierType')
  211.         
  212.         def __init__(self, pname, **kw):
  213.             ns = wsse.KeyIdentifierType_Def.schema
  214.             if wsse.EncodedString_Def not in wsse.KeyIdentifierType_Def.__bases__:
  215.                 bases = list(wsse.KeyIdentifierType_Def.__bases__)
  216.                 bases.insert(0, wsse.EncodedString_Def)
  217.                 wsse.KeyIdentifierType_Def.__bases__ = tuple(bases)
  218.             
  219.             if getattr(self, 'attribute_typecode_dict', None) is None:
  220.                 self.attribute_typecode_dict = { }
  221.             
  222.             wsse.EncodedString_Def.__init__(self, pname, **kw)
  223.  
  224.  
  225.     
  226.     class BinarySecurityTokenType_Def(TypeDefinition):
  227.         schema = NS.OASIS.WSSE
  228.         type = (schema, 'BinarySecurityTokenType')
  229.         
  230.         def __init__(self, pname, **kw):
  231.             ns = wsse.BinarySecurityTokenType_Def.schema
  232.             if wsse.EncodedString_Def not in wsse.BinarySecurityTokenType_Def.__bases__:
  233.                 bases = list(wsse.BinarySecurityTokenType_Def.__bases__)
  234.                 bases.insert(0, wsse.EncodedString_Def)
  235.                 wsse.BinarySecurityTokenType_Def.__bases__ = tuple(bases)
  236.             
  237.             if getattr(self, 'attribute_typecode_dict', None) is None:
  238.                 self.attribute_typecode_dict = { }
  239.             
  240.             wsse.EncodedString_Def.__init__(self, pname, **kw)
  241.  
  242.  
  243.     
  244.     class FaultcodeEnum_Def(ZSI.TC.QName, TypeDefinition):
  245.         schema = NS.OASIS.WSSE
  246.         type = (schema, 'FaultcodeEnum')
  247.         
  248.         def __init__(self, pname, **kw):
  249.             ZSI.TC.QName.__init__(self, pname, pyclass = None, **kw)
  250.             
  251.             class Holder((str,)):
  252.                 typecode = self
  253.  
  254.             self.pyclass = Holder
  255.  
  256.  
  257.     
  258.     class SecurityTokenReference_Dec(ElementDeclaration):
  259.         literal = 'SecurityTokenReference'
  260.         schema = NS.OASIS.WSSE
  261.         substitutionGroup = None
  262.         
  263.         def __init__(self, **kw):
  264.             kw['pname'] = (NS.OASIS.WSSE, 'SecurityTokenReference')
  265.             kw['aname'] = '_SecurityTokenReference'
  266.             if wsse.SecurityTokenReferenceType_Def not in wsse.SecurityTokenReference_Dec.__bases__:
  267.                 bases = list(wsse.SecurityTokenReference_Dec.__bases__)
  268.                 bases.insert(0, wsse.SecurityTokenReferenceType_Def)
  269.                 wsse.SecurityTokenReference_Dec.__bases__ = tuple(bases)
  270.             
  271.             wsse.SecurityTokenReferenceType_Def.__init__(self, **kw)
  272.             if self.pyclass is not None:
  273.                 self.pyclass.__name__ = 'SecurityTokenReference_Dec_Holder'
  274.             
  275.  
  276.  
  277.     
  278.     class Security_Dec(ElementDeclaration):
  279.         literal = 'Security'
  280.         schema = NS.OASIS.WSSE
  281.         substitutionGroup = None
  282.         
  283.         def __init__(self, **kw):
  284.             kw['pname'] = (NS.OASIS.WSSE, 'Security')
  285.             kw['aname'] = '_Security'
  286.             if wsse.SecurityHeaderType_Def not in wsse.Security_Dec.__bases__:
  287.                 bases = list(wsse.Security_Dec.__bases__)
  288.                 bases.insert(0, wsse.SecurityHeaderType_Def)
  289.                 wsse.Security_Dec.__bases__ = tuple(bases)
  290.             
  291.             wsse.SecurityHeaderType_Def.__init__(self, **kw)
  292.             if self.pyclass is not None:
  293.                 self.pyclass.__name__ = 'Security_Dec_Holder'
  294.             
  295.  
  296.  
  297.     
  298.     class UsernameToken_Dec(ElementDeclaration):
  299.         literal = 'UsernameToken'
  300.         schema = NS.OASIS.WSSE
  301.         substitutionGroup = None
  302.         
  303.         def __init__(self, **kw):
  304.             kw['pname'] = (NS.OASIS.WSSE, 'UsernameToken')
  305.             kw['aname'] = '_UsernameToken'
  306.             if wsse.UsernameTokenType_Def not in wsse.UsernameToken_Dec.__bases__:
  307.                 bases = list(wsse.UsernameToken_Dec.__bases__)
  308.                 bases.insert(0, wsse.UsernameTokenType_Def)
  309.                 wsse.UsernameToken_Dec.__bases__ = tuple(bases)
  310.             
  311.             wsse.UsernameTokenType_Def.__init__(self, **kw)
  312.             if self.pyclass is not None:
  313.                 self.pyclass.__name__ = 'UsernameToken_Dec_Holder'
  314.             
  315.  
  316.  
  317.     
  318.     class KeyIdentifier_Dec(ElementDeclaration):
  319.         literal = 'KeyIdentifier'
  320.         schema = NS.OASIS.WSSE
  321.         substitutionGroup = None
  322.         
  323.         def __init__(self, **kw):
  324.             kw['pname'] = (NS.OASIS.WSSE, 'KeyIdentifier')
  325.             kw['aname'] = '_KeyIdentifier'
  326.             if wsse.KeyIdentifierType_Def not in wsse.KeyIdentifier_Dec.__bases__:
  327.                 bases = list(wsse.KeyIdentifier_Dec.__bases__)
  328.                 bases.insert(0, wsse.KeyIdentifierType_Def)
  329.                 wsse.KeyIdentifier_Dec.__bases__ = tuple(bases)
  330.             
  331.             wsse.KeyIdentifierType_Def.__init__(self, **kw)
  332.             if self.pyclass is not None:
  333.                 self.pyclass.__name__ = 'KeyIdentifier_Dec_Holder'
  334.             
  335.  
  336.  
  337.     
  338.     class Reference_Dec(ElementDeclaration):
  339.         literal = 'Reference'
  340.         schema = NS.OASIS.WSSE
  341.         substitutionGroup = None
  342.         
  343.         def __init__(self, **kw):
  344.             kw['pname'] = (NS.OASIS.WSSE, 'Reference')
  345.             kw['aname'] = '_Reference'
  346.             if wsse.ReferenceType_Def not in wsse.Reference_Dec.__bases__:
  347.                 bases = list(wsse.Reference_Dec.__bases__)
  348.                 bases.insert(0, wsse.ReferenceType_Def)
  349.                 wsse.Reference_Dec.__bases__ = tuple(bases)
  350.             
  351.             wsse.ReferenceType_Def.__init__(self, **kw)
  352.             if self.pyclass is not None:
  353.                 self.pyclass.__name__ = 'Reference_Dec_Holder'
  354.             
  355.  
  356.  
  357.     
  358.     class BinarySecurityToken_Dec(ElementDeclaration):
  359.         literal = 'BinarySecurityToken'
  360.         schema = NS.OASIS.WSSE
  361.         substitutionGroup = None
  362.         
  363.         def __init__(self, **kw):
  364.             kw['pname'] = (NS.OASIS.WSSE, 'BinarySecurityToken')
  365.             kw['aname'] = '_BinarySecurityToken'
  366.             if wsse.BinarySecurityTokenType_Def not in wsse.BinarySecurityToken_Dec.__bases__:
  367.                 bases = list(wsse.BinarySecurityToken_Dec.__bases__)
  368.                 bases.insert(0, wsse.BinarySecurityTokenType_Def)
  369.                 wsse.BinarySecurityToken_Dec.__bases__ = tuple(bases)
  370.             
  371.             wsse.BinarySecurityTokenType_Def.__init__(self, **kw)
  372.             if self.pyclass is not None:
  373.                 self.pyclass.__name__ = 'BinarySecurityToken_Dec_Holder'
  374.             
  375.  
  376.  
  377.     
  378.     class PolicyReference_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
  379.         literal = 'PolicyReference'
  380.         schema = NS.OASIS.WSSE
  381.         
  382.         def __init__(self, **kw):
  383.             ns = wsse.PolicyReference_Dec.schema
  384.             TClist = []
  385.             kw['pname'] = (NS.OASIS.WSSE, 'PolicyReference')
  386.             kw['aname'] = '_PolicyReference'
  387.             self.attribute_typecode_dict = { }
  388.             ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder = 0, **kw)
  389.             self.attribute_typecode_dict['URI'] = ZSI.TC.URI()
  390.             
  391.             class Holder(()):
  392.                 __metaclass__ = pyclass_type
  393.                 typecode = self
  394.                 
  395.                 def __init__(self):
  396.                     pass
  397.  
  398.  
  399.             Holder.__name__ = 'PolicyReference_Holder'
  400.             self.pyclass = Holder
  401.  
  402.  
  403.  
  404.