qhE vSrSSKJrJr SSKJr SSKr\R"\5r \ /SQr SSSS S S S S SS. r SrSrSr\r\"\S5 Sr"SS\5rSr"SS\5r"SS\5rg!\ a \ \ 4r NWf=f!\a-r\ R'S\<SS<S\ "\5<35 SrCNfSrCff=f)aSimple registration request and response parsing and object representation This module contains objects representing simple registration requests and responses that can be used with both OpenID relying parties and OpenID providers. 1. The relying party creates a request object and adds it to the C{L{AuthRequest}} object before making the C{checkid_} request to the OpenID provider:: auth_request.addExtension(SRegRequest(required=['email'])) 2. The OpenID provider extracts the simple registration request from the OpenID request using C{L{SRegRequest.fromOpenIDRequest}}, gets the user's approval and data, creates a C{L{SRegResponse}} object and adds it to the C{id_res} response:: sreg_req = SRegRequest.fromOpenIDRequest(checkid_request) # [ get the user's approval and data, informing the user that # the fields in sreg_response were requested ] sreg_resp = SRegResponse.extractResponse(sreg_req, user_data) sreg_resp.toMessage(openid_response.fields) 3. The relying party uses C{L{SRegResponse.fromSuccessResponse}} to extract the data from the OpenID response:: sreg_resp = SRegResponse.fromSuccessResponse(success_response) @since: 2.0 @var sreg_data_fields: The names of the data fields that are listed in the sreg spec, and a description of them in English @var sreg_uri: The preferred URI to use for the simple registration namespace and XRD Type value )registerNamespaceAliasNamespaceAliasRegistrationError) ExtensionN) SRegRequest SRegResponse data_fieldsns_uri ns_uri_1_0 ns_uri_1_1 supportsSRegz Full NameNicknamez Date of BirthzE-mail AddressGenderz Postal CodeCountryLanguagez Time Zone) fullnamenicknamedobemailgenderpostcodecountrylanguagetimezonec6U[;a[U<S35eg)zCheck to see that the given value is a valid simple registration data field name. @raise ValueError: if the field name is not a valid simple registration data field name z+ is not a defined simple registration fieldN)r ValueError) field_names H/var/www/html/env/lib/python3.13/site-packages/openid/extensions/sreg.pycheckFieldNamerKs&$$() )%zhttp://openid.net/sreg/1.0z%http://openid.net/extensions/sreg/1.1sregzregisterNamespaceAlias(z, z ) failed: cdUR[5=(d UR[5$)a Does the given endpoint advertise support for simple registration? @param endpoint: The endpoint object as returned by OpenID discovery @type endpoint: openid.consumer.discover.OpenIDEndpoint @returns: Whether an sreg type was advertised by the endpoint @rtype: bool ) usesExtensionr r )endpoints rr r js*  " ": . /  " ": .0rc\rSrSrSrSrg)SRegNamespaceErrorxaThe simple registration namespace was not found and could not be created using the expected name (there's another extension using the name 'sreg') This is not I{illegal}, for OpenID 2, although it probably indicates a problem, since it's not expected that other extensions will re-use the alias that is in use for OpenID 1. If this is an OpenID 1 request, then there is no recourse. This should not happen unless some code has modified the namespaces for the message that is being processed. N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__r'rrr%r%xs rr%c[[4H$nURRU5nUcM# U$ [nURR [S5 U$![ an[ U5eSnAff=f)aExtract the simple registration namespace URI from the given OpenID message. Handles OpenID 1 and 2, as well as both sreg namespace URIs found in the wild, as well as missing namespace definitions (for OpenID 1) @param message: The OpenID message from which to parse simple registration fields. This may be a request or response message. @type message: C{L{openid.message.Message}} @returns: the sreg namespace URI for the supplied message. The message may be modified to define a simple registration namespace. @rtype: C{str} @raise ValueError: when using OpenID 1 if the message defines the 'sreg' alias to be something other than a simple registration type. Nr )r r namespacesgetAliasaddAliasKeyErrorr%)message sreg_ns_urialiaswhys r getSRegNSr7s*#J/ ""++K8    #0!  *    ' ' F ;  *%S) ) *s A A8( A33A8c\rSrSrSrSrSSS\4Sjr\"\ 5r Sr \ "\ 5r SSjr SrS rS rSS jrSS jrS rSrg)raAn object to hold the state of a simple registration request. @ivar required: A list of the required fields in this simple registration request @type required: [str] @ivar optional: A list of the optional fields in this simple registration request @type optional: [str] @ivar policy_url: The policy URL that was provided with the request @type policy_url: str or NoneType @group Consumer: requestField, requestFields, getExtensionArgs, addToOpenIDRequest @group Server: fromOpenIDRequest, parseExtensionArgs r Nc[R"U5 /Ul/UlX0lX@lU(aUR USSS9 U(aUR USSS9 gg)z/Initialize an empty simple registration requestT)requiredstrictFN)r__init__r;optional policy_urlr requestFields)selfr;r>r?r4s rr=SRegRequest.__init__s_ 4   $!    x$t  D    x%  E rcU"5nURR5nURU5UlUR UR5nUR U5 U$)a$Create a simple registration request that contains the fields that were requested in the OpenID request with the given arguments @param request: The OpenID request @type request: openid.server.CheckIDRequest @returns: The newly created simple registration request @rtype: C{L{SRegRequest}} )r3copy _getSRegNSr getArgsparseExtensionArgs)clsrequestrAr3argss rfromOpenIDRequestSRegRequest.fromOpenIDRequestsTu//&&(oog. t{{+ % rcSHMnUS:HnURU5nU(dM"URS5HnURXdU5 M MO URS5Ulg![a U(aeMJf=f)aParse the unqualified simple registration request parameters and add them to this object. This method is essentially the inverse of C{L{getExtensionArgs}}. This method restores the serialized simple registration request fields. If you are extracting arguments from a standard OpenID checkid_* request, you probably want to use C{L{fromOpenIDRequest}}, which will extract the sreg namespace and arguments from the OpenID request. This method is intended for cases where the OpenID server needs more control over how the arguments are parsed than that method provides. >>> args = message.getArgs(ns_uri) >>> request.parseExtensionArgs(args) @param args: The unqualified simple registration arguments @type args: {str:str} @param strict: Whether requests with fields that are not defined in the simple registration specification should be tolerated (and ignored) @type strict: bool @returns: None; updates this object r;r>r;,r?N)getsplit requestFieldrr?)rArJr< list_namer;itemsrs rrGSRegRequest.parseExtensionArgss82I!Z/HHHY'Eu"'++c"2J"))*G#3 2((<0 &"!!""sA++BBc4URUR-$)z|A list of all of the simple registration fields that were requested, whether they were required or optional. @rtype: [str] rNrAs rallRequestedFieldsSRegRequest.allRequestedFieldss }}t}},,rc4[UR55$)zBHave any simple registration fields been requested? @rtype: bool )boolrXrWs rwereFieldsRequestedSRegRequest.wereFieldsRequested$s D++-..rcHXR;=(d XR;$)zWas this field in the request?rNrArs r __contains__SRegRequest.__contains__+smm+Jz]]/JKrc~[U5 U(a*XR;dXR;a [S5eOCXR;agXR;a$U(aURR U5 OgU(aURR U5 gURR U5 g)a Request the specified field from the OpenID user @param field_name: the unqualified simple registration field name @type field_name: str @param required: whether the given field should be presented to the user as being a required to successfully complete the request @param strict: whether to raise an exception when a field is added to a request more than once @raise ValueError: when the field requested is not a simple registration field or strict is set and the field was requested more than once z%That field has already been requestedN)rr;r>rremoveappend)rArr;r<s rrRSRegRequest.requestField/s" z" ]]*jMM.I !HII/J]]*]]*MM((4  MM  , MM  ,rc[U[5(a[S[U5<S35eUHnUR XBUS9 M g)aAdd the given list of fields to the request @param field_names: The simple registration data fields to request @type field_names: [str] @param required: Whether these values should be presented to the user as required @param strict: whether to raise an exception when a field is added to a request more than once @raise ValueError: when a field requested is not a simple registration field or strict is set and a field was requested more than once z2Fields should be passed as a list of strings (not ))r<N) isinstancestr TypeErrortyperR)rA field_namesr;r<rs rr@SRegRequest.requestFieldsTsM k3 ' '26{2CGH H&J   j6  B&rc0nUR(aSRUR5US'UR(aSRUR5US'UR(aURUS'U$)zGet a dictionary of unqualified simple registration arguments representing this request. This method is essentially the inverse of C{L{parseExtensionArgs}}. This method serializes the simple registration request fields. @rtype: {str:str} rOr;r>r?)r;joinr>r?)rArJs rgetExtensionArgsSRegRequest.getExtensionArgsks_ =="xx 6D  =="xx 6D  ??!%D  r)r r>r?r;)F)FF)r(r)r*r+r,ns_aliasr r= staticmethodr7rErK classmethodrGrXr\r`rRr@rpr-r'rrrrsh"H # F(i(J.$$56'1R-/L#-JC.rrc\rSrSrSrSrS\4SjrSr\ "\5r\ "\ 5r SSjr \ "\ 5r SrSS jrS rS rS rS rSrSrSrSrSrSrg)riaRepresents the data returned in a simple registration response inside of an OpenID C{id_res} response. This object will be created by the OpenID server, added to the C{id_res} response object, and then extracted from the C{id_res} message by the Consumer. @ivar data: The simple registration data, keyed by the unqualified simple registration name of the field (i.e. nickname is keyed by C{'nickname'}) @ivar ns_uri: The URI under which the simple registration data was stored in the response message. @group Server: extractResponse @group Consumer: fromSuccessResponse @group Read-only dictionary interface: keys, iterkeys, items, iteritems, __iter__, get, __getitem__, keys, has_key r Nc^[R"U5 Uc0UlOXlX lgN)rr=datar )rArxr4s rr=SRegResponse.__init__s&4 <DII! rcU"5nURUlUR5H'nURU5nUcMXSRU'M) U$)a#Take a C{L{SRegRequest}} and a dictionary of simple registration values and create a C{L{SRegResponse}} object containing that data. @param request: The simple registration request object @type request: SRegRequest @param data: The simple registration data for this response, as a dictionary from unqualified simple registration field name to string (unicode) value. For instance, the nickname should be stored under the key 'nickname'. @type data: {str:str} @returns: a simple registration response object @rtype: SRegResponse )r rXrPrx)rHrIrxrAfieldvalues rextractResponseSRegResponse.extractResponsesO$unn //1EHHUOE #( % 2 rc>U"5nURUR5UlU(aURUR5nO%URR UR5nU(dg[ HnXT;dM XEUR U'M U$)a&Create a C{L{SRegResponse}} object from a successful OpenID library response (C{L{openid.consumer.consumer.SuccessResponse}}) response message @param success_response: A SuccessResponse from consumer.complete() @type success_response: C{L{openid.consumer.consumer.SuccessResponse}} @param signed_only: Whether to process only data that was signed in the id_res message from the server. @type signed_only: bool @rtype: SRegResponse @returns: A simple registration response containing the data that was supplied with the C{id_res} response. N)rEr3r getSignedNSrFrrx)rHsuccess_response signed_onlyrArJrs rfromSuccessResponse SRegResponse.fromSuccessResponses"uoo&6&>&>? #// rs#J%&   8 $       )* 5  6:v. 0  &RP)PfN9Ni  *Cl'6 !63q65666s)A5 B5 BBB8 #B33B8