Changeset 5620


Ignore:
Timestamp:
14/08/09 16:40:56 (10 years ago)
Author:
pjkersha
Message:

Assertion parsing near complete but fixes needed to XSGroupRoleElementTree

Location:
TI12-security/trunk/python/ndg.security.saml/saml
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.saml/saml/common/__init__.py

    r5597 r5620  
    3333    """Base class for all SAML types""" 
    3434    @classmethod 
    35     def parse(cls, xmlObject): 
     35    def fromXML(cls, xmlObject): 
     36        '''Parse from an XML representation into a SAML object 
     37        @type: XML class e.g. ElementTree or 4Suite XML 
     38        @param: XML representation of SAML Object 
     39        @rtype: saml.saml2.common.SAMLObject derived type 
     40        @return: SAML object 
     41        ''' 
    3642        raise NotImplementedError() 
    3743     
    3844    @classmethod 
    39     def create(cls, samlObject): 
     45    def toXML(cls, samlObject): 
     46        '''Convert the input SAML object into an XML representation 
     47        @type: saml.saml2.common.SAMLObject derived type 
     48        @param: SAML object 
     49        @rtype: XML class e.g. ElementTree or 4Suite XML 
     50        @return: XML representation of SAML Object 
     51        ''' 
    4052        raise NotImplementedError() 
    4153 
     
    4355class SAMLVersion(SAMLObject): 
    4456    """Version helper class""" 
     57     
    4558    VERSION_10 = (1, 0) 
    4659    VERSION_11 = (1, 1) 
  • TI12-security/trunk/python/ndg.security.saml/saml/saml2/core.py

    r5601 r5620  
    136136                               doc="the list of attribute values for this " 
    137137                               "attribute.") 
    138     
     138 
     139 
    139140class Statement(SAMLObject): 
    140     pass 
    141  
     141    '''SAML 2.0 Core Statement.  Abstract base class which all statement  
     142    types must implement.''' 
     143     
     144    # Element local name 
     145    DEFAULT_ELEMENT_LOCAL_NAME = "Statement" 
     146 
     147    # Default element name 
     148    DEFAULT_ELEMENT_NAME = QName(SAMLConstants.SAML20_NS,  
     149                                 DEFAULT_ELEMENT_LOCAL_NAME, 
     150                                 SAMLConstants.SAML20_PREFIX) 
     151 
     152    # Local name of the XSI type 
     153    TYPE_LOCAL_NAME = "StatementAbstractType" 
     154 
     155    # QName of the XSI type 
     156    TYPE_NAME = QName(SAMLConstants.SAML20_NS,  
     157                      TYPE_LOCAL_NAME, 
     158                      SAMLConstants.SAML20_PREFIX) 
     159     
     160             
    142161class AttributeStatement(Statement): 
    143162    '''SAML 2.0 Core AttributeStatement''' 
     
    176195    
    177196    encryptedAttributes = property(fget=_get_encryptedAttributes) 
    178          
    179      
     197 
     198 
     199class AuthnStatement(Statement): 
     200    '''SAML 2.0 Core AuthnStatement.  Currently implemented in abstract form 
     201    only 
     202    ''' 
     203 
     204    # Element local name 
     205    DEFAULT_ELEMENT_LOCAL_NAME = "AuthnStatement" 
     206 
     207    # Default element name 
     208    DEFAULT_ELEMENT_NAME = QName(SAMLConstants.SAML20_NS,  
     209                                 DEFAULT_ELEMENT_LOCAL_NAME, 
     210                                 SAMLConstants.SAML20_PREFIX) 
     211 
     212    # Local name of the XSI type 
     213    TYPE_LOCAL_NAME = "AuthnStatementType" 
     214 
     215    # QName of the XSI type 
     216    TYPE_NAME = QName(SAMLConstants.SAML20_NS,  
     217                      TYPE_LOCAL_NAME, 
     218                      SAMLConstants.SAML20_PREFIX) 
     219 
     220    # AuthnInstant attribute name 
     221    AUTHN_INSTANT_ATTRIB_NAME = "AuthnInstant" 
     222 
     223    # SessionIndex attribute name 
     224    SESSION_INDEX_ATTRIB_NAME = "SessionIndex" 
     225 
     226    # SessionNoOnOrAfter attribute name 
     227    SESSION_NOT_ON_OR_AFTER_ATTRIB_NAME = "SessionNotOnOrAfter" 
     228 
     229    def _getAuthnInstant(self): 
     230        '''Gets the time when the authentication took place. 
     231         
     232        @return the time when the authentication took place 
     233        ''' 
     234        raise NotImplementedError() 
     235 
     236    def _setAuthnInstant(self, value): 
     237        '''Sets the time when the authentication took place. 
     238         
     239        @param newAuthnInstant the time when the authentication took place 
     240        ''' 
     241        raise NotImplementedError() 
     242 
     243    def _getSessionIndex(self): 
     244        '''Get the session index between the principal and the authenticating  
     245        authority. 
     246         
     247        @return the session index between the principal and the authenticating  
     248        authority 
     249        ''' 
     250        raise NotImplementedError() 
     251 
     252    def _setSessionIndex(self, value): 
     253        '''Sets the session index between the principal and the authenticating  
     254        authority. 
     255         
     256        @param newIndex the session index between the principal and the  
     257        authenticating authority 
     258        ''' 
     259        raise NotImplementedError() 
     260 
     261    def _getSessionNotOnOrAfter(self): 
     262        '''Get the time when the session between the principal and the SAML  
     263        authority ends. 
     264         
     265        @return the time when the session between the principal and the SAML  
     266        authority ends 
     267        ''' 
     268        raise NotImplementedError() 
     269 
     270    def _setSessionNotOnOrAfter(self, value): 
     271        '''Set the time when the session between the principal and the SAML  
     272        authority ends. 
     273         
     274        @param newSessionNotOnOrAfter the time when the session between the  
     275        principal and the SAML authority ends 
     276        ''' 
     277        raise NotImplementedError() 
     278 
     279    def _getSubjectLocality(self): 
     280        '''Get the DNS domain and IP address of the system where the principal  
     281        was authenticated. 
     282         
     283        @return the DNS domain and IP address of the system where the principal 
     284        was authenticated 
     285        ''' 
     286        raise NotImplementedError() 
     287 
     288    def _setSubjectLocality(self, value): 
     289        '''Set the DNS domain and IP address of the system where the principal  
     290        was authenticated. 
     291         
     292        @param newLocality the DNS domain and IP address of the system where  
     293        the principal was authenticated 
     294        ''' 
     295        raise NotImplementedError() 
     296 
     297    def _getAuthnContext(self): 
     298        '''Gets the context used to authenticate the subject. 
     299         
     300        @return the context used to authenticate the subject 
     301        ''' 
     302        raise NotImplementedError() 
     303 
     304    def _setAuthnContext(self, value): 
     305        '''Sets the context used to authenticate the subject. 
     306         
     307        @param newAuthnContext the context used to authenticate the subject 
     308        ''' 
     309        raise NotImplementedError() 
     310             
     311 
     312class AuthzDecisionStatement(Statement): 
     313    '''SAML 2.0 Core AuthzDecisionStatement.  Currently implemented in abstract 
     314    form only''' 
     315     
     316    # Element local name 
     317    DEFAULT_ELEMENT_LOCAL_NAME = "AuthzDecisionStatement" 
     318 
     319    # Default element name 
     320    DEFAULT_ELEMENT_NAME = QName(SAMLConstants.SAML20_NS,  
     321                                 DEFAULT_ELEMENT_LOCAL_NAME, 
     322                                 SAMLConstants.SAML20_PREFIX) 
     323 
     324    # Local name of the XSI type 
     325    TYPE_LOCAL_NAME = "AuthzDecisionStatementType" 
     326 
     327    # QName of the XSI type 
     328    TYPE_NAME = QName(SAMLConstants.SAML20_NS,  
     329                      TYPE_LOCAL_NAME, 
     330                      SAMLConstants.SAML20_PREFIX) 
     331 
     332    # Resource attribute name 
     333    RESOURCE_ATTRIB_NAME = "Resource" 
     334 
     335    # Decision attribute name 
     336    DECISION_ATTRIB_NAME = "Decision" 
     337 
     338    def _getResource(self): 
     339        ''' 
     340        Get URI of the resource to which authorization is saught. 
     341         
     342        @return URI of the resource to which authorization is saught 
     343        ''' 
     344        raise NotImplementedError() 
     345 
     346    def _setResource(self, value): 
     347        ''' 
     348        Sets URI of the resource to which authorization is saught. 
     349         
     350        @param newResourceURI URI of the resource to which authorization is  
     351        saught 
     352        ''' 
     353        raise NotImplementedError() 
     354 
     355    def _getDecision(self): 
     356        ''' 
     357        Gets the decision of the authorization request. 
     358         
     359        @return the decision of the authorization request 
     360        ''' 
     361        raise NotImplementedError() 
     362 
     363    def _setDecision(self, value): 
     364        ''' 
     365        Sets the decision of the authorization request. 
     366         
     367        @param newDecision the decision of the authorization request 
     368        ''' 
     369        raise NotImplementedError() 
     370 
     371    def _getActions(self): 
     372        ''' 
     373        Gets the actions authorized to be performed. 
     374         
     375        @return the actions authorized to be performed 
     376        ''' 
     377        raise NotImplementedError() 
     378 
     379 
     380    def _getEvidence(self): 
     381        ''' 
     382        Get the SAML assertion the authority relied on when making the  
     383        authorization decision. 
     384         
     385        @return the SAML assertion the authority relied on when making the  
     386        authorization decision 
     387        ''' 
     388        raise NotImplementedError() 
     389 
     390    def _setEvidence(self, value): 
     391        ''' 
     392        Sets the SAML assertion the authority relied on when making the  
     393        authorization decision. 
     394         
     395        @param newEvidence the SAML assertion the authority relied on when  
     396        making the authorization decision 
     397        ''' 
     398        raise NotImplementedError() 
     399         
     400 
    180401class Subject(SAMLObject): 
    181402    '''Concrete implementation of @link org.opensaml.saml2.core.Subject.''' 
     
    8371058 
    8381059class AttributeValue(SAMLObject): 
    839  
     1060    """Base class for Attribute Value type""" 
     1061     
    8401062    # Element name, no namespace 
    8411063    DEFAULT_ELEMENT_LOCAL_NAME = "AttributeValue" 
     
    8461068                                 SAMLConstants.SAML20_PREFIX) 
    8471069 
     1070 
    8481071class XSStringAttributeValue(AttributeValue): 
    849  
     1072    """XML XS:String Attribute Value type""" 
     1073     
    8501074    # Local name of the XSI type 
    8511075    TYPE_LOCAL_NAME = "string" 
     
    9901214                             StatusDetail.DEFAULT_ELEMENT_NAME.prefix) 
    9911215     
    992     def getUnknownXMLObjects(self, qname=None):  
     1216    def getUnknownXMLTypes(self, qname=None):  
    9931217        if qname is not None: 
    9941218            if not isinstance(qname, QName): 
     
    10081232            return self.__unknownChildren 
    10091233     
    1010     unknownChildren = property(fget=getUnknownXMLObjects, 
     1234    unknownChildren = property(fget=getUnknownXMLTypes, 
    10111235                               doc="Child objects of Status Detail - may be " 
    10121236                                   "any type") 
  • TI12-security/trunk/python/ndg.security.saml/saml/test/test_saml.py

    r5601 r5620  
    2222 
    2323from saml.saml2.core import SAMLVersion, Attribute, AttributeStatement, \ 
    24     Assertion, AttributeValue, AttributeQuery, Response, Issuer, Subject, \ 
    25     NameID, StatusCode, Status, Conditions, XSStringAttributeValue, \ 
    26     XSGroupRoleAttributeValue 
     24    Assertion, AttributeQuery, Response, Issuer, Subject, NameID, StatusCode, \ 
     25    Status, Conditions, XSStringAttributeValue, XSGroupRoleAttributeValue 
    2726from saml.common.xml import SAMLConstants 
    2827from saml.xml.etree import prettyPrint, AssertionElementTree, \ 
    2928    XSGroupRoleAttributeValueElementTree, AttributeQueryElementTree, \ 
    30     ResponseElementTree, ConditionsElementTree 
     29    ResponseElementTree 
    3130 
    3231 
     
    4443        self.emailAddress = None 
    4544         
     45        # ESG Group/Role attribute type 
    4646        self.__groupRoleList = [] 
    4747        self.__miscAttrList = [] 
     
    8787 
    8888    def buildAttributeQuery(self, issuer, subjectNameID): 
    89          
     89        """Make a SAML Attribute Query 
     90        @type issuer: basestring 
     91        @param issuer: attribute issuer name 
     92        @type subjectNameID: basestring 
     93        @param subjectNameID: identity to query attributes for 
     94        """ 
    9095        attributeQuery = AttributeQuery() 
    9196        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20) 
     
    107112     
    108113    def createAttributes(self): 
     114        """Create SAML Attributes for use in an Assertion or AttributeQuery""" 
    109115         
    110116        attributes = [] 
     
    223229        # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    224230        # Attribute Value factory to render the XML output 
    225         attributeValueElementTreeClassMap = { 
     231        toXMLTypeMap = { 
    226232            XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    227233        } 
    228234         
    229235        # Create ElementTree Assertion Element 
    230         assertionElem = AssertionElementTree.create(assertion, 
    231                             customClassMap=attributeValueElementTreeClassMap) 
     236        assertionElem = AssertionElementTree.toXML(assertion, 
     237                                            customToXMLTypeMap=toXMLTypeMap) 
    232238         
    233239        self.assert_(iselement(assertionElem)) 
     
    246252        # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    247253        # Attribute Value factory to render the XML output 
    248         attributeValueElementTreeClassMap = { 
     254        toXMLTypeMap = { 
    249255            XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    250256        } 
    251257         
    252258        # Create ElementTree Assertion Element 
    253         assertionElem = AssertionElementTree.create(assertion, 
    254                             customClassMap=attributeValueElementTreeClassMap) 
     259        assertionElem = AssertionElementTree.toXML(assertion, 
     260                                            customToXMLTypeMap=toXMLTypeMap) 
    255261         
    256262        self.assert_(iselement(assertionElem)) 
     
    266272        elem2 = tree.getroot() 
    267273         
    268         assertionElem2 = AssertionElementTree.parse(elem2) 
     274        toSAMLTypeMap = [XSGroupRoleAttributeValueElementTree.factoryMatchFunc] 
     275         
     276        assertionElem2 = AssertionElementTree.fromXML(elem2, 
     277                                            customToSAMLTypeMap=toSAMLTypeMap) 
     278        self.assert_(assertionElem2) 
    269279         
    270280    def test03CreateAttributeQuery(self): 
     
    277287                        "https://openid.localhost/philip.kershaw") 
    278288         
    279         elem = AttributeQueryElementTree.create(attributeQuery)         
     289        elem = AttributeQueryElementTree.toXML(attributeQuery)         
    280290        xmlOutput = prettyPrint(elem) 
    281291            
     
    293303                        "https://openid.localhost/philip.kershaw") 
    294304         
    295         elem = AttributeQueryElementTree.create(attributeQuery)         
     305        elem = AttributeQueryElementTree.toXML(attributeQuery)         
    296306        xmlOutput = prettyPrint(elem)        
    297307        print("\n"+"_"*80) 
     
    305315        elem2 = tree.getroot() 
    306316         
    307         attributeQuery2 = AttributeQueryElementTree.parse(elem2) 
     317        attributeQuery2 = AttributeQueryElementTree.fromXML(elem2) 
    308318        self.assert_(attributeQuery2.id == attributeQuery.id) 
    309319        self.assert_(attributeQuery2.issuer.value==attributeQuery.issuer.value) 
     
    360370        # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    361371        # Attribute Value factory to render the XML output 
    362         attributeValueElementTreeClassMap = { 
     372        toXMLTypeMap = { 
    363373            XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    364374        } 
    365375         
    366376        # Create ElementTree Assertion Element 
    367         responseElem = ResponseElementTree.create(response, 
    368                             customClassMap=attributeValueElementTreeClassMap) 
     377        responseElem = ResponseElementTree.toXML(response, 
     378                                            customToXMLTypeMap=toXMLTypeMap) 
    369379         
    370380        self.assert_(iselement(responseElem)) 
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/__init__.py

    r5599 r5620  
    9090 
    9191 
    92 class XMLObjectError(Exception): 
     92class XMLTypeError(Exception): 
    9393    pass 
    9494 
    95 class XMLObjectParseError(Exception): 
     95class XMLTypeParseError(Exception): 
    9696    pass 
    9797         
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/etree.py

    r5601 r5620  
    3939 
    4040from saml.saml2.core import SAMLObject, Attribute, AttributeStatement, \ 
     41    AuthnStatement, AuthzDecisionStatement, \ 
    4142    Assertion, Conditions, AttributeValue, AttributeQuery, Subject, NameID, \ 
    42     Issuer, SAMLVersion, Response, Status, StatusCode , Advice, \ 
     43    Issuer, SAMLVersion, Response, Status, StatusCode, Advice, \ 
    4344    XSStringAttributeValue, XSGroupRoleAttributeValue 
    4445from saml.common.xml import SAMLConstants 
    45 from saml.xml import XMLObjectParseError 
     46from saml.xml import XMLTypeParseError 
    4647from saml.utils import SAMLDateTime 
    4748from saml.xml import QName as GenericQName 
     
    5960                                             str)()) 
    6061                                              
    61     getLocalPart = staticmethod(lambda tag: tag.rsplit('}',1)[-1]) 
     62    getLocalPart = staticmethod(lambda tag: tag.rsplit('}', 1)[-1]) 
    6263 
    6364    def __init__(self, input, tag=None, prefix=None): 
     
    7980            self.localPart = tag 
    8081        else: 
    81             # No tag provided namespace and locatPart of QN must be parsed from 
     82            # No tag provided namespace and localPart of QN must be parsed from 
    8283            # the namespace 
    8384            self.namespaceURI = QName.getNs(input) 
     
    216217     
    217218    @classmethod 
    218     def create(cls, conditions): 
    219         """Make a tree of a XML elements based on the assertion conditions""" 
    220          
     219    def toXML(cls, conditions): 
     220        """Make a tree of a XML elements based on the assertion conditions 
     221         
     222        @type assertion: saml.saml2.core.Conditions 
     223        @param assertion: Assertion conditions to be represented as an  
     224        ElementTree Element 
     225        @rtype: ElementTree.Element 
     226        @return: ElementTree Element 
     227        """ 
    221228        if not isinstance(conditions, Conditions): 
    222229            raise TypeError("Expecting %r type got: %r" % (Conditions, 
     
    241248                 
    242249        return elem 
     250     
     251    @classmethod 
     252    def fromXML(cls, elem): 
     253        """Parse an ElementTree SAML Conditions element into an 
     254        Conditions object 
     255         
     256        @type elem: ElementTree.Element 
     257        @param elem: ElementTree element containing the conditions 
     258        @rtype: saml.saml2.core.Conditions 
     259        @return: Conditions object""" 
     260         
     261        if not ElementTree.iselement(elem): 
     262            raise TypeError("Expecting %r input type for parsing; got %r" % 
     263                            (ElementTree.Element, elem)) 
     264 
     265        localName = QName.getLocalPart(elem.tag) 
     266        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     267            raise XMLTypeParseError("No \"%s\" element found" % 
     268                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     269         
     270         
     271        if len(elem) > 0: 
     272            raise NotImplementedError("Conditions list parsing is not " 
     273                                      "implemented") 
     274 
     275        conditions = Conditions() 
     276        notBefore = elem.attrib.get(Conditions.NOT_BEFORE_ATTRIB_NAME) 
     277        if notBefore is not None: 
     278            conditions.notBefore = SAMLDateTime.fromString(notBefore) 
     279             
     280        notOnOrAfter = elem.attrib.get(Conditions.NOT_ON_OR_AFTER_ATTRIB_NAME) 
     281        if notBefore is not None: 
     282            conditions.notOnOrAfter = SAMLDateTime.fromString(notOnOrAfter) 
     283             
     284        return conditions                 
     285         
    243286                
    244287class AssertionElementTree(Assertion): 
     
    247290     
    248291    @classmethod 
    249     def create(cls,  
    250                assertion,  
    251                **attributeValueElementTreeFactoryKw): 
    252         """Make a tree of a XML elements based on the assertion""" 
     292    def toXML(cls, assertion, **attributeValueElementTreeFactoryKw): 
     293        """Make a tree of a XML elements based on the assertion 
     294         
     295        @type assertion: saml.saml2.core.Assertion 
     296        @param assertion: Assertion to be represented as an ElementTree Element 
     297        @type attributeValueElementTreeFactoryKw: dict 
     298        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     299        factory 
     300        @rtype: ElementTree.Element 
     301        @return: ElementTree Element 
     302        """ 
    253303         
    254304        if not isinstance(assertion, Assertion): 
     
    270320         
    271321        if assertion.issuer is not None: 
    272             issuerElem = IssuerElementTree.create(assertion.issuer) 
     322            issuerElem = IssuerElementTree.toXML(assertion.issuer) 
    273323            elem.append(issuerElem) 
    274324         
    275325        if assertion.subject is not None: 
    276             subjectElem = SubjectElementTree.create(assertion.subject) 
     326            subjectElem = SubjectElementTree.toXML(assertion.subject) 
    277327            elem.append(subjectElem) 
    278328 
     
    282332 
    283333        if assertion.conditions is not None: 
    284             conditionsElem = ConditionsElementTree.create(assertion.conditions) 
     334            conditionsElem = ConditionsElementTree.toXML(assertion.conditions) 
    285335            elem.append(conditionsElem) 
    286336             
     
    298348             
    299349        for attributeStatement in assertion.attributeStatements: 
    300             attributeStatementElem = AttributeStatementElementTree.create( 
     350            attributeStatementElem = AttributeStatementElementTree.toXML( 
    301351                                        attributeStatement, 
    302352                                        **attributeValueElementTreeFactoryKw) 
     
    305355        return elem 
    306356 
    307      
    308     @classmethod 
    309     def parse(cls, elem): 
    310         """Make a tree of a XML elements based on the assertion""" 
     357    @classmethod 
     358    def fromXML(cls, elem, **attributeValueElementTreeFactoryKw): 
     359        """Parse an ElementTree representation of an Assertion into an 
     360        Assertion object 
     361         
     362        @type elem: ElementTree.Element 
     363        @param elem: ElementTree element containing the assertion 
     364        @rtype: saml.saml2.core.Assertion 
     365        @return: Assertion object""" 
    311366        if not ElementTree.iselement(elem): 
    312367            raise TypeError("Expecting %r input type for parsing; got %r" % 
     
    315370        localName = QName.getLocalPart(elem.tag) 
    316371        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    317             raise XMLObjectParseError("No \"%s\" element found" % 
     372            raise XMLTypeParseError("No \"%s\" element found" % 
    318373                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    319374         
     
    326381            attributeValue = elem.attrib.get(attributeName) 
    327382            if attributeValue is None: 
    328                 raise XMLObjectParseError('No "%s" attribute found in "%s" ' 
    329                                  'element' % 
    330                                  (attributeName, 
    331                                   cls.DEFAULT_ELEMENT_LOCAL_NAME)) 
     383                raise XMLTypeParseError('No "%s" attribute found in "%s" ' 
     384                                          'element' % 
     385                                          (attributeName, 
     386                                           cls.DEFAULT_ELEMENT_LOCAL_NAME)) 
    332387                 
    333388            attributeValues.append(attributeValue) 
    334389         
    335         attributeQuery = AttributeQuery() 
    336         attributeQuery.version = SAMLVersion(attributeValues[0]) 
    337         if attributeQuery.version != SAMLVersion.VERSION_20: 
     390        assertion = Assertion() 
     391        assertion.version = SAMLVersion(attributeValues[0]) 
     392        if assertion.version != SAMLVersion.VERSION_20: 
    338393            raise NotImplementedError("Parsing for %r is implemented for " 
    339394                                      "SAML version %s only; version %s is "  
     
    341396                                      (cls, 
    342397                                       SAMLVersion(SAMLVersion.VERSION_20), 
    343                                        SAMLVersion(attributeQuery.version))) 
    344              
    345         attributeQuery.issueInstant = SAMLDateTime.fromString( 
    346                                                             attributeValues[1]) 
    347         attributeQuery.id = attributeValues[2] 
     398                                       SAMLVersion(assertion.version))) 
     399             
     400        assertion.issueInstant = SAMLDateTime.fromString(attributeValues[1]) 
     401        assertion.id = attributeValues[2] 
    348402         
    349403        for childElem in elem: 
     
    351405            if localName == Issuer.DEFAULT_ELEMENT_LOCAL_NAME: 
    352406                # Parse Issuer 
    353                 assertion.issuer = IssuerElementTree.parse(childElem) 
     407                assertion.issuer = IssuerElementTree.fromXML(childElem) 
    354408                 
    355409            elif localName == Subject.DEFAULT_ELEMENT_LOCAL_NAME: 
    356                 # Parse Issuer 
    357                 assertion.subject = SubjectElementTree.parse(childElem) 
     410                # Parse subject 
     411                assertion.subject = SubjectElementTree.fromXML(childElem) 
    358412                 
    359413            elif localName == Advice.DEFAULT_ELEMENT_LOCAL_NAME: 
    360                 raise NotImplementedError("Assertion Advice creation is not " 
     414                raise NotImplementedError("Assertion Advice parsing is not " 
    361415                                          "implemented") 
    362             elif localName == "Conditions": 
    363              
    364             statement in assertion.statements: 
    365             raise NotImplementedError("Assertion Statement creation is not " 
    366                                       "implemented") 
    367          
    368         for authnStatement in assertion.authnStatements: 
    369             raise NotImplementedError("Assertion Authentication Statement " 
    370                                       "creation is not implemented") 
    371          
    372         for authzDecisionStatement in assertion.authzDecisionStatements: 
    373             raise NotImplementedError("Assertion Authorisation Decision " 
    374                                       "Statement creation is not implemented") 
    375              
    376         for attributeStatement in assertion.attributeStatements: 
    377             attributeStatementElem = AttributeStatementElementTree.create( 
    378                                         attributeStatement, 
     416                 
     417            elif localName == Conditions.DEFAULT_ELEMENT_LOCAL_NAME: 
     418                assertion.conditions = ConditionsElementTree.fromXML(childElem) 
     419         
     420            elif localName == AuthnStatement.DEFAULT_ELEMENT_LOCAL_NAME: 
     421                raise NotImplementedError("Assertion Authentication Statement " 
     422                                          "parsing is not implemented") 
     423         
     424            elif localName==AuthzDecisionStatement.DEFAULT_ELEMENT_LOCAL_NAME: 
     425                raise NotImplementedError("Assertion Authorisation Decision " 
     426                                          "Statement parsing is not " 
     427                                          "implemented") 
     428             
     429            elif localName == AttributeStatement.DEFAULT_ELEMENT_LOCAL_NAME: 
     430                attributeStatement = AttributeStatementElementTree.fromXML( 
     431                                        childElem, 
    379432                                        **attributeValueElementTreeFactoryKw) 
    380             elem.append(attributeStatementElem) 
     433                assertion.attributeStatements.append(attributeStatement) 
     434            else: 
     435                raise XMLTypeParseError('Assertion child element name "%s" ' 
     436                                          'not recognised' % localName) 
    381437         
    382438        return assertion 
     
    387443     
    388444    @classmethod 
    389     def create(cls,  
    390                attributeStatement,  
    391                **attributeValueElementTreeFactoryKw): 
     445    def toXML(cls, attributeStatement, **attributeValueElementTreeFactoryKw): 
     446        """Make a tree of a XML elements based on the attribute statement 
     447         
     448        @type assertion: saml.saml2.core.AttributeStatement 
     449        @param assertion: Attribute Statement to be represented as an  
     450        ElementTree Element 
     451        @type attributeValueElementTreeFactoryKw: dict 
     452        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     453        factory 
     454        @rtype: ElementTree.Element 
     455        @return: ElementTree Element 
     456        """ 
    392457        if not isinstance(attributeStatement, AttributeStatement): 
    393458            raise TypeError("Expecting %r type got: %r" % (AttributeStatement,  
     
    401466        for attribute in attributeStatement.attributes: 
    402467            # Factory enables support for multiple attribute types 
    403             attributeElem = AttributeElementTree.create(attribute, 
     468            attributeElem = AttributeElementTree.toXML(attribute, 
    404469                                        **attributeValueElementTreeFactoryKw) 
    405470            elem.append(attributeElem) 
     
    407472        return elem 
    408473     
     474    @classmethod 
     475    def fromXML(cls, elem, **attributeValueElementTreeFactoryKw): 
     476        """Parse an ElementTree SAML AttributeStatement element into an 
     477        AttributeStatement object 
     478         
     479        @type elem: ElementTree.Element 
     480        @param elem: ElementTree element containing the AttributeStatement 
     481        @type attributeValueElementTreeFactoryKw: dict 
     482        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     483        factory 
     484        @rtype: saml.saml2.core.AttributeStatement 
     485        @return: Attribute Statement""" 
     486         
     487        if not ElementTree.iselement(elem): 
     488            raise TypeError("Expecting %r input type for parsing; got %r" % 
     489                            (ElementTree.Element, elem)) 
     490 
     491        localName = QName.getLocalPart(elem.tag) 
     492        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     493            raise XMLTypeParseError("No \"%s\" element found" % 
     494                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     495         
     496         
     497        attributeStatement = AttributeStatement() 
     498 
     499        for childElem in elem: 
     500            # Factory enables support for multiple attribute types 
     501            attribute = AttributeElementTree.fromXML(childElem, 
     502                                        **attributeValueElementTreeFactoryKw) 
     503            attributeStatement.attributes.append(attribute) 
     504         
     505        return attributeStatement 
     506 
    409507 
    410508class AttributeElementTree(Attribute): 
     
    413511 
    414512    @classmethod 
    415     def create(cls,  
    416                attribute,  
    417                **attributeValueElementTreeFactoryKw): 
    418         """Make 'Attribute' element""" 
    419          
     513    def toXML(cls, attribute, **attributeValueElementTreeFactoryKw): 
     514        """Make a tree of a XML elements based on the Attribute 
     515         
     516        @type assertion: saml.saml2.core.Attribute 
     517        @param assertion: Attribute to be represented as an ElementTree Element 
     518        @type attributeValueElementTreeFactoryKw: dict 
     519        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     520        factory 
     521        @rtype: ElementTree.Element 
     522        @return: ElementTree Element 
     523        """ 
    420524        if not isinstance(attribute, Attribute): 
    421525            raise TypeError("Expecting %r type got: %r"%(Attribute, attribute)) 
     
    441545            attributeValueElementTree = factory(attributeValue) 
    442546             
    443             attributeValueElem=attributeValueElementTree.create(attributeValue) 
     547            attributeValueElem=attributeValueElementTree.toXML(attributeValue) 
    444548            elem.append(attributeValueElem) 
    445549             
     
    447551  
    448552    @classmethod 
    449     def parse(cls, elem, **attributeValueElementTreeFactoryKw): 
     553    def fromXML(cls, elem, **attributeValueElementTreeFactoryKw): 
    450554        """Parse ElementTree element into a SAML Attribute object 
    451555         
    452556        @type elem: ElementTree.Element 
    453557        @param elem: Attribute as ElementTree XML element 
    454         @rtype: ndg.security.common.saml.Attribute 
     558        @type attributeValueElementTreeFactoryKw: dict 
     559        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     560        factory 
     561        @rtype: saml.saml2.core.Attribute 
    455562        @return: SAML Attribute 
    456563        """ 
     
    460567 
    461568        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    462             raise XMLObjectParseError("No \"%s\" element found" % 
     569            raise XMLTypeParseError("No \"%s\" element found" % 
    463570                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    464571             
     
    476583        if nameFormat is not None: 
    477584            attribute.nameFormat = nameFormat 
     585         
     586        # Factory to handle the different Attribute Value types 
     587        factory = AttributeValueElementTreeFactory( 
     588                                        **attributeValueElementTreeFactoryKw) 
    478589 
    479590        for childElem in elem: 
    480591            localName = QName.getLocalPart(childElem.tag) 
    481592            if localName != AttributeValue.DEFAULT_ELEMENT_LOCAL_NAME: 
    482                 raise XMLObjectParseError('Expecting "%s" element; found "%s"'% 
     593                raise XMLTypeParseError('Expecting "%s" element; found "%s"'% 
    483594                                    (AttributeValue.DEFAULT_ELEMENT_LOCAL_NAME, 
    484595                                     localName)) 
    485              
    486             # Find XML type attribute to key which AttributeValue sub type to  
    487             # instantiate 
    488             attributeValueTypeId = None 
    489             for attribName, attribVal in childElem.attrib.items(): 
    490                 qname = QName(attribName) 
    491                 if qname.localPart == "type": 
    492                     attributeValueTypeId = attribVal 
    493                     break 
    494                  
    495             if attributeValueTypeId is None: 
    496                 raise XMLObjectParseError("Unable to determine type for " 
    497                                           "AttributeValue") 
    498                  
    499             factory = AttributeValueElementTreeFactory( 
    500                                         **attributeValueElementTreeFactoryKw) 
    501      
    502             attributeValueElementTreeClass = factory(attributeValueTypeId) 
    503             attributeValue = attributeValueElementTreeClass.parse(childElem) 
     596                             
     597            attributeValueElementTreeClass = factory(childElem) 
     598            attributeValue = attributeValueElementTreeClass.fromXML(childElem) 
    504599            attribute.attributeValues.append(attributeValue) 
    505600         
     
    511606     
    512607    @classmethod 
    513     def create(cls, attributeValue): 
    514         """Make 'Attribute' XML element""" 
    515  
     608    def toXML(cls, attributeValue): 
     609        """Make a tree of a XML elements based on the Attribute value 
     610         
     611        @type assertion: saml.saml2.core.Assertion 
     612        @param assertion: Assertion to be represented as an ElementTree Element 
     613        @rtype: ElementTree.Element 
     614        @return: ElementTree Element 
     615        """ 
    516616        if not isinstance(attributeValue, AttributeValue): 
    517617            raise TypeError("Expecting %r type got: %r" % (AttributeValue,  
     
    531631     
    532632    @classmethod 
    533     def create(cls, attributeValue): 
    534         """Create an XML representation of the input SAML Attribute Value""" 
    535         elem = AttributeValueElementTreeBase.create(attributeValue) 
     633    def toXML(cls, attributeValue): 
     634        """Create an XML representation of the input SAML Attribute Value  
     635         
     636        @type assertion: saml.saml2.core.XSStringAttributeValue 
     637        @param assertion: xs:string to be represented as an ElementTree Element 
     638        @rtype: ElementTree.Element 
     639        @return: ElementTree Element 
     640        """ 
     641        elem = AttributeValueElementTreeBase.toXML(attributeValue) 
    536642         
    537643        if not isinstance(attributeValue, XSStringAttributeValue): 
     
    559665 
    560666    @classmethod 
    561     def parse(cls, elem): 
     667    def fromXML(cls, elem): 
    562668        """Parse ElementTree xs:string element into a SAML  
    563669        XSStringAttributeValue object 
     
    565671        @type elem: ElementTree.Element 
    566672        @param elem: Attribute value as ElementTree XML element 
    567         @rtype: ndg.security.common.saml.AttributeValue 
     673        @rtype: saml.saml2.core.AttributeValue 
    568674        @return: SAML Attribute value 
    569675        """ 
     
    574680        localName = QName.getLocalPart(elem.tag) 
    575681        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    576             raise XMLObjectParseError("No \"%s\" element found" % 
     682            raise XMLTypeParseError("No \"%s\" element found" % 
    577683                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    578684         
     
    584690        typeValueLocalName = typeValue.split(':')[-1] 
    585691        if typeValueLocalName != cls.TYPE_LOCAL_NAME: 
    586             raise XMLObjectParseError('Expecting "%s" type; got "%s"' % 
     692            raise XMLTypeParseError('Expecting "%s" type; got "%s"' % 
    587693                                      (cls.TYPE_LOCAL_NAME, 
    588694                                       typeValueLocalName)) 
     
    606712 
    607713    @classmethod 
    608     def create(cls, attributeValue): 
    609         """Create an XML representation of the input SAML Attribute Value""" 
    610         elem = AttributeValueElementTreeBase.create(attributeValue) 
     714    def toXML(cls, attributeValue): 
     715        """Create an XML representation of the input SAML ESG Group/Role type 
     716        Attribute Value 
     717         
     718        @type assertion: saml.saml2.core.XSGroupRoleAttributeValue 
     719        @param assertion: XSGroupRoleAttributeValue to be represented as an  
     720        ElementTree Element 
     721        @rtype: ElementTree.Element 
     722        @return: ElementTree Element 
     723        """ 
     724        elem = AttributeValueElementTreeBase.toXML(attributeValue) 
    611725         
    612726        if not isinstance(attributeValue, XSGroupRoleAttributeValue): 
     
    622736        return elem 
    623737 
     738    @classmethod 
     739    def fromXML(cls, elem): 
     740        """Parse ElementTree ESG Group/Role attribute element into a SAML  
     741        XSGroupRoleAttributeValue object 
     742         
     743        @type elem: ElementTree.Element 
     744        @param elem: Attribute value as ElementTree XML element 
     745        @rtype: saml.saml2.core.XSGroupRoleAttributeValue 
     746        @return: SAML ESG Group/Role Attribute value 
     747        """ 
     748        if not ElementTree.iselement(elem): 
     749            raise TypeError("Expecting %r input type for parsing; got %r" % 
     750                            (ElementTree.Element, elem)) 
     751 
     752        localName = QName.getLocalPart(elem.tag) 
     753        if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
     754            raise XMLTypeParseError("No \"%s\" element found" % 
     755                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
     756 
     757         
     758        # Update namespace map as an XSI type has been referenced.  This will 
     759        # ensure the correct prefix is applied if it is re-serialised. 
     760        ElementTree._namespace_map[SAMLConstants.XSI_NS 
     761                                   ] = SAMLConstants.XSI_PREFIX 
     762                                       
     763        attributeValue = XSGroupRoleAttributeValue() 
     764        if elem.text is not None: 
     765            attributeValue.value = elem.text.strip() 
     766 
     767        return attributeValue 
     768     
     769    @classmethod 
     770    def factoryMatchFunc(cls, elem): 
     771        """Match function used by AttributeValueElementTreeFactory to 
     772        determine whether the given attribute is XSGroupRole type 
     773        """ 
     774        if cls.GROUP_ATTRIB_NAME in elem.attrib and \ 
     775           cls.ROLE_ATTRIB_NAME in elem.attrib: 
     776            return cls 
     777 
     778        return None 
     779 
    624780 
    625781class AttributeValueElementTreeFactory(object): 
     
    627783    used to represent SAML Attribute value types 
    628784     
    629     @type classMap: dict 
    630     @cvar classMap: mapping between SAML AttributeValue class and its  
     785    @type toXMLTypeMap: dict 
     786    @cvar toXMLTypeMap: mapping between SAML AttributeValue class and its  
    631787    ElementTree handler class 
    632     @type idMap: dict 
    633     @cvar idMap: mapping between SAML AttributeValue string identifier and  
     788    @type toSAMLTypeMap: dict 
     789    @cvar toSAMLTypeMap: mapping between SAML AttributeValue string identifier and  
    634790    its ElementTree handler class 
    635791    """ 
    636     classMap = { 
     792    toXMLTypeMap = { 
    637793        XSStringAttributeValue: XSStringAttributeValueElementTree 
    638794    } 
    639      
    640     idMap = { 
    641         "xs:string": XSStringAttributeValueElementTree 
    642     } 
     795 
     796    def xsstringMatch(elem): 
     797        """Match function for xs:string type attribute. 
     798        @type elem: ElementTree.Element 
     799        @param elem: Attribute Value element to be checked 
     800        @rtype: XSStringAttributeValueElementTree/None 
     801        @return: Parsing class if this element is an xs:string Attribute Value, 
     802        None otherwise. 
     803        """ 
     804        # Iterate through the attributes searching for a type attribute set to 
     805        # xs:string 
     806        for attribName, attribVal in elem.attrib.items(): 
     807            qname = QName(attribName) 
     808            if qname.localPart == "type": 
     809                typeLocalName = attribVal.split(':')[-1] 
     810                 
     811                if typeLocalName == XSStringAttributeValue.TYPE_LOCAL_NAME: 
     812                    return XSStringAttributeValueElementTree 
     813                else: 
     814                    return None 
     815                 
     816        # No type attribute was found for this Attribute element 
     817        return None 
     818         
     819    toSAMLTypeMap = [xsstringMatch] 
     820    xsstringMatch = staticmethod(toSAMLTypeMap[0]) 
    643821    
    644     def __init__(self, customClassMap={}, customIdMap={}):  
     822    def __init__(self, customToXMLTypeMap={}, customToSAMLTypeMap=[]):  
    645823        """Set-up a SAML class to ElementTree mapping 
    646         @type customClassMap: dict 
    647         @param customClassMap: mapping for custom SAML AttributeValue classes 
    648         to their respective ElementTree based representations.  This appends 
    649         to self.__classMap 
    650         @type customIdMap: dict 
    651         @param customIdMap: string ID based mapping for custom SAML  
     824        @type customToXMLTypeMap: dict 
     825        @param customToXMLTypeMap: mapping for custom SAML AttributeValue  
     826        classes to their respective ElementTree based representations.  This  
     827        appends to self.__toXMLTypeMap 
     828        @type customToSAMLTypeMap: dict 
     829        @param customToSAMLTypeMap: string ID based mapping for custom SAML  
    652830        AttributeValue classes to their respective ElementTree based  
    653         representations.  As with customClassMap, this appends to 
    654         to the respective self.__idMap 
    655         """ 
    656         self.__classMap = AttributeValueElementTreeFactory.classMap 
    657         for samlClass, etreeClass in customClassMap.items():  
     831        representations.  As with customToXMLTypeMap, this appends to 
     832        to the respective self.__toSAMLTypeMap 
     833        """ 
     834        self.__toXMLTypeMap = AttributeValueElementTreeFactory.toXMLTypeMap 
     835        if not isinstance(customToXMLTypeMap, dict): 
     836            raise TypeError('Expecting dict type for "customToXMLTypeMap"') 
     837 
     838        for samlClass, etreeClass in customToXMLTypeMap.items():  
    658839            if not issubclass(samlClass, AttributeValue): 
    659840                raise TypeError("Input custom class must be derived from %r, " 
    660841                                "got %r instead" % (Attribute, samlClass)) 
    661842                 
    662             self.__classMap[samlClass] = etreeClass 
    663  
    664         self.__idMap = AttributeValueElementTreeFactory.idMap 
    665         for samlId, etreeClass in customIdMap.items():  
    666             if not isinstance(samlId, basestring): 
    667                 raise TypeError("Input custom SAML identifier must be a " 
    668                                 "string, got %r instead" % samlId) 
    669                  
    670             self.__idMap[samlId] = etreeClass 
    671              
     843            self.__toXMLTypeMap[samlClass] = etreeClass 
     844 
     845        if not isinstance(customToSAMLTypeMap, (list, tuple)): 
     846            raise TypeError('Expecting list or tuple type for ' 
     847                            '"customToSAMLTypeMap"') 
     848         
     849        self.__toSAMLTypeMap = AttributeValueElementTreeFactory.toSAMLTypeMap[:] 
     850        for func in customToSAMLTypeMap: 
     851            if not callable(func): 
     852                raise TypeError('"customToSAMLTypeMap" items must be callable') 
     853             
     854        self.__toSAMLTypeMap += customToSAMLTypeMap 
     855 
    672856    def __call__(self, input): 
    673857        """Create an ElementTree object based on the Attribute class type 
    674858        passed in 
    675859         
    676         @type input: ndg.security.common.saml.AttributeValue or basestring 
     860        @type input: saml.saml2.core.AttributeValue or basestring 
    677861        @param input: pass an AttributeValue derived type or a string.  If 
    678         an AttributeValue type, then self.__classMap is checked for a matching 
    679         AttributeValue class entry, if a string is passed, self.__idMap is 
     862        an AttributeValue type, then self.__toXMLTypeMap is checked for a matching 
     863        AttributeValue class entry, if a string is passed, self.__toSAMLTypeMap is 
    680864        checked for a matching string ID.  In both cases, if a match is  
    681865        found an ElementTree class is returned which can render or parse 
     
    683867        """ 
    684868        if isinstance(input, AttributeValue): 
    685             xmlObjectClass = self.__classMap.get(input.__class__) 
    686             if xmlObjectClass is None: 
    687                 raise TypeError("no matching XMLObject class representation " 
     869            XMLTypeClass = self.__toXMLTypeMap.get(input.__class__) 
     870            if XMLTypeClass is None: 
     871                raise TypeError("no matching XMLType class representation " 
    688872                                "for SAML class %r" % input.__class__) 
    689873                 
    690         elif isinstance(input, basestring): 
    691             xmlObjectClass = self.__idMap.get(input) 
    692             if xmlObjectClass is None: 
    693                 raise TypeError("no matching XMLObject class representation " 
    694                                 "for SAML AttributeValue type %s" % input) 
     874        elif ElementTree.iselement(input): 
     875            XMLTypeClasses = [] 
     876            for matchFunc in self.__toSAMLTypeMap: 
     877                cls = matchFunc(input) 
     878                if cls is None: 
     879                    continue 
     880                elif issubclass(cls, AttributeValue): 
     881                    XMLTypeClasses.append(cls) 
     882                else: 
     883                    raise TypeError("Expecting AttributeValue derived type " 
     884                                    "for XML class; got %r" % cls) 
     885             
     886            nXMLTypeClasses = len(XMLTypeClasses) 
     887            if nXMLTypeClasses == 0: 
     888                raise TypeError("no matching XMLType class representation " 
     889                                "for SAML AttributeValue type %r" % input) 
     890            elif nXMLTypeClasses > 1: 
     891                raise TypeError("Multiple XMLType classes %r matched for " 
     892                                "for SAML AttributeValue type %r" %  
     893                                (XMLTypeClasses, input))  
     894                    
     895            XMLTypeClass = XMLTypeClasses[0]             
    695896        else: 
    696897            raise TypeError("Expecting %r class got %r" % (AttributeValue,  
    697898                                                           type(input))) 
    698              
    699              
    700         return xmlObjectClass 
    701  
    702          
     899        return XMLTypeClass 
     900     
     901 
    703902class IssuerElementTree(Issuer): 
    704903    """Represent a SAML Issuer element in XML using ElementTree""" 
    705904     
    706905    @classmethod 
    707     def create(cls, issuer): 
     906    def toXML(cls, issuer): 
    708907        """Create an XML representation of the input SAML issuer object""" 
    709908        if not isinstance(issuer, Issuer): 
     
    723922 
    724923    @classmethod 
    725     def parse(cls, elem): 
    726         """Parse ElementTree element into a SAML Issuer instance""" 
     924    def fromXML(cls, elem): 
     925        """Parse ElementTree element into a SAML Issuer instance 
     926         
     927        @type elem: ElementTree.Element 
     928        @param elem: ElementTree element containing the assertion 
     929        @rtype: saml.saml2.core.Issuer 
     930        @return: Assertion object""" 
    727931        if not ElementTree.iselement(elem): 
    728932            raise TypeError("Expecting %r input type for parsing; got %r" % 
     
    730934 
    731935        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    732             raise XMLObjectParseError('No "%s" element found' % 
     936            raise XMLTypeParseError('No "%s" element found' % 
    733937                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    734938             
    735939        issuerFormat = elem.attrib.get(cls.FORMAT_ATTRIB_NAME) 
    736940        if issuerFormat is None: 
    737             raise XMLObjectParseError('No "%s" attribute found in "%s" ' 
     941            raise XMLTypeParseError('No "%s" attribute found in "%s" ' 
    738942                                      'element' % 
    739943                                      (issuerFormat, 
     
    750954     
    751955    @classmethod 
    752     def create(cls, nameID): 
     956    def toXML(cls, nameID): 
    753957        """Create an XML representation of the input SAML Name Identifier 
    754958        object 
    755         @type nameID: ndg.security.common.saml.Subject 
     959        @type nameID: saml.saml2.core.Subject 
    756960        @param nameID: SAML subject 
    757961        @rtype: ElementTree.Element 
     
    775979 
    776980    @classmethod 
    777     def parse(cls, elem): 
     981    def fromXML(cls, elem): 
    778982        """Parse ElementTree element into a SAML NameID object 
    779983         
    780984        @type elem: ElementTree.Element 
    781985        @param elem: Name ID as ElementTree XML element 
    782         @rtype: ndg.security.common.saml.NameID 
     986        @rtype: saml.saml2.core.NameID 
    783987        @return: SAML Name ID 
    784988        """ 
     
    788992 
    789993        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    790             raise XMLObjectParseError("No \"%s\" element found" % 
     994            raise XMLTypeParseError("No \"%s\" element found" % 
    791995                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    792996             
    793997        format = elem.attrib.get(cls.FORMAT_ATTRIB_NAME) 
    794998        if format is None: 
    795             raise XMLObjectParseError('No "%s" attribute found in "%s" ' 
     999            raise XMLTypeParseError('No "%s" attribute found in "%s" ' 
    7961000                                      'element' % 
    7971001                                      (format, 
     
    8081012     
    8091013    @classmethod 
    810     def create(cls, subject): 
     1014    def toXML(cls, subject): 
    8111015        """Create an XML representation of the input SAML subject object 
    812         @type subject: ndg.security.common.saml.Subject 
     1016        @type subject: saml.saml2.core.Subject 
    8131017        @param subject: SAML subject 
    8141018        @rtype: ElementTree.Element 
     
    8261030 
    8271031             
    828         nameIdElem = NameIdElementTree.create(subject.nameID) 
     1032        nameIdElem = NameIdElementTree.toXML(subject.nameID) 
    8291033        elem.append(nameIdElem) 
    8301034         
     
    8321036 
    8331037    @classmethod 
    834     def parse(cls, elem): 
     1038    def fromXML(cls, elem): 
    8351039        """Parse ElementTree element into a SAML Subject object 
    8361040         
    8371041        @type elem: ElementTree.Element 
    8381042        @param elem: subject as ElementTree XML element 
    839         @rtype: ndg.security.common.saml.Subject 
     1043        @rtype: saml.saml2.core.Subject 
    8401044        @return: SAML subject 
    8411045        """ 
     
    8451049 
    8461050        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    847             raise XMLObjectParseError("No \"%s\" element found" % 
     1051            raise XMLTypeParseError("No \"%s\" element found" % 
    8481052                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    8491053             
    8501054        if len(elem) != 1: 
    851             raise XMLObjectParseError("Expecting single Name ID child element " 
     1055            raise XMLTypeParseError("Expecting single Name ID child element " 
    8521056                                      "for SAML Subject element") 
    8531057             
    8541058        subject = Subject() 
    855         subject.nameID = NameIdElementTree.parse(elem[0]) 
     1059        subject.nameID = NameIdElementTree.fromXML(elem[0]) 
    8561060         
    8571061        return subject 
     
    8621066     
    8631067    @classmethod 
    864     def create(cls, statusCode): 
     1068    def toXML(cls, statusCode): 
    8651069        """Create an XML representation of the input SAML Name Status Code 
    8661070         
    867         @type statusCode: ndg.security.common.saml.StatusCode 
     1071        @type statusCode: saml.saml2.core.StatusCode 
    8681072        @param statusCode: SAML Status Code 
    8691073        @rtype: ElementTree.Element 
     
    8851089 
    8861090    @classmethod 
    887     def parse(cls, elem): 
     1091    def fromXML(cls, elem): 
    8881092        """Parse ElementTree element into a SAML StatusCode object 
    8891093         
    8901094        @type elem: ElementTree.Element 
    8911095        @param elem: Status Code as ElementTree XML element 
    892         @rtype: ndg.security.common.saml.StatusCode 
     1096        @rtype: saml.saml2.core.StatusCode 
    8931097        @return: SAML Status Code 
    8941098        """ 
     
    8981102 
    8991103        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    900             raise XMLObjectParseError('No "%s" element found' % 
     1104            raise XMLTypeParseError('No "%s" element found' % 
    9011105                                      cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    9021106             
     
    9121116     
    9131117    @classmethod 
    914     def create(cls, status): 
     1118    def toXML(cls, status): 
    9151119        """Create an XML representation of the input SAML subject object 
    916         @type subject: ndg.security.common.saml.Status 
     1120        @type subject: saml.saml2.core.Status 
    9171121        @param subject: SAML subject 
    9181122        @rtype: ElementTree.Element 
     
    9291133                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix 
    9301134         
    931         statusCodeElem = StatusCodeElementTree.create(status.statusCode) 
     1135        statusCodeElem = StatusCodeElementTree.toXML(status.statusCode) 
    9321136        elem.append(statusCodeElem) 
    9331137         
     
    9351139 
    9361140    @classmethod 
    937     def parse(cls, elem): 
     1141    def fromXML(cls, elem): 
    9381142        """Parse ElementTree element into a SAML Status object 
    9391143         
    9401144        @type elem: ElementTree.Element 
    9411145        @param elem: subject as ElementTree XML element 
    942         @rtype: ndg.security.common.saml.Status 
     1146        @rtype: saml.saml2.core.Status 
    9431147        @return: SAML subject 
    9441148        """ 
     
    9481152 
    9491153        if QName.getLocalPart(elem.tag) != Status.DEFAULT_ELEMENT_LOCAL_NAME: 
    950             raise XMLObjectParseError('No "%s" element found' % 
     1154            raise XMLTypeParseError('No "%s" element found' % 
    9511155                                      Status.DEFAULT_ELEMENT_LOCAL_NAME) 
    9521156             
    9531157        if len(elem) != 1: 
    954             raise XMLObjectParseError("Expecting single StatusCode child " 
     1158            raise XMLTypeParseError("Expecting single StatusCode child " 
    9551159                                      "element for SAML Status element") 
    9561160             
    9571161        status = Status() 
    958         status.statusCode = StatusCodeElementTree.parse(elem[0]) 
     1162        status.statusCode = StatusCodeElementTree.fromXML(elem[0]) 
    9591163         
    9601164        return status 
     
    9651169         
    9661170    @classmethod 
    967     def create(cls,  
    968                attributeQuery,  
    969                **attributeValueElementTreeFactoryKw): 
     1171    def toXML(cls, attributeQuery, **attributeValueElementTreeFactoryKw): 
    9701172        """Create an XML representation of the input SAML Attribute Query 
    9711173        object 
    9721174 
    973         @type attributeQuery: ndg.security.common.saml.AttributeQuery 
     1175        @type attributeQuery: saml.saml2.core.AttributeQuery 
    9741176        @param attributeQuery: SAML Attribute Query 
     1177        @type attributeValueElementTreeFactoryKw: dict 
     1178        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     1179        factory 
    9751180        @rtype: ElementTree.Element 
    9761181        @return: Attribute Query as ElementTree XML element 
     
    9961201                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix 
    9971202         
    998         issuerElem = IssuerElementTree.create(attributeQuery.issuer) 
     1203        issuerElem = IssuerElementTree.toXML(attributeQuery.issuer) 
    9991204        elem.append(issuerElem) 
    10001205 
    1001         subjectElem = SubjectElementTree.create(attributeQuery.subject) 
     1206        subjectElem = SubjectElementTree.toXML(attributeQuery.subject) 
    10021207        elem.append(subjectElem) 
    10031208 
    10041209        for attribute in attributeQuery.attributes: 
    10051210            # Factory enables support for multiple attribute types 
    1006             attributeElem = AttributeElementTree.create(attribute, 
     1211            attributeElem = AttributeElementTree.toXML(attribute, 
    10071212                                        **attributeValueElementTreeFactoryKw) 
    10081213            elem.append(attributeElem) 
     
    10111216 
    10121217    @classmethod 
    1013     def parse(cls, elem): 
     1218    def fromXML(cls, elem): 
    10141219        """Parse ElementTree element into a SAML AttributeQuery object 
    10151220         
    10161221        @type elem: ElementTree.Element 
    10171222        @param elem: XML element containing the AttributeQuery 
    1018         @rtype: ndg.security.common.saml.AttributeQuery 
     1223        @rtype: saml.saml2.core.AttributeQuery 
    10191224        @return: AttributeQuery object 
    10201225        """ 
     
    10241229 
    10251230        if QName.getLocalPart(elem.tag) != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    1026             raise XMLObjectParseError("No \"%s\" element found" % 
     1231            raise XMLTypeParseError("No \"%s\" element found" % 
    10271232                                    cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    10281233         
     
    10341239            attributeValue = elem.attrib.get(attributeName) 
    10351240            if attributeValue is None: 
    1036                 raise XMLObjectParseError('No "%s" attribute found in "%s" ' 
     1241                raise XMLTypeParseError('No "%s" attribute found in "%s" ' 
    10371242                                 'element' % 
    10381243                                 (attributeName, 
     
    10591264            if localName == Issuer.DEFAULT_ELEMENT_LOCAL_NAME: 
    10601265                # Parse Issuer 
    1061                 attributeQuery.issuer = IssuerElementTree.parse(childElem) 
     1266                attributeQuery.issuer = IssuerElementTree.fromXML(childElem) 
    10621267                 
    10631268            elif localName == Subject.DEFAULT_ELEMENT_LOCAL_NAME: 
    10641269                # Parse Subject 
    1065                 attributeQuery.subject = SubjectElementTree.parse(childElem) 
     1270                attributeQuery.subject = SubjectElementTree.fromXML(childElem) 
    10661271             
    10671272            elif localName == Attribute.DEFAULT_ELEMENT_LOCAL_NAME: 
    1068                 attribute = AttributeElementTree.parse(childElem) 
     1273                attribute = AttributeElementTree.fromXML(childElem) 
    10691274                attributeQuery.attributes.append(attribute) 
    10701275            else: 
    1071                 raise XMLObjectParseError("Unrecognised AttributeQuery child " 
     1276                raise XMLTypeParseError("Unrecognised AttributeQuery child " 
    10721277                                          "element \"%s\"" % localName) 
    10731278         
     
    10791284         
    10801285    @classmethod 
    1081     def create(cls,  
    1082                response,  
    1083                **attributeValueElementTreeFactoryKw): 
     1286    def toXML(cls, response, **attributeValueElementTreeFactoryKw): 
    10841287        """Create an XML representation of the input SAML Response 
    10851288        object 
    10861289 
    1087         @type response: ndg.security.common.saml.Response 
     1290        @type response: saml.saml2.core.Response 
    10881291        @param response: SAML Response 
     1292        @type attributeValueElementTreeFactoryKw: dict 
     1293        @param attributeValueElementTreeFactoryKw: keywords for AttributeValue 
     1294        factory 
    10891295        @rtype: ElementTree.Element 
    10901296        @return: Response as ElementTree XML element 
     
    10941300                                                            type(response))) 
    10951301             
    1096          
    10971302        issueInstant = SAMLDateTime.toString(response.issueInstant) 
    10981303        attrib = { 
     
    11111316                                   ] = cls.DEFAULT_ELEMENT_NAME.prefix 
    11121317             
    1113         issuerElem = IssuerElementTree.create(response.issuer) 
     1318        issuerElem = IssuerElementTree.toXML(response.issuer) 
    11141319        elem.append(issuerElem) 
    11151320 
    1116         statusElem = StatusElementTree.create(response.status)        
     1321        statusElem = StatusElementTree.toXML(response.status)        
    11171322        elem.append(statusElem) 
    11181323 
    11191324        for assertion in response.assertions: 
    11201325            # Factory enables support for multiple attribute types 
    1121             assertionElem = AssertionElementTree.create(assertion, 
     1326            assertionElem = AssertionElementTree.toXML(assertion, 
    11221327                                        **attributeValueElementTreeFactoryKw) 
    11231328            elem.append(assertionElem) 
     
    11261331 
    11271332    @classmethod 
    1128     def parse(cls, elem): 
     1333    def fromXML(cls, elem): 
    11291334        """Parse ElementTree element into a SAML Response object 
    11301335         
    11311336        @type elem: ElementTree.Element 
    11321337        @param elem: XML element containing the Response 
    1133         @rtype: ndg.security.common.saml.Response 
     1338        @rtype: saml.saml2.core.Response 
    11341339        @return: Response object 
    11351340        """ 
     
    11391344 
    11401345        if QName.getLocalPart(elem.tag) != Response.DEFAULT_ELEMENT_LOCAL_NAME: 
    1141             raise XMLObjectParseError("No \"%s\" element found" % 
     1346            raise XMLTypeParseError("No \"%s\" element found" % 
    11421347                                      Response.DEFAULT_ELEMENT_LOCAL_NAME) 
    11431348         
     
    11501355            attributeValue = elem.attrib.get(attributeName) 
    11511356            if attributeValue is None: 
    1152                 raise XMLObjectParseError('No "%s" attribute found in "%s" ' 
     1357                raise XMLTypeParseError('No "%s" attribute found in "%s" ' 
    11531358                                          'element' % 
    11541359                                         (attributeName, 
     
    11751380            if localName == Issuer.DEFAULT_ELEMENT_LOCAL_NAME: 
    11761381                # Parse Issuer 
    1177                 response.issuer = IssuerElementTree.parse(childElem) 
     1382                response.issuer = IssuerElementTree.fromXML(childElem) 
    11781383             
    11791384            elif localName == Status.DEFAULT_ELEMENT_LOCAL_NAME: 
    11801385                # Get status of response 
    1181                 response.status = StatusElementTree.parse(childElem) 
     1386                response.status = StatusElementTree.fromXML(childElem) 
    11821387                 
    11831388            elif localName == Subject.DEFAULT_ELEMENT_LOCAL_NAME: 
    11841389                # Parse Subject 
    1185                 response.subject = SubjectElementTree.parse(childElem) 
     1390                response.subject = SubjectElementTree.fromXML(childElem) 
    11861391             
    11871392            elif localName == Assertion.DEFAULT_ELEMENT_LOCAL_NAME: 
    11881393                response.assertions.append( 
    1189                                         AssertionElementTree.parse(childElem)) 
     1394                                    AssertionElementTree.fromXML(childElem)) 
    11901395            else: 
    1191                 raise XMLObjectParseError('Unrecognised Response child ' 
     1396                raise XMLTypeParseError('Unrecognised Response child ' 
    11921397                                          'element "%s"' % localName) 
    11931398         
Note: See TracChangeset for help on using the changeset viewer.