← Back
Editing: sreg.cpython-311.pyc
� QT�^�E � � � d Z ddlmZmZ ddlmZ ddlZ ej e� � Z e n# e $ r e e fZ Y nw xY wg d�Z dddd d d d d dd� Z d� ZdZdZeZ eed� � n9# e$ r1Ze � de�dd�d e e� � ��� � Y dZ[ndZ[ww xY wd� Z G d� de� � Zd� Z G d� d e� � Z G d � d e� � ZdS ) a� Simple 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<openid.consumer.consumer.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 � )�registerNamespaceAlias� NamespaceAliasRegistrationError)� ExtensionN)� SRegRequest� SRegResponse� data_fields�ns_uri� ns_uri_1_0� ns_uri_1_1� supportsSRegz Full Name�Nicknamez Date of BirthzE-mail Address�Genderz Postal Code�Country�Languagez Time Zone) �fullname�nickname�dob�email�gender�postcode�country�language�timezonec �< � | t vrt | �d�� � �dS )z�Check 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 �8/usr/lib/python3/dist-packages/openid/extensions/sreg.py�checkFieldNamer K s5 � � ��$�$��$�*�*�(� )� )� )� %�$� zhttp://openid.net/sreg/1.0z%http://openid.net/extensions/sreg/1.1�sregzregisterNamespaceAlias(z, z ) failed: c �j � | � t � � p| � t � � S )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 r r r j s0 � � � "� "�:� .� .� /� � "� "�:� .� .�0r c � � e Zd ZdZdS )�SRegNamespaceErrora The 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__� r r r% r% x s � � � � � � � � � r r% c � � t t fD ] }| j � |� � }|� nK�!t } | j � t d� � n!# t $ r}t |� � �d}~ww xY w|S )a� Extract 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 � namespaces�getAlias�addAlias�KeyErrorr% )�message� sreg_ns_uri�alias�whys r � getSRegNSr4 � s� � �* #�J�/� *� *� ��"�+�+�K�8�8�� � � �E� � !� � *� � � '� '� �F� ;� ;� ;� ;��� *� *� *� %�S�)�)� )����� *���� �s � A � A7�#A2�2A7c � � e Zd ZdZdZdddefd�Z ee� � Z d� Z e e � � Z dd�Z d� Z d � Zd � Zdd �Zdd �Zd � ZdS )r a4 An 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 �� � t j | � � g | _ g | _ || _ || _ |r| � |dd�� � |r| � |dd�� � dS dS )z/Initialize an empty simple registration requestT)�required�strictFN)r �__init__r7 �optional� policy_urlr � requestFields)�selfr7 r: r; r1 s r r9 zSRegRequest.__init__� s� � � ��4� � � ��� ��� �$���!�� � � E� � � �x�$�t� � D� D� D� � F� � � �x�%�� � E� E� E� E� E� F� Fr c �� � | � � }|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}} )r0 �copy� _getSRegNSr �getArgs�parseExtensionArgs)�cls�requestr= r0 �argss r �fromOpenIDRequestz SRegRequest.fromOpenIDRequest� sc � � �s�u�u�� �/�&�&�(�(���o�o�g�.�.�� ����t�{�+�+�� � � ��%�%�%�� r Fc � � dD ]b}|dk }|� |� � }|rC|� d� � D ]-} | � |||� � �# t $ r |r� Y �*w xY w�c|� d� � | _ dS )aA Parse 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 �r7 r: r7 �,r; N)�get�split� requestFieldr r; )r= rE r8 � list_namer7 �itemsr s r rB z SRegRequest.parseExtensionArgs� s� � �8 2� "� "�I�!�Z�/�H��H�H�Y�'�'�E�� "�"'�+�+�c�"2�"2� "� "�J�"� �)�)�*�h��G�G�G�G��%� "� "� "�!� "� !�"� "�"����� �(�(�<�0�0����s �A� A"�!A"c � � | j | j z S )z�A list of all of the simple registration fields that were requested, whether they were required or optional. @rtype: [str] rH �r= s r �allRequestedFieldsz SRegRequest.allRequestedFields s � � �}�t�}�,�,r c �D � t | � � � � � S )zRHave any simple registration fields been requested? @rtype: bool )�boolrQ rP s r �wereFieldsRequestedz SRegRequest.wereFieldsRequested$ s � � �D�+�+�-�-�.�.�.r c �& � || j v p|| j v S )z Was this field in the request?rH �r= r s r � __contains__zSRegRequest.__contains__+ s � ��d�m�+�J�z�T�]�/J�Kr c �B � t |� � |r"|| j v s || j v rt d� � �n3|| j v rdS || j v r |r| j � |� � ndS |r | j � |� � dS | j � |� � dS )ae 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)r r7 r: r �remove�append)r= r r7 r8 s r rL zSRegRequest.requestField/ s� � �" �z�"�"�"� � ��T�]�*�*�j�D�M�.I�.I� �!H�I�I�I� /J� �T�]�*�*����T�]�*�*�� ��M�(�(��4�4�4�4��F� � -� �M� � �� ,� ,� ,� ,� ,� �M� � �� ,� ,� ,� ,� ,r c � � t |t � � r t dt |� � �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 �))r8 N)� isinstance�str� TypeError�typerL )r= � field_namesr7 r8 r s r r< zSRegRequest.requestFieldsT s� � � �k�3� '� '� H��)�26�{�2C�2C�2C�2C� G� H� H� H� &� C� C�J� � � �j�(�6� � B� B� B� B� C� Cr c � � i }| j r d� | j � � |d< | j r d� | j � � |d< | j r | 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} rI r7 r: r; )r7 �joinr: r; )r= rE s r �getExtensionArgsz SRegRequest.getExtensionArgsk sh � � �� �=� 7� "�x�x�� � 6� 6�D�� � �=� 7� "�x�x�� � 6� 6�D�� � �?� 1�!%� �D� � �� r )F)FF)r& r' r( r) �ns_aliasr r9 � staticmethodr4 r@ rF � classmethodrB rQ rT rW rL r< rd r* r r r r � s� � � � � � �� �" �H� � � � #� F� F� F� F�( � �i�(�(�J�� � �. $� �$5�6�6��'1� '1� '1� '1�R-� -� -�/� /� /�L� L� L�#-� #-� #-� #-�JC� C� C� C�.� � � � r r c � � e Zd ZdZdZdefd�Zd� Z ee� � Z e e � � Z dd�Z ee � � Z d� Z dd �Zd � Zd � Zd � Zd � Zd� Zd� Zd� Zd� Zd� ZdS )r a� Represents 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 �^ � t j | � � |�i | _ n|| _ || _ d S �N)r r9 �datar )r= rk r1 s r r9 zSRegResponse.__init__� s3 � ���4� � � � �<��D�I�I� �D�I�!�� � � r c � � | � � }|j |_ |� � � D ]#}|� |� � }|� ||j |< �$|S )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 rQ rJ rk )rC rD rk r= �field�values r �extractResponsez SRegResponse.extractResponse� sZ � �$ �s�u�u�� �n�� � �/�/�1�1� )� )�E��H�H�U�O�O�E�� �#(�� �%� ��� r Tc � � | � � }|� |j � � |_ |r|� |j � � }n |j � |j � � }|sdS t D ]}||v r|| |j |< �|S )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)r@ r0 r � getSignedNSrA r rk )rC �success_response� signed_onlyr= rE r s r �fromSuccessResponsez SRegResponse.fromSuccessResponse� s� � �" �s�u�u���o�o�&6�&>�?�?�� � � A�#�/�/�� �<�<�D�D�#�+�3�3�D�K�@�@�D�� ��4�%� 9� 9�J��T�!�!�(,�Z�(8�� �*�%��� r c � � | j S )z�Get the fields to put in the simple registration namespace when adding them to an id_res message. @see: openid.extension )rk rP s r rd z SRegResponse.getExtensionArgs� s � � �y�r c �V � t |� � | j � ||� � S )ztLike dict.get, except that it checks that the field name is defined by the simple registration specification)r rk rJ )r= r �defaults r rJ zSRegResponse.get� s( � � �z�"�"�"��y�}�}�Z��1�1�1r c �N � t | j � � � � � S )zDAll of the data values in this simple registration response )�listrk rN rP s r rN zSRegResponse.items� s � � �D�I�O�O�%�%�&�&�&r c �N � t | j � � � � � S rj )�iterrk rN rP s r � iteritemszSRegResponse.iteritems� s � ��D�I�O�O�%�%�&�&�&r c �N � t | j � � � � � S rj )ry rk �keysrP s r r~ zSRegResponse.keys� � � ��D�I�N�N�$�$�%�%�%r c �N � t | j � � � � � S rj )r{ rk r~ rP s r �iterkeyszSRegResponse.iterkeys� r r c � � || v S rj r* )r= �keys r �has_keyzSRegResponse.has_key s � ��d�{�r c �2 � t |� � || j v S rj �r rk rV s r rW zSRegResponse.__contains__ s � ��z�"�"�"��T�Y�&�&r c �* � t | j � � S rj )r{ rk rP s r �__iter__zSRegResponse.__iter__ � � ��D�I��� r c �: � t |� � | j | S rj r� rV s r � __getitem__zSRegResponse.__getitem__ s � ��z�"�"�"��y��$�$r c �* � t | j � � S rj )rS rk rP s r �__bool__zSRegResponse.__bool__ r� r )Trj )r& r' r( r) re r r9 ro rg rf r4 r@ rt rd rJ rN r| r~ r� r� rW r� r� r� r* r r r r � sA � � � � � �� �& �H� �f� "� "� "� "�� � �4 "�k�/�2�2�O� � �i�(�(�J� � � � �B &�+�&9�:�:��� � �2� 2� 2� 2� '� '� '� '� '� '�&� &� &�&� &� &�� � �'� '� '� � � �%� %� %� � � � � r r )r) �openid.messager r �openid.extensionr �logging� getLoggerr& �loggerr^ � NameError�__all__r r r r r �e� exceptionr r r% r4 r r r* r r �<module>r� s= ��#� #�J%� %� %� %� %� %� %� %� &� &� &� &� &� &� ���� �� �8� $� $����C�C��� � � � ��*�C�C�C����� � � �� �� � �� ���� � � � )� )� )� *� � 5� � ��6���:�v�.�.�.�.��&� 6� 6� 6� ����!�z�z�6�6�6�3�3�q�6�6�6�5� 6� 6� 6� 6� 6� 6� 6� 6�����6���� 0� 0� 0� � � � � �� � � � &� &� &�RP� P� P� P� P�)� P� P� P�fN � N � N � N � N �9� N � N � N � N � N s$ �) � 5�5� A � B�$'B�B
Save File
Cancel