)JfE dZddlmZmZddlmZddlZejeZ e n#e $re e fZ YnwxYwgdZ dddd d d d d dd Z dZdZdZeZ eedn9#e$r1Ze deddde eYdZ[ndZ[wwxYwdZGddeZdZGddeZGddeZdS)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) fullnamenicknamedobemailgenderpostcodecountrylanguagetimezonec<|tvrt|ddS)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 Y/home/alex/cs2snipeproduction/venv/lib/python3.11/site-packages/openid/extensions/sreg.pycheckFieldNamerKs5$$$**()) )%$zhttp://openid.net/sreg/1.0z%http://openid.net/extensions/sreg/1.1sregzregisterNamespaceAlias(z, z ) failed: cj|tp|tS)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 js0  " ": . . /  " ": . .0rceZdZdZdS)SRegNamespaceErroraThe 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____doc__rrr%r%xs    rr%cttfD] }|j|}|nK!t} |jtdn!#t $r}t |d}~wwxYw|S)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 getSRegNSr4s*#J/ * * "++K88   E  !  *   ' ' F ; ; ; ; * * *%S)) ) * s A A7#A22A7ceZdZdZdZdddefdZeeZ dZ e e Z ddZ dZ d Zd Zdd Zdd Zd ZdS)ra4An 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 Nctj|g|_g|_||_||_|r||dd|r||dddSdS)z/Initialize an empty simple registration requestT)requiredstrictFN)r__init__r7optional policy_urlr requestFields)selfr7r:r;r1s rr9zSRegRequest.__init__s 4     $!  E   x$t  D D D  F   x%  E E E E E F Frc|}|j}|||_||j}|||S)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}} )r0copy _getSRegNSr getArgsparseExtensionArgs)clsrequestr=r0argss rfromOpenIDRequestzSRegRequest.fromOpenIDRequestscsuu/&&((oog.. t{++ %%% rFcdD]b}|dk}||}|rC|dD]-} ||||#t$r|rY*wxYwc|d|_dS)aAParse 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 r7r:r7,r;N)getsplit requestFieldrr;)r=rEr8 list_namer7itemsrs rrBzSRegRequest.parseExtensionArgss82 " "I!Z/HHHY''E ""'++c"2"2""J"))*hGGGG%"""!"!"""((<00sA A"!A"c |j|jzS)zA list of all of the simple registration fields that were requested, whether they were required or optional. @rtype: [str] rHr=s rallRequestedFieldszSRegRequest.allRequestedFieldss }t},,rcDt|S)zRHave any simple registration fields been requested? @rtype: bool )boolrQrPs rwereFieldsRequestedzSRegRequest.wereFieldsRequested$s D++--...rc&||jvp||jvS)zWas this field in the request?rHr=rs r __contains__zSRegRequest.__contains__+sdm+JzT]/JKrcBt||r"||jvs ||jvrtdn3||jvrdS||jvr|r|j|ndS|r|j|dS|j|dS)aeRequest 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)rr7r:rremoveappend)r=rr7r8s rrLzSRegRequest.requestField/s" z"""  T]**jDM.I.I !HIII/JT]**T]**M((4444F  - M  , , , , , M  , , , , ,rct|tr tdt|d|D]}||||dS)a$Add 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 ))r8N) isinstancestr TypeErrortyperL)r= field_namesr7r8rs rr<zSRegRequest.requestFieldsTs k3 ' ' H)26{2C2C2C2CGHH H& C CJ   j(6  B B B B C Crci}|jrd|j|d<|jrd|j|d<|jr |j|d<|S)a Get 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} rIr7r:r;)r7joinr:r;)r=rEs rgetExtensionArgszSRegRequest.getExtensionArgsksh = 7"xx 66D  = 7"xx 66D  ? 1!%D  r)F)FF)r&r'r(r)ns_aliasr r9 staticmethodr4r@rF classmethodrBrQrTrWrLr<rdr*rrrrs"H # FFFF(i((J.$ $566'1'1'1'1R---///LLL#-#-#-#-JCCCC.rrceZdZdZdZdefdZdZeeZe e Z ddZ ee Z dZ dd Zd Zd Zd Zd ZdZdZdZdZdZdS)raRepresents 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^tj||i|_n||_||_dSN)rr9datar )r=rkr1s rr9zSRegResponse.__init__s34   <DIIDI! rc|}|j|_|D]#}||}| ||j|<$|S)aTake 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 rQrJrk)rCrDrkr=fieldvalues rextractResponsezSRegResponse.extractResponsesZ$suun //11 ) )EHHUOOE #( %  rTc|}||j|_|r||j}n|j|j}|sdSt D]}||vr|||j|<|S)aCreate 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)r@r0r getSignedNSrArrk)rCsuccess_response signed_onlyr=rErs rfromSuccessResponsez SRegResponse.fromSuccessResponses"suuoo&6&>??  A#// <rs=##J%%%%%%%%&&&&&&  8 $ $CC *CCC         ) ) )* 5  6:v....&666 !zz66633q6665666666666 0 0 0        &&&RPPPPP)PPPfNNNNN9NNNNNs$) 55 AB$'BB