| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/webob/__pycache__/ |
Upload File : |
�
�
.`"5 � �� � d Z ddlmZ ddlZddlZddlZdZdZedz Z ej dez dz � Z
d Z ed
z ez d z e z d z Z d
� Z
d� Zd� Zd� Z G d� d edg d�� � Z G d� de� Z G d� de� Z G d� de� Z G d� de� Z G d � d e� Z G d � d e� Zd � Zd!� Z G d"� d#e� Z G d$� d%e� Z G d&� d'e� Z G d(� d)e � Z G d*� d+e � Z d,� Z d-� Z! G d.� d/e� Z" G d0� d1e"� Z# G d2� d3e"� Z$ G d4� d5e$� Z% G d6� d7e$� Z&d8� Z'd9� Z( G d:� d;e� Z) G d<� d=e)� Z* G d>� d?e)� Z+ G d@� dAe+� Z, G dB� dCe+� Z-dD� Z.dE� Z/y)Fz�
Parse four ``Accept*`` headers used in server-driven content negotiation.
The four headers are ``Accept``, ``Accept-Charset``, ``Accept-Encoding`` and
``Accept-Language``.
� )�
namedtupleNz[ ]*z[!#$%&'*+\-.^_`|~0-9A-Za-z]�+�^�$z)(?:0(?:\.[0-9]{0,3})?)|(?:1(?:\.0{0,3})?)�;z[qQ]=(�)c �& � d| z dz t z dz S )N�(z)(?:�)?)� weight_re��item_res �3/usr/lib/python3/dist-packages/webob/acceptparse.py�_item_n_weight_rer ) s � � ��=�6� !�I� -�� 4�4� c �v � | \ }}|dk( r|}|S |dk( rdj |� }|S dj ||� }|S )N� �?� z{};q=0z{};q={})�format)�pair�item�qvalue�elements r �#_item_qvalue_pair_to_header_elementr - sU � ��L�D�&�
��}���
�N�
�3� ��/�/�$�'�� �N� �"�"�4��0�� �Nr c �r � t j d| z dz dz t z dz t z | z dz dz � S )Nz^(?:$)|(?:(?:,|(?:�))�(?:�,(?:z)?)*z)$��re�compile�OWS_re��
element_res r � _list_0_or_more__compiled_rer% 8 sp � � �:�:� � � �"&� '� � � � � � � #)� )� ,6� 6� 9?� ?�
�
� � r c �z � t j dt z dz | z dz t z dz t z | z dz � S )Nz^(?:,�)*r r z)?)*$r r# s r � _list_1_or_more__compiled_rer( D sX � � �:�:��&��4� �*�,�
� �� � � �"(� )�+5� 6�8?� @� � r c � � e Zd ZdZdZd� Zy)� AcceptOffera"
A pre-parsed offer tuple represeting a value in the format
``type/subtype;param0=value0;param1=value1``.
:ivar type: The media type's root category.
:ivar subtype: The media type's subtype.
:ivar params: A tuple of 2-tuples containing parameter names and values.
� c �z � | j dz | j z }t j || j � S )z@
Return the properly quoted media type string.
�/)�type�subtype�Accept�_form_media_range�params)�self�values r �__str__zAcceptOffer.__str__Z s1 � �
� � �C��$�,�,�.���'�'��t�{�{�;�;r N)�__name__�
__module__� __qualname__�__doc__� __slots__r5 r+ r r r* r* N s � �� �I�<r r* )r. r/ r2 c �B � e Zd ZdZdZdZdez dz Zdez ez dz Zdez dz ez d z Ze Z
e Z e d
z d z e z dz ez d z Z d
e
z dz e z dz dz dz dz e
z dz e
z dz e z dz dz Ze
dz e
z e z dz dz dz e z dz ez dz dz dz Zed
z ez dz Zedz ez dz Z ej( e� Z ee�� Z ej( e
dz e
z dz e z dz e z dz ez dz � Z ej( e
dz e
z dz e z dz dz dz dz dz e z dz ez dz dz dz dz � ZeZ ej( d ez d z � Ze d � � Z e d � � Z e d � � Z e d!� � Z e d"� � Z!e d#� � Z"e d$� � Z#e d%� � Z$e d&� � Z%e d'� � Z&y())r0 z�
Represent an ``Accept`` header.
Base class for :class:`AcceptValidHeader`, :class:`AcceptNoHeader`, and
:class:`AcceptInvalidHeader`.
z!-~u -ÿz [ !#-[\]-~�]z\\[ z"(?:(?:z)|(?:z))*"�=z(?:(?:r z((?:r- r r
r r z (?![qQ]=)r' z=(?:r z)*)r# z)=(�|z=(r r c � � |dk( rd}|S |j dd� j dd� }t j |� sd|z dz }|S )z{
Escape and quote parameter value where necessary.
For media type and extension parameter values.
� z""�\�\\�"z\")�replace�token_compiled_re�match)�cls� param_values r �!_escape_and_quote_parameter_valuez(Accept._escape_and_quote_parameter_value� sb � � �"� � �K� �� &�-�-�d�F�;�C�C��U��K� %�*�*�;�7� !�K� /�#� 5� ��r c � � d}|D ] } |d|z z
}�
|S # t $ r( |\ }}| j |�� }|d|z dz |z z
}Y �@w xY w)z�
Convert iterable of extension parameters to str segment for header.
`extension_params` is an iterable where each item is either a parameter
string or a (name, value) tuple.
r@ r �rH r= )� TypeErrorrI )rG �extension_params�extension_params_segmentr �
param_namerH s r � _form_extension_params_segmentz%Accept._form_extension_params_segment� s� � � $&� �$�
�D�
�(�S�4�Z�8�(�
� (�'�� �
�*.�'�
�K� !� C� C� +� D� � � )��*�$�s�*�[�8��(�
�s ��.A�Ac �d � d}|D ]% \ }}| j |�� }|d|z dz |z z
}�' ||z S )z�
Combine `type_subtype` and `media_type_params` to form a media range.
`type_subtype` is a ``str``, and `media_type_params` is an iterable of
(parameter name, parameter value) tuples.
r@ rK r r= )rI )rG � type_subtype�media_type_params�media_type_params_segmentrO rH s r r1 zAccept._form_media_range� sc � � %'�!�'8� P� #�J� � �?�?� '� @� �K�
&�#�
�*:�S�*@�;�*N� O� %� P�
� 7�7�7r c �� � |\ }}}|dk( r|rdj ||� }|S |}|S |dk( rdj ||� }|S dj |||� }|S # t $ r
|\ }}d}Y �_w xY w)z�
Convert iterable of tuples into header element ``str``.
Each tuple is expected to be in one of two forms: (media_range, qvalue,
extension_params_segment), or (media_range, qvalue).
r@ r z{};q=1{}r z{};q=0{}z {};q={}{})�
ValueErrorr )rG �iterable� media_ranger rN r s r �_iterable_to_header_elementz"Accept._iterable_to_header_element� s� � � *�<D� 9�K��!9�
�S�=�'�$�+�+� �!9��� �� &�� ��
�s�]� �'�'� �5M�N�G�
�� "�(�(��V�%=��G� ���# � *�"*� �K��')� $� *�s �A �A(�'A(c �� � | j j |� }t |� D ]E \ }\ }}|j d� s�|j d� s�-| j |�� }||f||< �G |S )zX
Parse media type parameters segment into list of (name, value) tuples.
rC ��token)�parameters_compiled_re�findall� enumerate�
startswith�endswith� _process_quoted_string_token)rG rT rS �index�namer4 s r �_parse_media_type_paramsz Accept._parse_media_type_params s� � �
� 6� 6� >� >� %�
�� %.�.?�$@� 9� �E�=�D�%�� � ��$�� � ��)<��8�8�u�8�E��,0�%�=�!�%�(� 9� !� r c �V � t j dd|dd � j dd� S )zH
Return unescaped and unquoted value from quoted token.
z
\\(?![\\])r@ � ���rB rA )r �subrD )rG r\ s r rb z#Accept._process_quoted_string_token* s* � � �v�v�m�R��q���5�=�=�f�d�K�Kr c � � t |t � r|S t |d� rv|i k( rg }nng }|j � D ]J \ }}t |t t
f� r|j
||df� �1|j
||d |d f� �L t |d� d�� }t |t t f� rUg }|D ]; }t |t t f� r| j |�� }|j
|� �= d j |� }|S t |� }|S )
zM
Convert Python value to header string for __add__/__radd__.
�itemsr@ r rg c � � | d S �Nrg r+ �r s r �<lambda>z4Accept._python_value_to_header_str.<locals>.<lambda>J �
� �T�!�W� r T��key�reverse�rW �, ) �
isinstance�str�hasattrrk �float�int�append�sorted�tuple�listrY �join)rG r4 �
value_listrX r �header_elements�
header_strs r �_python_value_to_header_strz"Accept._python_value_to_header_str4 s � �
�e�S� !��L� �5�'� "���{��� �
�).��� � K�%�K�� "�$��� �5�"�)�)�;��b�*A�B�"�)�)�;��Q���a��*I�J�K� � �,� ���
�e�e�T�]� +� �O� �
-�� �d�U�D�M�2� �:�:�D�:�I�D� �&�&�t�,�
-� ���?�3�J� �� �U��J��r c �l � � � j j |� � t d� �� fd�} ||�� S )as
Parse an ``Accept`` header.
:param value: (``str``) header value
:return: If `value` is a valid ``Accept`` header, returns an iterator
of (*media_range*, *qvalue*, *media_type_params*,
*extension_params*) tuples, as parsed from the header from
left to right.
| *media_range* is the media range, including any media type
parameters. The media range is returned in a canonicalised
form (except the case of the characters are unchanged):
unnecessary spaces around the semicolons before media type
parameters are removed; the parameter values are returned in
a form where only the '``\``' and '``"``' characters are
escaped, and the values are quoted with double quotes only
if they need to be quoted.
| *qvalue* is the quality value of the media range.
| *media_type_params* is the media type parameters, as a list
of (parameter name, value) tuples.
| *extension_params* is the extension parameters, as a list
where each item is either a parameter string or a (parameter
name, value) tuple.
:raises ValueError: if `value` is an invalid header
z#Invalid value for an Accept header.c 3 � �K � � j j | � D ]� }|j � }|d }� j |d �� }� j ||�� }|d }|r t |� nd}|d }|rw� j j |� }t |� D ]M \ }\ } }
|
r>|
j d� s� |
j d� s�/� j |
� � }
| |
f||< �I| ||< �O ng }||||f�� �� y �w)
Nr rg �rT )rR rS � r � rC r[ ) �'media_range_n_accept_params_compiled_re�finditer�groupsre r1 ry �accept_ext_compiled_rer^ r_ r` ra rb ) r4 rF r� rR rS rX r rM rc � token_key� token_valuerG s �r � generatorz Accept.parse.<locals>.generator| sY �� �� ��;�;�D�D�U�K�1
�� � � � �� %�a�y� �$'�$@�$@�.4�Q�i� %A� %�!� "� 3� 3�!-�&7� 4� � � ����*0��v� �c��#)�!�9� �#�'*�'A�'A�'I�'I�(�(�$� <E�(�<� @�7�� 7� �;� '� +� 6� 6�s� ;� +� 4� 4�S� 9�.1�.N�.N�*5� /O� /"� � %.�{�;"� 0�� 7� 7@� ,�U� 3� @�" (*�$� ��):�<L�� �_1
�s �B9C>�=C>�/C>�r4 )�accept_compiled_rerF rV �rG r4 r� s ` r �parsez Accept.parseX s< �� �D � !� !� '� '�� .� 6� � B�C� C�2 �f �u�%�%r c � � t |t � r|S | j j |� }|s t d� �|j � }|d j
d� \ }}| j |d �� }|dk( s|dk( r t d� �t |j � |j � t d� |D � � � S )a�
Parse an offer into its component parts.
:param offer: A media type or range in the format
``type/subtype[;params]``.
:return: A named tuple containing ``(*type*, *subtype*, *params*)``.
| *params* is a list containing ``(*parameter name*, *value*)``
values.
:raises ValueError: If the offer does not match the required format.
z"Invalid value for an Accept offer.r r- rg r� �*c 3 �F K � | ] \ }}|j � |f�� � y �w�N��lower��.0rd r4 s r � <genexpr>z%Accept.parse_offer.<locals>.<genexpr>� s � �� �H�K�D�%�4�:�:�<��'�H�� � !)
rv r* �media_type_compiled_rerF rV r� �splitre r� r} )rG �offerrF r� �
offer_type�
offer_subtype� offer_paramss r � parse_offerzAccept.parse_offer� s� � � �e�[� )��L��*�*�0�0��7��� � A�B� B�� � � ��$*�1�I�O�O�C�$8�!�
�M��3�3�&,�Q�i� 4�
� � �� �
�� 4� � A�B� B�� � � � � � � � !� �H�<�H� H�
�
r c � � g }t |� D ]* \ }} | j |� }|j ||g� �, |S # t $ r Y �:w xY w)z�
Throw out any offers that do not match the media range ABNF.
:return: A list of offers split into the format ``[offer_index,
parsed_offer]``.
)r_ r� rV r{ )rG �offers�
parsed_offersrc r� � parsed_offers r �_parse_and_normalize_offersz"Accept._parse_and_normalize_offers� se � � �
� %�f� -� 8�L�E�5�
� "���u� 5� �
� � �%� �!6� 7� 8� � �� �
��
�s �=� A �A N)'r6 r7 r8 r9 �vchar_re� obs_text_re� qdtext_re�quoted_pair_re�quoted_string_re�token_re�type_re�
subtype_re� parameter_rer" �media_range_re�
accept_ext_rer �accept_params_re� media_range_n_accept_params_rer r! r� r% r� r] r� �
media_type_rer� � classmethodrI rP r1 rY re rb r� r� r� r� r+ r r r0 r0 c s� � �� �H� �K�.��<�s�B�I�#�h�.��<�s�B�N��I� ��'�.�8�6�A� � �G��J��c�>���� � %�&�(8�9�;?�@�L� �� � � � *� +�-0� 1� � �
� � �
� �
� �
� &�
&� � � � � � � � � � �� �v� ��(�5�0�� �
� �� �"� #�%5� 6�8;� <� � �
�
� � !�6�)�M�9�E�A��%3�e�%;��&� �& �"�.8�b�j�j�&�/�+� 6�1��� (�R�Z�Z��� �v� ��#�h�.��6��A�C�G�� � � � �� (�R�Z�Z��� �v� ��#�h�.��4�
� � �
� � � � � � � #� #� &6� 6� 9<� <�
� � �
�
�
� �� #�M� '�R�Z�Z��m�(;�c�(A� B���� �� �(� �(�* �
8� �
8� �� ��8 � !� � !� �L� �L� �!� �!�F �V&� �V&�p �
� �
�B � � � r r0 c � � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
e
Z d� Z d � Z
d
� Zd � Zd � Z dd
�Zd� Zd� Z eeej �� Zd� Zdd�Zd� Zy)�AcceptValidHeaderae
Represent a valid ``Accept`` header.
A valid header is one that conforms to :rfc:`RFC 7231, section 5.3.2
<7231#section-5.3.2>`.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptValidHeader.__add__`).
c � � | j S �z'(``str`` or ``None``) The header value.��
_header_value�r3 s r � header_valuez AcceptValidHeader.header_value� � � � �!�!�!r c � � | j S )a�
(``list`` or ``None``) Parsed form of the header.
A list of (*media_range*, *qvalue*, *media_type_params*,
*extension_params*) tuples, where
*media_range* is the media range, including any media type parameters.
The media range is returned in a canonicalised form (except the case of
the characters are unchanged): unnecessary spaces around the semicolons
before media type parameters are removed; the parameter values are
returned in a form where only the '``\``' and '``"``' characters are
escaped, and the values are quoted with double quotes only if they need
to be quoted.
*qvalue* is the quality value of the media range.
*media_type_params* is the media type parameters, as a list of
(parameter name, value) tuples.
*extension_params* is the extension parameters, as a list where each
item is either a parameter string or a (parameter name, value) tuple.
��_parsedr� s r �parsedzAcceptValidHeader.parsed� s � �0 �|�|�r c � � || _ t | j |� � | _ | j D �cg c]
}|d s� |�� c}| _ yc c}w )z�
Create an :class:`AcceptValidHeader` instance.
:param header_value: (``str``) header value.
:raises ValueError: if `header_value` is an invalid value for an
``Accept`` header.
rg N�r� r~ r� r� r� �_parsed_nonzero�r3 r� r s r �__init__zAcceptValidHeader.__init__ �A � � *����D�J�J�|� 4�5�� �15��� H���Q��� H�� �� H� �
A
� A
c �8 � | j | j � S �z6
Create a copy of the header object.
�� __class__r� r� s r �copyzAcceptValidHeader.copy � � �
�~�~�d� 0� 0�1�1r c �N � t |t � rQ|j dk( r | j | j �� S t | j dz |j z �� S t |t
t f� r | j | j �� S | j | |�� S )a!
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with media ranges ``str``'s (including any media type
parameters) as keys, and either qvalues ``float``'s or (*qvalues*,
*extension_params*) tuples as values, where *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (*media_range*, *qvalue*, *extension_params*) ``tuple``
or ``list`` where *media_range* is a ``str`` of the media range
including any media type parameters, and *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* an :class:`AcceptValidHeader`, :class:`AcceptNoHeader`, or
:class:`AcceptInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or another
:class:`AcceptValidHeader` instance, and the header value it represents
is not `''`, then the two header values are joined with ``', '``, and a
new :class:`AcceptValidHeader` instance with the new header value is
returned.
If `other` is a valid header value or another
:class:`AcceptValidHeader` instance representing a header value of
`''`; or if it is ``None`` or an :class:`AcceptNoHeader` instance; or
if it is an invalid header value, or an :class:`AcceptInvalidHeader`
instance, then a new :class:`AcceptValidHeader` instance with the same
header value as ``self`` is returned.
r@ �r� ru ��instance�other)rv r� r� r� �create_accept_header�AcceptNoHeader�AcceptInvalidHeader�!_add_instance_and_non_accept_type�r3 r� s r �__add__zAcceptValidHeader.__add__% s� � �H �e� .� /��!�!�R�'��~�~�4�3D�3D�~�E�E�+�!%�!2�!2�T�!9�E�<N�<N�!N�� � �e�n�.A� B� C��>�>�t�/@�/@�>�A� A��5�5��� 6�
�
r c � � y)a.
Return whether ``self`` represents a valid ``Accept`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``True``.
Tr+ r� s r �__bool__zAcceptValidHeader.__bool__X � � � r c � � t j dt � | j D ] \ }}}}| j ||� s� y y)a�
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of :meth:`AcceptValidHeader.__contains__` is currently
being maintained for backward compatibility, but it will change in
the future to better conform to the RFC.
:param offer: (``str``) media type offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
This uses the old criterion of a match in
:meth:`AcceptValidHeader._old_match`, which is not as specified in
:rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>`. It does not
correctly take into account media type parameters:
>>> 'text/html;p=1' in AcceptValidHeader('text/html')
False
or media ranges with ``q=0`` in the header::
>>> 'text/html' in AcceptValidHeader('text/*, text/html;q=0')
True
>>> 'text/html' in AcceptValidHeader('text/html;q=0, */*')
True
(See the docstring for :meth:`AcceptValidHeader._old_match` for other
problems with the old criterion for matching.)
z�The behavior of AcceptValidHeader.__contains__ is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.TF��warnings�warn�DeprecationWarningr� �
_old_match)r3 r� rX �qualityrS rM s r � __contains__z AcceptValidHeader.__contains__e sW � �@ �
�
�
F�
�
� �
!�
!� �
� ��"3�5E����{�E�2�� �
r c # � K � t j dt � t | j d� d�� D ] \ }}}}|�� �
y�w)a@
Return all the ranges with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the media ranges in the header with non-0
qvalues, in descending order of qvalue. If two ranges have the
same qvalue, they are returned in the order of their positions
in the header, from left to right.
Please note that this is a simple filter for the ranges in the header
with non-0 qvalues, and is not necessarily the same as what the client
prefers, e.g. ``'audio/basic;q=0, */*'`` means 'everything but
audio/basic', but ``list(instance)`` would return only ``['*/*']``.
��The behavior of AcceptLanguageValidHeader.__iter__ is currently maintained for backward compatibility, but will change in the future.c � � | d S rm r+ ��is r ro z,AcceptValidHeader.__iter__.<locals>.<lambda>� �
� �!�A�$� r Trq N�r� r� r� r| r� )r3 rX r rS rM s r �__iter__zAcceptValidHeader.__iter__� sY � �� �& �
�
�
�
�
� IO� � � � ��I
� � D�K��!2�4D�
� � �s �AAc �* � | j | |d�� S �z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptValidHeader.__add__`.
T�r� r� �instance_on_the_right�r� r� s r �__radd__zAcceptValidHeader.__radd__� �# � � �5�5���d� 6�
�
r c �` � dj | j j t | � � S �Nz <{} ({!r})>�r r� r6 rw r� s r �__repr__zAcceptValidHeader.__repr__� �# � � �#�#�D�N�N�$;�$;�S��Y�G�Gr c �L � � dj � fd�� j D � � S )a
Return a tidied up version of the header value.
e.g. If ``self.header_value`` is ``r',,text/html ; p1="\"\1\"" ;
q=0.50; e1=1 ;e2 , text/plain ,'``, ``str(instance)`` returns
``r'text/html;p1="\"1\"";q=0.5;e1=1;e2, text/plain'``.
ru c 3 �z �K � | ]2 }�j |d |d �j |d �� f�� �� �4 y�w)r rg r� )rM rt N)rY rP )r� �tuple_r3 s �r r� z,AcceptValidHeader.__str__.<locals>.<genexpr>� sX �� �� �
� �
� ,� ,��1�I��1�I��7�7�)/��� 8� ��
-�
�
�s �8;�r r� r� s `r r5 zAcceptValidHeader.__str__� s) �� � �y�y�
� !�K�K�
�
�
r c � � |s | j |j �� S | j |�� }|dk( r | j |j �� S | j |�� |r|dz |j z n|j dz |z }| j |�� S # t $ r | j |j �� cY S w xY w�Nr� r� r@ ru �r� r� r� r� rV �r3 r� r� r� �other_header_value�new_header_values r r� z3AcceptValidHeader._add_instance_and_non_accept_type� �� � � ��>�>�x�/D�/D�>�E� E� !� =� =�E� =� J�� �� #� �>�>�x�/D�/D�>�E� E� F� �J�J� /�J� 0� %� �$�
&��)>�)>�
>��'�'�$�.�1C�C� �
�~�~�+;�~�<�<�� � F��>�>�x�/D�/D�>�E� E� F�� �B � %C�Cc � � |j � |j � k( s d||fv sd|k( ry |j d� D �cg c] }|j � �� c}\ }} |j d� D �cg c] }|j � �� c}\ }}|dk( r'|dk( ry|j � |j � k( S |dk( r'|dk( ry|j � |j � k( S |dk( r!|j � |j � k( S |dk( r!|j � |j � k( S |j � |j � k( S c c}w # t $ r |}d}Y �� w xY wc c}w # t $ r |}d}Y ��w xY w)a�
Check if the offer is covered by the mask
``offer`` may contain wildcards to facilitate checking if a ``mask``
would match a 'permissive' offer.
Wildcard matching forces the match to take place against the type or
subtype of the mask and offer (depending on where the wildcard matches)
.. warning::
This is maintained for backward compatibility, and will be
deprecated in the future.
This method was WebOb's old criterion for deciding whether a media type
matches a media range, used in
- :meth:`AcceptValidHeader.__contains__`
- :meth:`AcceptValidHeader.best_match`
- :meth:`AcceptValidHeader.quality`
It allows offers of *, */*, type/*, */subtype and types with no
subtypes, which are not media types as specified in :rfc:`RFC 7231,
section 5.3.2 <7231#section-5.3.2>`. This is also undocumented in any
of the public APIs that uses this method.
�*/*r� Tr- )r� r� rV )r3 �maskr� �x� mask_type� mask_subtyper� r� s r r� z AcceptValidHeader._old_match� s| � �8
�J�J�L�E�K�K�M� )��$�� �&��u� �� �:>�*�*�S�/�&J�Q�q�w�w�y�&J� #�I�|� �<A�K�K��<L�(M�q�����(M� %�J�
�
�3� ��S� �� ���(�J�,<�,<�,>�>�>� �� � ��#��#�)�)�+�}�/B�/B�/D�D�D� �C� � �?�?�$�
�(8�(8�(:�:� :� �� � �%�%�'�=�+>�+>�+@�@� @��{�{�}��
�
� �,�,��E 'K��� � �I� �L� �� )N��� � �J� �M� �sG �E �E�E � E3 �3E.�
E3 �E �
E+�*E+�.E3 �3
F�Fc �< � t | j g d��� � S )z�
Return ``True`` if any HTML-like type is accepted.
The HTML-like types are 'text/html', 'application/xhtml+xml',
'application/xml' and 'text/xml'.
�z text/htmlzapplication/xhtml+xmlzapplication/xmlztext/xml�r� ��bool�acceptable_offersr� s r � accept_htmlz AcceptValidHeader.accept_html8 s) � � � � "� "��
#�
�
�
r ��fget�docc � � | j }|D ����cg c]< \ }}}}|j d� d j � |t d� |D � � f��> }}}}}| j |� }i } |D ]w \ }
} ||
} | \ }
}}|D ]b \ }}}|j dd� \ }}|
|k( r||k( r|dk( rd}n ||k( rd}n�7|d k( r|
|k( rd
}n |d k( rd}n�M || | d
k r�Z ||
|f| | < �d �y | j � D ��cg c] \ }}|d r ||d |d f�� } }}| j d � �
� | j d� d�� | D �cg c] }|d |d f�� } }| S c c}}}}w # t $ r Y ��w xY wc c}}w c c}w )a�
Return the offers that are acceptable according to the header.
The offers are returned in descending order of preference, where
preference is indicated by the qvalue of the media range in the header
that best matches the offer.
This uses the matching rules described in :rfc:`RFC 7231, section 5.3.2
<7231#section-5.3.2>`.
Any offers that cannot be parsed via
:meth:`.Accept.parse_offer` will be ignored.
:param offers: ``iterable`` of ``str`` media types (media types can
include media type parameters) or pre-parsed instances
of :class:`.AcceptOffer`.
:return: A list of tuples of the form (media type, qvalue), in
descending order of qvalue. Where two offers have the same
qvalue, they are returned in the same order as their order in
`offers`.
r r c 3 �F K � | ] \ }}|j � |f�� � y �wr� r� r� s r r� z6AcceptValidHeader.acceptable_offers.<locals>.<genexpr>l s' � �� � �#��e� �Z�Z�\�5�)��r� r- rg r+ r� � r� r� r
c � � | d S �Nr� r+ �r� s r ro z5AcceptValidHeader.acceptable_offers.<locals>.<lambda>� s
� �F�1�I� r �rr c � � | d S rm r+ r s r ro z5AcceptValidHeader.acceptable_offers.<locals>.<lambda>� s
� �v�a�y� r Trq ) r� � partitionr� r} r� r� �KeyErrorrk �sort)r3 r� r� rX r rS �__�lowercased_ranges�lowercased_offers_parsed�#acceptable_offers_n_quality_factors� offer_indexr� r� r� r� �offer_media_type_params�range_type_subtype� range_qvalue�range_media_type_params�
range_type�
range_subtype� specificityrr r4 r s r r z#AcceptValidHeader.acceptable_offersL sM � �, ����
�
�
� ;� �V�%6�� �%�%�c�*�1�-�3�3�5��� �'8�� �
�
��
� $(�#C�#C�F�#K� �.0�+�)A� : � %�K� ��;�'�E�AM� >�J�
�'>� #�7
� �"�L�2I�,>�,D�,D�S�!�,L�)�
�M� �*�,�%� �6�.�"�4� '(� �0�4K�K�&'� � !�$��+�
�j�0H�&'� �+�u�4�&'� � !��"�;�E�B�1�E�� !�� !� � �>�3�E�:�g7
�: �~ B� G� G� I�
/
� ��U��Q�x� �%��(�E�!�H� %�
/
�+�
/
� ,�0�0�5M�0�N�+�0�0�(�$� 1�
�
,O�/
�#'�T�!�W�d�1�g� �/
�+� /
� 3�2��A
��B � � ���
/
��$/
s$ �AE
� E!�<E0�E6�! E-�,E-Nc �` � t j dt � d}|}d}|D ]� }t |t t
f� r|\ }}nd}| j D ]Y }|d } |d }
||
z } | |k r�| |k( r$|j d� | j d� k r�A| j | |� s�T| }|}| }�[ �� |S )a�
Return the best match from the sequence of media type `offers`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:meth:`AcceptValidHeader.best_match` uses its own algorithm (one not
specified in :rfc:`RFC 7231 <7231>`) to determine what is a best
match. The algorithm has many issues, and does not conform to
:rfc:`RFC 7231 <7231>`.
Each media type in `offers` is checked against each non-``q=0`` range
in the header. If the two are a match according to WebOb's old
criterion for a match, the quality value of the match is the qvalue of
the media range from the header multiplied by the server quality value
of the offer (if the server quality value is not supplied, it is 1).
The offer in the match with the highest quality value is the best
match. If there is more than one match with the highest qvalue, the
match where the media range has a lower number of '*'s is the best
match. If the two have the same number of '*'s, the one that shows up
first in `offers` is the best match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` media type,
or a (media type, server quality value) ``tuple`` or
``list``. (The two may be mixed in the iterable.)
:param default_match: (optional, any type) the value to be returned if
there is no match
:return: (``str``, or the type of `default_match`)
| The offer that is the best match. If there is no match, the
value of `default_match` is returned.
This uses the old criterion of a match in
:meth:`AcceptValidHeader._old_match`, which is not as specified in
:rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>`. It does not
correctly take into account media type parameters:
>>> instance = AcceptValidHeader('text/html')
>>> instance.best_match(offers=['text/html;p=1']) is None
True
or media ranges with ``q=0`` in the header::
>>> instance = AcceptValidHeader('text/*, text/html;q=0')
>>> instance.best_match(offers=['text/html'])
'text/html'
>>> instance = AcceptValidHeader('text/html;q=0, */*')
>>> instance.best_match(offers=['text/html'])
'text/html'
(See the docstring for :meth:`AcceptValidHeader._old_match` for other
problems with the old criterion for matching.)
Another issue is that this method considers the best matching range for
an offer to be the matching range with the highest quality value,
(where quality values are tied, the most specific media range is
chosen); whereas :rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>`
specifies that we should consider the best matching range for a media
type offer to be the most specific matching range.::
>>> instance = AcceptValidHeader('text/html;q=0.5, text/*')
>>> instance.best_match(offers=['text/html', 'text/plain'])
'text/html'
z�The behavior of AcceptValidHeader.best_match is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.rh r
rg r r� � r� r� r� rv r} r~ r� �countr� � r3 r� �
default_match� best_quality�
best_offer�
matched_byr� �server_qualityr r r� �possible_qualitys r �
best_matchz AcceptValidHeader.best_match� s� � �R �
�
�
A�
�
� � �"�
��
�� &�E��%�%�� �/�(-�%��~�!"�� �,�,�
&���A�w�� �q�'��#1�G�#;� �#�l�2� �%� �5� "�'�'��,��
�
�3��?� ��?�?�4��/�#3�L�!&�J�!%�J�
&� &�( �r c � � t j dt � d}| j D ]+ }|d }|d }| j ||� s� t ||� }�- |xs dS )a�
Return quality value of given offer, or ``None`` if there is no match.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:param offer: (``str``) media type offer
:return: (``float`` or ``None``)
| The highest quality value from the media range(s) that match
the `offer`, or ``None`` if there is no match.
This uses the old criterion of a match in
:meth:`AcceptValidHeader._old_match`, which is not as specified in
:rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>`. It does not
correctly take into account media type parameters:
>>> instance = AcceptValidHeader('text/html')
>>> instance.quality('text/html;p=1') is None
True
or media ranges with ``q=0`` in the header::
>>> instance = AcceptValidHeader('text/*, text/html;q=0')
>>> instance.quality('text/html')
1.0
>>> AcceptValidHeader('text/html;q=0, */*').quality('text/html')
1.0
(See the docstring for :meth:`AcceptValidHeader._old_match` for other
problems with the old criterion for matching.)
Another issue is that this method considers the best matching range for
an offer to be the matching range with the highest quality value,
whereas :rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>` specifies
that we should consider the best matching range for a media type offer
to be the most specific matching range.::
>>> instance = AcceptValidHeader('text/html;q=0.5, text/*')
>>> instance.quality('text/html')
1.0
z�The behavior of AcceptValidHeader.quality is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.r rg N�r� r� r� r� r� �max)r3 r� �bestqr rX r s r r� zAcceptValidHeader.quality6 sn � �Z �
�
�
@�
�
� ���K�K� +�D� �q�'�K��!�W�F����{�E�2��E�6�*�� +�
�}�� r �Fr� )r6 r7 r8 r9 �propertyr� r� r� r� r� r� � __nonzero__r� r� r� r� r5 r� r� r � accepts_htmlr r: r� r+ r r r� r� � s� � � � �"� �"� � � � �2
I�2�1
�f
� �K�+�Z �B
�H�
�2 6;�=�2E-�N
�" ��+�2E�2E�F�L�|3�Df�P9 r r� c �^ � e Zd ZdZd� Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d
� Z
dd �Zd
� Zy )�
MIMEAccepta�
Backwards compatibility shim for the new functionality provided by
AcceptValidHeader, AcceptInvalidHeader, or AcceptNoHeader, that acts like
the old MIMEAccept from WebOb version 1.7 or lower.
This shim does use the newer Accept header parsing, which will mean your
application may be less liberal in what Accept headers are correctly
parsed. It is recommended that user agents be updated to send appropriate
Accept headers that are valid according to rfc:`RFC 7231, section 5.3.2
<7231#section-5.3.2>`
.. deprecated:: 1.8
Instead of directly creating the Accept object, please see:
:func:`create_accept_header(header_value)
<webob.acceptparse.create_accept_header>`, which will create the
appropriate object.
This shim has an extended deprecation period to allow for application
developers to switch the to new API.
c �v � t j dt � t |� | _ | j j
r^| j j
D ���cg c] \ }}}}||f��
c}}}| _ | j D ��cg c] \ }}|s� ||f�� c}}| _ y g | _ g | _ y c c}}}w c c}}w )Nz�The MIMEAccept class has been replaced by webob.acceptparse.create_accept_header. This compatibility shim will be deprecated in a future version of WebOb.)r� r� r� r� �_acceptr� r� r� )r3 r� �media�q�_�ms r r� zMIMEAccept.__init__� s� � ��
�
�
?�
�
� ,�L�9�� � �<�<� � �?C�|�|�?R�?R�S�S�+;�E�1�a��U�A�J�S�D�L�9=� � �#K�v��1��Q��F�#K�D� � �D�L�#%�D� �� T��#Ks �B.�
B5�B5c # �z K � t j | � }|D ]
\ }}}}||f�� � y # t $ r Y y w xY w�wr� )r0 r� rV )r4 �parsed_acceptedrG rH rI s r r� zMIMEAccept.parse� sL � �� � � $�l�l�5� 1�O�$3�
!� ���1�a� �a�j� �
!��� � � �s �;�', �;� 8�;�8�;c �6 � | j j � S r� )rF r� r� s r r� zMIMEAccept.__repr__� � � ��|�|�$�$�&�&r c �6 � | j j � S r� )rF r� r� s r r� zMIMEAccept.__iter__� rN r c �6 � | j j � S r� )rF r5 r� s r r5 zMIMEAccept.__str__� s � ��|�|�#�#�%�%r c � � t || j � r=| j t | j j |j � � � S | j t | j j |� � � S r� )rv r� rw rF r� r� s r r� zMIMEAccept.__add__� sZ � � �e�T�^�^� ,��>�>�#�d�l�l�&:�&:�5�=�=�&I�"J�K� K��>�>�#�d�l�l�&:�&:�5�&A�"B�C� Cr c �h � | j t | j j |� � � S r� )r� rw rF r� r� s r r� zMIMEAccept.__radd__� s% � ��~�~�c�$�,�,�"7�"7��">� ?�@�@r c � � || j v S r� )rF �r3 r� s r r� zMIMEAccept.__contains__� s � ��� � �$�$r c �8 � | j j |� S r� )rF r� rT s r r� zMIMEAccept.quality� s � ��|�|�#�#�E�*�*r Nc �< � | j j ||�� S )N)r4 )rF r: )r3 r� r4 s r r: zMIMEAccept.best_match� s � ��|�|�&�&�v�]�&�K�Kr c �6 � | j j � S r� )rF r r� s r r zMIMEAccept.accept_html� s � ��|�|�'�'�)�)r r� )r6 r7 r8 r9 r� � staticmethodr� r� r� r5 r� r� r� r� r: r r+ r r rD rD r sP � ��.
&� �� ��'�'�&�D� A�%�+�L�*r rD c �h � e Zd ZdZd� ZeZd� Zd� Zd� Z e eej �� Z
d� Z d d �Z d
� Z
y) �_AcceptInvalidOrNoHeadera�
Represent when an ``Accept`` header is invalid or not in request.
This is the base class for the behaviour that :class:`.AcceptInvalidHeader`
and :class:`.AcceptNoHeader` have in common.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept`` header has an invalid value. This implementation disregards the
header when the header is invalid, so :class:`.AcceptInvalidHeader` and
:class:`.AcceptNoHeader` have much behaviour in common.
c � � y)a/
Return whether ``self`` represents a valid ``Accept`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``False``.
Fr+ r� s r r� z!_AcceptInvalidOrNoHeader.__bool__� � � � r c �8 � t j dt � y)a�
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of ``.__contains__`` for the ``Accept`` classes is
currently being maintained for backward compatibility, but it will
change in the future to better conform to the RFC.
:param offer: (``str``) media type offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
For this class, either there is no ``Accept`` header in the request, or
the header is invalid, so any media type is acceptable, and this always
returns ``True``.
z�The behavior of .__contains__ for the Accept classes is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.T�r� r� r� rT s r r� z%_AcceptInvalidOrNoHeader.__contains__� � � �$ �
�
�
F�
�
� r c �L � t j dt � t d� S )a�
Return all the ranges with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the media ranges in the header with non-0
qvalues, in descending order of qvalue. If two ranges have the
same qvalue, they are returned in the order of their positions
in the header, from left to right.
When there is no ``Accept`` header in the request or the header is
invalid, there are no media ranges, so this always returns an empty
iterator.
z}The behavior of AcceptValidHeader.__iter__ is currently maintained for backward compatibility, but will change in the future.r+ �r� r� r� �iterr� s r r� z!_AcceptInvalidOrNoHeader.__iter__� �% � �$ �
�
�
�
�
� �B�x�r c �< � t | j g d��� � S )ab
Return ``True`` if any HTML-like type is accepted.
The HTML-like types are 'text/html', 'application/xhtml+xml',
'application/xml' and 'text/xml'.
When the header is invalid, or there is no `Accept` header in the
request, all `offers` are considered acceptable, so this always returns
``True``.
r r r r� s r r z$_AcceptInvalidOrNoHeader.accept_html s) � � � � "� "��
#�
�
�
r r c �` � | j |� D ��cg c] \ }}|| df�� c}}S c c}}w )a�
Return the offers that are acceptable according to the header.
Any offers that cannot be parsed via
:meth:`.Accept.parse_offer` will be ignored.
:param offers: ``iterable`` of ``str`` media types (media types can
include media type parameters)
:return: When the header is invalid, or there is no ``Accept`` header
in the request, all `offers` are considered acceptable, so
this method returns a list of (media type, qvalue) tuples
where each offer in `offers` is paired with the qvalue of 1.0,
in the same order as in `offers`.
r )r� )r3 r� r( rI s r r z*_AcceptInvalidOrNoHeader.acceptable_offers( s= � �* �/�/��7�
� � �Q� �K�
�#� &�
�
��
s �*Nc � � t j dt � d}|}|D ]* }t |t t
f� r|\ }}nd}||kD s�'|}|}�, |S )a#
Return the best match from the sequence of language tag `offers`.
This is the ``.best_match()`` method for when the header is invalid or
not found in the request, corresponding to
:meth:`AcceptValidHeader.best_match`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptValidHeader.best_match`).
When the header is invalid, or there is no `Accept` header in the
request, all `offers` are considered acceptable, so the best match is
the media type in `offers` with the highest server quality value (if
the server quality value is not supplied for a media type, it is 1).
If more than one media type in `offers` have the same highest server
quality value, then the one that shows up first in `offers` is the best
match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` media type,
or a (media type, server quality value) ``tuple`` or
``list``. (The two may be mixed in the iterable.)
:param default_match: (optional, any type) the value to be returned if
`offers` is empty.
:return: (``str``, or the type of `default_match`)
| The offer that has the highest server quality value. If
`offers` is empty, the value of `default_match` is returned.
z�The behavior of .best_match for the Accept classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior is not specified in (and currently does not conform to) RFC 7231.rh rg �r� r� r� rv r~ r} �r3 r� r4 r5 r6 r� r� s r r: z#_AcceptInvalidOrNoHeader.best_match@ sl � �J �
�
�
?�
�
� � �"�
�� '�E��%�$�� �/�!&���w���� �%� "�
� &� � '� �r c �8 � t j dt � y)a�
Return quality value of given offer, or ``None`` if there is no match.
This is the ``.quality()`` method for when the header is invalid or not
found in the request, corresponding to
:meth:`AcceptValidHeader.quality`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptValidHeader.quality`).
:param offer: (``str``) media type offer
:return: (``float``) ``1.0``.
When the ``Accept`` header is invalid or not in the request, all offers
are equally acceptable, so 1.0 is always returned.
z�The behavior of .quality for the Accept classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior does not conform toRFC 7231.r r^ rT s r r� z _AcceptInvalidOrNoHeader.qualityx s � �( �
�
�
�
�
� r r� )r6 r7 r8 r9 r� rA r� r� r r@ rB r r: r� r+ r r rZ rZ � sF � �
�
� �K��4�4
�* ��+�2E�2E�F�L�
�06�pr rZ c �Z � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d
� Z
y ) r� a
Represent when there is no ``Accept`` header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptNoHeader.__add__`).
c � � | j S �zz
(``str`` or ``None``) The header value.
As there is no header in the request, this is ``None``.
r� r� s r r� zAcceptNoHeader.header_value� � � � �!�!�!r c � � | j S �z�
(``list`` or ``None``) Parsed form of the header.
As there is no header in the request, this is ``None``.
r� r� s r r� zAcceptNoHeader.parsed� � � � �|�|�r c �. � d| _ d| _ d| _ y)z=
Create an :class:`AcceptNoHeader` instance.
N�r� r� r� r� s r r� zAcceptNoHeader.__init__� � � � "����� � #�� r c �" � | j � S r� �r� r� s r r� zAcceptNoHeader.copy� � � �
�~�~� � r c � � t |t � rt |j �� S t |t t f� r| j � S | j
| |�� S )a�
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with media ranges ``str``'s (including any media type
parameters) as keys, and either qvalues ``float``'s or (*qvalues*,
*extension_params*) tuples as values, where *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (*media_range*, *qvalue*, *extension_params*) ``tuple``
or ``list`` where *media_range* is a ``str`` of the media range
including any media type parameters, and *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* an :class:`AcceptValidHeader`, :class:`AcceptNoHeader`, or
:class:`AcceptInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an :class:`AcceptValidHeader`
instance, a new :class:`AcceptValidHeader` instance with the valid
header value is returned.
If `other` is ``None``, an :class:`AcceptNoHeader` instance, an invalid
header value, or an :class:`AcceptInvalidHeader` instance, a new
:class:`AcceptNoHeader` instance is returned.
r� r� )rv r� r� r� r� r� r� r� s r r� zAcceptNoHeader.__add__� sZ � �> �e� .� /�$�%�2D�2D�E� E� �e�n�.A� B� C��>�>�#� #��5�5��� 6�
�
r c �& � | j |�� S )z}
Add to header, creating a new header object.
See the docstring for :meth:`AcceptNoHeader.__add__`.
�r� �r� r� s r r� zAcceptNoHeader.__radd__� � � � �|�|�%�|�(�(r c �L � dj | j j � S �Nz<{}>�r r� r6 r� s r r� zAcceptNoHeader.__repr__� � � ��}�}�T�^�^� 4� 4�5�5r c � � y�z0Return the ``str`` ``'<no header in request>'``.z<no header in request>r+ r� s r r5 zAcceptNoHeader.__str__� � � �'r c � � |�| j � S | j |�� } t |�� S # t $ r | j � cY S w xY w�Nr� r� )r� r� r� rV �r3 r� r� r s r r� z0AcceptNoHeader._add_instance_and_non_accept_type� sU � � �=��>�>�#� #� !� =� =�E� =� J�� $�$�2D�E� E��� $��>�>�#� #� $�� � 2 �A�
AN�r6 r7 r8 r9 r@ r� r� r� r� r� r� r� r5 r� r+ r r r� r� � sS � �� �"� �"� � � � �$� �'
�R)�6�(� $r r� c �^ � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d d
�Z
y )
r� aD
Represent an invalid ``Accept`` header.
An invalid header is one that does not conform to
:rfc:`7231#section-5.3.2`.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept`` header has an invalid value. This implementation disregards the
header, and treats it as if there is no ``Accept`` header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptInvalidHeader.__add__`).
c � � | j S r� r� r� s r r� z AcceptInvalidHeader.header_value r� r c � � | j S �z�
(``list`` or ``None``) Parsed form of the header.
As the header is invalid and cannot be parsed, this is ``None``.
r� r� s r r� zAcceptInvalidHeader.parsed rp r c �. � || _ d| _ d| _ y)zB
Create an :class:`AcceptInvalidHeader` instance.
Nrr �r3 r� s r r� z AcceptInvalidHeader.__init__" � � � *����� � #�� r c �8 � | j | j � S r� r� r� s r r� zAcceptInvalidHeader.copy* r� r c � � t |t � rt |j �� S t |t t f� r
t � S | j | |�� S )a�
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with media ranges ``str``'s (including any media type
parameters) as keys, and either qvalues ``float``'s or (*qvalues*,
*extension_params*) tuples as values, where *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (*media_range*, *qvalue*, *extension_params*) ``tuple``
or ``list`` where *media_range* is a ``str`` of the media range
including any media type parameters, and *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* an :class:`AcceptValidHeader`, :class:`AcceptNoHeader`, or
:class:`AcceptInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an :class:`AcceptValidHeader`
instance, then a new :class:`AcceptValidHeader` instance with the valid
header value is returned.
If `other` is ``None``, an :class:`AcceptNoHeader` instance, an invalid
header value, or an :class:`AcceptInvalidHeader` instance, a new
:class:`AcceptNoHeader` instance is returned.
r� r� )rv r� r� r� r� r� r� s r r� zAcceptInvalidHeader.__add__1 sV � �> �e� .� /�$�%�2D�2D�E� E� �e�n�.A� B� C�!�#� #��5�5��� 6�
�
r c �* � | j | |d�� S r� r� r� s r r� z AcceptInvalidHeader.__radd__Z r� r c �L � dj | j j � S r} r~ r� s r r� z AcceptInvalidHeader.__repr__d r r c � � y�z0Return the ``str`` ``'<invalid header value>'``.z<invalid header value>r+ r� s r r5 zAcceptInvalidHeader.__str__j r� r c � � |�
t � S | j |�� } t |�� S # t $ r
t � cY S w xY wr� )r� r� r� rV �r3 r� r� r� r s r r� z5AcceptInvalidHeader._add_instance_and_non_accept_typen sO � � �=�!�#� #� !� =� =�E� =� J�� $�$�2D�E� E��� $�!�#� #� $�� � , �A�ANr? r� r+ r r r� r� sX � �
� �"� �"� � � � �$�2�'
�R
�6� (�
6;� $r r� c � � | �
t � S t | t � r| j � S t | �� S # t
$ r t
| �� cY S w xY w)a�
Create an object representing the ``Accept`` header in a request.
:param header_value: (``str``) header value
:return: If `header_value` is ``None``, an :class:`AcceptNoHeader`
instance.
| If `header_value` is a valid ``Accept`` header, an
:class:`AcceptValidHeader` instance.
| If `header_value` is an invalid ``Accept`` header, an
:class:`AcceptInvalidHeader` instance.
r� )r� rv r0 r� r� rV r� r� s r r� r� | sV � � �� � � ��,��'�� � �"�"�>� �l�;�;�� � >�"� �=�=�>�� � : �A�Ac �p ��� d} d��fd�}��fd�}�fd��t ||�t j | � � S )Na�
Property representing the ``Accept`` header.
(:rfc:`RFC 7231, section 5.3.2 <7231#section-5.3.2>`)
The header value in the request environ is parsed and a new object
representing the header is created every time we *get* the value of the
property. (*set* and *del* change the header value in the request
environ, and do not involve parsing.)
� HTTP_ACCEPTc �N �� t | j j �� �� S �z5Get an object representing the header in the request.r� )r� �environ�get��request� ENVIRON_KEYs �r r z accept_property.<locals>.fget� s" �� �#� � � �,�,�[�9�
�
r c �� �� |�t |t � r
�| �� yt |t t f� r
|j }nt
j
|�� }|| j �< y)aV
Set the corresponding key in the request environ.
`value` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with media ranges ``str``'s (including any media type
parameters) as keys, and either qvalues ``float``'s or (*qvalues*,
*extension_params*) tuples as values, where *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (*media_range*, *qvalue*, *extension_params*) ``tuple``
or ``list`` where *media_range* is a ``str`` of the media range
including any media type parameters, and *extension_params* is a
``str`` of the extension parameters segment of the header element,
starting with the first '``;``'
* an :class:`AcceptValidHeader`, :class:`AcceptNoHeader`, or
:class:`AcceptInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
N�r� r� )rv r� r� r� r� r0 r� r� �r� r4 r� r� �fdels ��r �fsetz accept_property.<locals>.fset� sX �� �. �=�J�u�n� =� �� !��%�"3�5H�!I�J� $� 1� 1� � %� A� A�� A� N� �+7�G�O�O�K� (r c �@ �� | j �= y# t $ r Y yw xY w�z6Delete the corresponding key from the request environ.N�r� r" r� s �r r� z accept_property.<locals>.fdel� �& �� � ���� �,��� � � �� �
� � �r@ �textwrap�dedent�r r r� r� r� s @@r �accept_propertyr� � s= �� � �C� �K�
� 8�@� �D�$��h�o�o�c�&:� ;�;r c �| � e Zd ZdZeZ ee�� Z ej e� Z
e e�� Z e
d� � Ze
d� � Zy)�
AcceptCharsetz�
Represent an ``Accept-Charset`` header.
Base class for :class:`AcceptCharsetValidHeader`,
:class:`AcceptCharsetNoHeader`, and :class:`AcceptCharsetInvalidHeader`.
r
r# c �` � t |t � r|}|S t |d� r t |j � d� d�� }t |t
t f� rOg }|D ]5 }t |t
t f� r t |�� }|j |� �7 dj |� }|S t |� }|S )Nrk c � � | d S rm r+ rn s r ro z;AcceptCharset._python_value_to_header_str.<locals>.<lambda>� rp r Trq �r ru �
rv rw rx r| rk r} r~ r r{ r �rG r4 r� �resultr s r r� z)AcceptCharset._python_value_to_header_str� � � � �e�S� !� �J�" �� �u�g�&� ��K�K�M�,� ���
�%�%�� �/��� !� (�D�!�$���
�6� B�� M���M�M�$�'�(� "�Y�Y�v� .�
� �� !��Z�
��r c �l � � � j j |� � t d� �� fd�} ||�� S )ai
Parse an ``Accept-Charset`` header.
:param value: (``str``) header value
:return: If `value` is a valid ``Accept-Charset`` header, returns an
iterator of (charset, quality value) tuples, as parsed from
the header from left to right.
:raises ValueError: if `value` is an invalid header
z+Invalid value for an Accept-Charset header.c 3 � �K � �j j | � D ]9 }|j d� }|j d� }|r t |� nd}||f�� �; y �w�Nrg r� r )� charset_n_weight_compiled_rer� �groupry )r4 rF �charsetr rG s �r r� z&AcceptCharset.parse.<locals>.generator �Y �� �� � �:�:�C�C�E�J�
(�� �+�+�a�.�� ���Q� ��*0��v� �c�� ��'�'�
(�� �AA r� )�accept_charset_compiled_rerF rV r� s ` r r� zAcceptCharset.parse� s: �� � � )� )� /� /�� 6� >� � J�K� K� (� �u�%�%r N)r6 r7 r8 r9 r� �
charset_rer �charset_n_weight_rer r! r� r( r� r� r� r� r+ r r r� r� � sc � �� �J� ,�J�?��#-�2�:�:�.A�#B� �!=�&�"� � �� ��* �&� �&r r� c � � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
e
Z d� Z d � Z
d
� Zd � Zd � Z dd
�Zd� Zd� Zdd�Zd� Zy)�AcceptCharsetValidHeaderat
Represent a valid ``Accept-Charset`` header.
A valid header is one that conforms to :rfc:`RFC 7231, section 5.3.3
<7231#section-5.3.3>`.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptCharsetValidHeader.__add__`).
c � � | j S )z(``str``) The header value.r� r� s r r� z%AcceptCharsetValidHeader.header_value! r� r c � � | j S )zk
(``list``) Parsed form of the header.
A list of (charset, quality value) tuples.
r� r� s r r� z AcceptCharsetValidHeader.parsed& rp r c � � || _ t | j |� � | _ | j D �cg c]
}|d s� |�� c}| _ yc c}w )z�
Create an :class:`AcceptCharsetValidHeader` instance.
:param header_value: (``str``) header value.
:raises ValueError: if `header_value` is an invalid value for an
``Accept-Charset`` header.
rg Nr� r� s r r� z!AcceptCharsetValidHeader.__init__/ sH � � *����D�J�J�|� 4�5�� � !�[�[�
��D��G�D�
�� ��
r� c �8 � | j | j � S r� r� r� s r r� z AcceptCharsetValidHeader.copy= r� r c � � t |t � r&t | j dz |j z �� S t |t t
f� r | j
| j �� S | j | |�� S )a�
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, where keys are charsets and values are qvalues
* a ``tuple`` or ``list``, where each item is a charset ``str`` or a
``tuple`` or ``list`` (charset, qvalue) pair (``str``'s and pairs
can be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptCharsetValidHeader`, :class:`AcceptCharsetNoHeader`,
or :class:`AcceptCharsetInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or another
:class:`AcceptCharsetValidHeader` instance, the two header values are
joined with ``', '``, and a new :class:`AcceptCharsetValidHeader`
instance with the new header value is returned.
If `other` is ``None``, an :class:`AcceptCharsetNoHeader` instance, an
invalid header value, or an :class:`AcceptCharsetInvalidHeader`
instance, a new :class:`AcceptCharsetValidHeader` instance with the
same header value as ``self`` is returned.
ru r� r� )rv r� � create_accept_charset_headerr� �AcceptCharsetNoHeader�AcceptCharsetInvalidHeaderr� �)_add_instance_and_non_accept_charset_typer� s r r� z AcceptCharsetValidHeader.__add__D s� � �4 �e� 5� 6�/� !� .� .�� 5��8J�8J� J��
� � �)�+E�F�
� �>�>�t�/@�/@�>�A� A��=�=��� >�
�
r c � � y)a6
Return whether ``self`` represents a valid ``Accept-Charset`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``True``.
Tr+ r� s r r� z!AcceptCharsetValidHeader.__bool__l r� r c � � t j dt � | j D ] \ }}| j ||� s� y y)a3
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of :meth:`AcceptCharsetValidHeader.__contains__` is
currently being maintained for backward compatibility, but it will
change in the future to better conform to the RFC.
:param offer: (``str``) charset offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
This does not fully conform to :rfc:`RFC 7231, section 5.3.3
<7231#section-5.3.3>`: it incorrect interprets ``*`` to mean 'match any
charset in the header', rather than 'match any charset that is not
mentioned elsewhere in the header'::
>>> 'UTF-8' in AcceptCharsetValidHeader('UTF-8;q=0, *')
True
z�The behavior of AcceptCharsetValidHeader.__contains__ is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.TFr� �r3 r� r r� s r r� z%AcceptCharsetValidHeader.__contains__y sL � �, �
�
�
F�
�
� "� 1� 1� �M�D�'����t�U�+�� � r c # � K � t j dt � t | j d� d�� D ] \ }}|�� � y�w)a9
Return all the items with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the items (charset or ``*``) in the header
with non-0 qvalues, in descending order of qvalue. If two
items have the same qvalue, they are returned in the order of
their positions in the header, from left to right.
Please note that this is a simple filter for the items in the header
with non-0 qvalues, and is not necessarily the same as what the client
prefers, e.g. ``'utf-7;q=0, *'`` means 'everything but utf-7', but
``list(instance)`` would return only ``['*']``.
��The behavior of AcceptCharsetValidHeader.__iter__ is currently maintained for backward compatibility, but will change in the future.c � � | d S rm r+ r� s r ro z3AcceptCharsetValidHeader.__iter__.<locals>.<lambda>� r� r Trq Nr� �r3 rJ rH s r r� z!AcceptCharsetValidHeader.__iter__� sN � �� �& �
�
�
�
�
� � � � � ��
� �C�A�a�
�G� �� �AAc �* � | j | |d�� S �z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptCharsetValidHeader.__add__`.
Tr� �r� r� s r r� z!AcceptCharsetValidHeader.__radd__� �# � � �=�=���d� >�
�
r c �` � dj | j j t | � � S r� r� r� s r r� z!AcceptCharsetValidHeader.__repr__� r� r c �F � dj d� | j D � � S )a
Return a tidied up version of the header value.
e.g. If the ``header_value`` is ``', \t,iso-8859-5;q=0.000 \t,
utf-8;q=1.000, UTF-7, unicode-1-1;q=0.210 ,'``, ``str(instance)``
returns ``'iso-8859-5;q=0, utf-8, UTF-7, unicode-1-1;q=0.21'``.
ru c 3 �4 K � | ] }t |� � �� � y�w�r� N�r �r� r� s r r� z3AcceptCharsetValidHeader.__str__.<locals>.<genexpr>� � � �� �
��
0�V� <� <�
�� �r r� s r r5 z AcceptCharsetValidHeader.__str__� �& � � �y�y�
� �+�+�
�
�
r c �N � |s | j |j �� S | j |�� } | j |�� |r|dz |j z n|j dz |z }| j |�� S # t $ r | j |j �� cY S w xY w�Nr� r� ru r r s r r� zBAcceptCharsetValidHeader._add_instance_and_non_accept_charset_type� � � � ��>�>�x�/D�/D�>�E� E� !� =� =�E� =� J�� F� �J�J� /�J� 0� %� �$�
&��)>�)>�
>��'�'�$�.�1C�C� �
�~�~�+;�~�<�<�� � F��>�>�x�/D�/D�>�E� E� F�� �A< �<%B$�#B$c �R � |dk( xs! |j � |j � k( S )a�
Return whether charset offer matches header item (charset or ``*``).
.. warning::
This is maintained for backward compatibility, and will be
deprecated in the future.
This method was WebOb's old criterion for deciding whether a charset
matches a header item (charset or ``*``), used in
- :meth:`AcceptCharsetValidHeader.__contains__`
- :meth:`AcceptCharsetValidHeader.best_match`
- :meth:`AcceptCharsetValidHeader.quality`
It does not conform to :rfc:`RFC 7231, section 5.3.3
<7231#section-5.3.3>` in that it does not interpret ``*`` values in the
header correctly: ``*`` should only match charsets not mentioned
elsewhere in the header.
r� r� �r3 r r� s r r� z#AcceptCharsetValidHeader._old_match� s$ � �* �s�{�;�e�k�k�m�t�z�z�|� ;�;r c �� �� | j D ��cg c] \ }}|j � |f�� }}}|D �cg c] }|j � �� }}t � }t � }d} |D ]6 \ }}|dk( r| ��|} �||vs�||vs�|dk( r|j |� �2|||< �8 t |j
� � }|j d� d�� g }
t |� D ]M \ } �t �fd�|D � � r�d} |D ] \ }}�|k( s� |} n | r| } | ��7|
j || | | f� �O |
j d� � � |
j d
� d�� |
D �
cg c] }
|
d |
d f�� c}
S c c}}w c c}w c c}
w )
a�
Return the offers that are acceptable according to the header.
The offers are returned in descending order of preference, where
preference is indicated by the qvalue of the charset or ``*`` in the
header matching the offer.
This uses the matching rules described in :rfc:`RFC 7231, section 5.3.3
<7231#section-5.3.3>`.
:param offers: ``iterable`` of ``str`` charsets
:return: A list of tuples of the form (charset, qvalue), in descending
order of qvalue. Where two offers have the same qvalue, they
are returned in the same order as their order in `offers`.
Nr� r c � � | d S rm r+ r s r ro z<AcceptCharsetValidHeader.acceptable_offers.<locals>.<lambda>' �
� �F�1�I� r Trq c 3 �( �K � | ] }�|k( �� � y �wr� r+ )r� r� r� s �r r� z=AcceptCharsetValidHeader.acceptable_offers.<locals>.<genexpr>, � �� �� � �'.��'�!��� �c � � | d S r r+ r s r ro z<AcceptCharsetValidHeader.acceptable_offers.<locals>.<lambda>? �
� ��q� � r r c � � | d S rm r+ r s r ro z<AcceptCharsetValidHeader.acceptable_offers.<locals>.<lambda>C r� r r rg � r� r� �set�dict�addr~ rk r# r_ �anyr{ )r3 r� r� r �lowercased_parsedr� �lowercased_offers�not_acceptable_charsets�acceptable_charsets�asterisk_qvalue�filtered_offersrc �matched_charset_qvaluer s ` r r z*AcceptCharsetValidHeader.acceptable_offers� s� �� �" @D�{�{�
�*;�7�F�W�]�]�_�f� %�
��
� 9?� ?�u�U�[�[�]� ?�� ?�"%�%� � "�f�� �� 0� :�O�G�V��#�~�"�*�&,�O�� 2�2�w�'�8(� �S�=�+�/�/��8�39�'��0� :� #�#6�#<�#<�#>� ?��� � �%=�t� �L� �� %�&7� 8� �L�E�5�� �2I�� � �%)� "�#6�
=�����G�#�-3�*��
=�
#�-<�*�%�1� �&�&��5�M�#9�5�(� �! �* � � �!9� �:� � � �!9�4� �H�/>�?�t��a��$�q�'�"�?�?��m
�� @��f @s � E'�E-�E2Nc �R � t j dt � d}|}d}|D ]� }t |t t
f� r|\ }}nd}| j D ]R \ }} || z }
|
|k r�|
|k( r$|j d� |j d� k r�:| j ||� s�M|
}|}|}�T �� |S )aK
Return the best match from the sequence of charset `offers`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:meth:`AcceptCharsetValidHeader.best_match` has many issues, and
does not conform to :rfc:`RFC 7231 <7231>`.
Each charset in `offers` is checked against each non-``q=0`` item
(charset or ``*``) in the header. If the two are a match according to
WebOb's old criterion for a match, the quality value of the match is
the qvalue of the item from the header multiplied by the server quality
value of the offer (if the server quality value is not supplied, it is
1).
The offer in the match with the highest quality value is the best
match. If there is more than one match with the highest qvalue, the one
that shows up first in `offers` is the best match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` charset, or
a (charset, server quality value) ``tuple`` or
``list``. (The two may be mixed in the iterable.)
:param default_match: (optional, any type) the value to be returned if
there is no match
:return: (``str``, or the type of `default_match`)
| The offer that is the best match. If there is no match, the
value of `default_match` is returned.
The algorithm behind this method was written for the ``Accept`` header
rather than the ``Accept-Charset`` header. It uses the old criterion of
a match in :meth:`AcceptCharsetValidHeader._old_match`, which does not
conform to :rfc:`RFC 7231, section 5.3.3 <7231#section-5.3.3>`, in that
it does not interpret ``*`` values in the header correctly: ``*``
should only match charsets not mentioned elsewhere in the header::
>>> AcceptCharsetValidHeader('utf-8;q=0, *').best_match(['utf-8'])
'utf-8'
z�The behavior of AcceptCharsetValidHeader.best_match is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.rh r
rg r� r1 � r3 r� r4 r5 r6 r7 r� r8 r r� r9 s r r: z#AcceptCharsetValidHeader.best_matchH s� � �^ �
�
�
K�
�
� � �"�
��
�� &�E��%�%�� �/�(-�%��~�!"��!%�!5�!5�
&�
��g�#1�G�#;� �#�l�2� �%� �5�
"�'�'��,��
�
�3��?� ��?�?�4��/�#3�L�!&�J�!%�J�
&� &�( �r c � � t j dt � d}| j D ]$ \ }}| j ||� s�t ||� }�& |xs dS )a�
Return quality value of given offer, or ``None`` if there is no match.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:param offer: (``str``) charset offer
:return: (``float`` or ``None``)
| The quality value from the charset that matches the `offer`,
or ``None`` if there is no match.
This uses the old criterion of a match in
:meth:`AcceptCharsetValidHeader._old_match`, which does not conform to
:rfc:`RFC 7231, section 5.3.3 <7231#section-5.3.3>`, in that it does
not interpret ``*`` values in the header correctly: ``*`` should only
match charsets not mentioned elsewhere in the header::
>>> AcceptCharsetValidHeader('utf-8;q=0, *').quality('utf-8')
1.0
>>> AcceptCharsetValidHeader('utf-8;q=0.9, *').quality('utf-8')
1.0
z�The behavior of AcceptCharsetValidHeader.quality is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.r Nr< �r3 r� r> r rH s r r� z AcceptCharsetValidHeader.quality� s^ � �4 �
�
�
K�
�
� ���{�{� &�G�D�!����t�U�+��E�1�
�� &� �}�� r r? r� )r6 r7 r8 r9 r@ r� r� r� r� r� r� rA r� r� r� r� r5 r� r� r r: r� r+ r r r� r� s� � � � �"� �"� � � � �
� 2�&
�P
� �K� �B �@
�H�
� 6;�=�(<�.F@�RL�\$ r r� c �: � e Zd ZdZd� ZeZd� Zd� Zd� Zd d�Z d� Z
y)
� _AcceptCharsetInvalidOrNoHeadera$
Represent when an ``Accept-Charset`` header is invalid or not in request.
This is the base class for the behaviour that
:class:`.AcceptCharsetInvalidHeader` and :class:`.AcceptCharsetNoHeader`
have in common.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept-Charset`` header has an invalid value. This implementation
disregards the header when the header is invalid, so
:class:`.AcceptCharsetInvalidHeader` and :class:`.AcceptCharsetNoHeader`
have much behaviour in common.
c � � y)a7
Return whether ``self`` represents a valid ``Accept-Charset`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``False``.
Fr+ r� s r r� z(_AcceptCharsetInvalidOrNoHeader.__bool__� r\ r c �8 � t j dt � y)a�
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of ``.__contains__`` for the ``AcceptCharset`` classes
is currently being maintained for backward compatibility, but it
will change in the future to better conform to the RFC.
:param offer: (``str``) charset offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
For this class, either there is no ``Accept-Charset`` header in the
request, or the header is invalid, so any charset is acceptable, and
this always returns ``True``.
z�The behavior of .__contains__ for the AcceptCharset classes is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.Tr^ rT s r r� z,_AcceptCharsetInvalidOrNoHeader.__contains__� r_ r c �L � t j dt � t d� S )a�
Return all the items with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the items (charset or ``*``) in the header
with non-0 qvalues, in descending order of qvalue. If two
items have the same qvalue, they are returned in the order of
their positions in the header, from left to right.
When there is no ``Accept-Charset`` header in the request or the header
is invalid, there are no items, and this always returns an empty
iterator.
r� r+ ra r� s r r� z(_AcceptCharsetInvalidOrNoHeader.__iter__� rc r c �0 � |D �cg c] }|df�� c}S c c}w )a
Return the offers that are acceptable according to the header.
The offers are returned in descending order of preference, where
preference is indicated by the qvalue of the charset or ``*`` in the
header matching the offer.
This uses the matching rules described in :rfc:`RFC 7231, section 5.3.3
<7231#section-5.3.3>`.
:param offers: ``iterable`` of ``str`` charsets
:return: A list of tuples of the form (charset, qvalue), in descending
order of qvalue. Where two offers have the same qvalue, they
are returned in the same order as their order in `offers`.
| When the header is invalid or there is no ``Accept-Charset``
header in the request, all `offers` are considered
acceptable, so this method returns a list of (charset,
qvalue) tuples where each offer in `offers` is paired with
the qvalue of 1.0, in the same order as `offers`.
r r+ �r3 r� r� s r r z1_AcceptCharsetInvalidOrNoHeader.acceptable_offers
s � �, +1�1���� �1�1��1� � Nc � � t j dt � d}|}|D ]* }t |t t
f� r|\ }}nd}||kD s�'|}|}�, |S )a+
Return the best match from the sequence of charset `offers`.
This is the ``.best_match()`` method for when the header is invalid or
not found in the request, corresponding to
:meth:`AcceptCharsetValidHeader.best_match`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptCharsetValidHeader.best_match`).
When the header is invalid, or there is no `Accept-Charset` header in
the request, all the charsets in `offers` are considered acceptable, so
the best match is the charset in `offers` with the highest server
quality value (if the server quality value is not supplied, it is 1).
If more than one charsets in `offers` have the same highest server
quality value, then the one that shows up first in `offers` is the best
match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` charset, or
a (charset, server quality value) ``tuple`` or
``list``. (The two may be mixed in the iterable.)
:param default_match: (optional, any type) the value to be returned if
`offers` is empty.
:return: (``str``, or the type of `default_match`)
| The charset that has the highest server quality value. If
`offers` is empty, the value of `default_match` is returned.
z�The behavior of .best_match for the AcceptCharset classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior is not specified in (and currently does not conform to) RFC 7231.rh rg rg rh s r r: z*_AcceptCharsetInvalidOrNoHeader.best_match% sm � �J �
�
�
I�
�
� � �"�
�� '�E��%�$�� �/�!&���w���� �%� "�
� &� � '� �r c �8 � t j dt � y)a�
Return quality value of given offer, or ``None`` if there is no match.
This is the ``.quality()`` method for when the header is invalid or not
found in the request, corresponding to
:meth:`AcceptCharsetValidHeader.quality`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptCharsetValidHeader.quality`).
:param offer: (``str``) charset offer
:return: (``float``) ``1.0``.
When the ``Accept-Charset`` header is invalid or not in the request,
all offers are equally acceptable, so 1.0 is always returned.
z�The behavior of .quality for the Accept-Charset classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior does not conform to RFC 7231.r r^ rT s r r� z'_AcceptCharsetInvalidOrNoHeader.quality] s � �( �
�
�
$�
�
� r r� � r6 r7 r8 r9 r� rA r� r� r r: r� r+ r r r r � s- � � �
� �K��4�42�06�pr r c �Z � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d
� Z
y ) r� a$
Represent when there is no ``Accept-Charset`` header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptCharsetNoHeader.__add__`).
c � � | j S rl r� r� s r r� z"AcceptCharsetNoHeader.header_value� rm r c � � | j S ro r� r� s r r� z AcceptCharsetNoHeader.parsed� rp r c �. � d| _ d| _ d| _ y)zD
Create an :class:`AcceptCharsetNoHeader` instance.
Nrr r� s r r� z AcceptCharsetNoHeader.__init__� rs r c �" � | j � S r� ru r� s r r� zAcceptCharsetNoHeader.copy� rv r c � � t |t � rt |j �� S t |t t f� r| j � S | j
| |�� S �a*
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, where keys are charsets and values are qvalues
* a ``tuple`` or ``list``, where each item is a charset ``str`` or a
``tuple`` or ``list`` (charset, qvalue) pair (``str``'s and pairs
can be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptCharsetValidHeader`, :class:`AcceptCharsetNoHeader`,
or :class:`AcceptCharsetInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an
:class:`AcceptCharsetValidHeader` instance, a new
:class:`AcceptCharsetValidHeader` instance with the valid header value
is returned.
If `other` is ``None``, an :class:`AcceptCharsetNoHeader` instance, an
invalid header value, or an :class:`AcceptCharsetInvalidHeader`
instance, a new :class:`AcceptCharsetNoHeader` instance is returned.
r� r� )rv r� r� r� r� r� r� r� s r r� z AcceptCharsetNoHeader.__add__� s` � �2 �e� 5� 6�+��9K�9K�L� L� � �)�+E�F�
� �>�>�#� #��=�=��� >�
�
r c �& � | j |�� S )z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptCharsetNoHeader.__add__`.
ry rz r� s r r� z AcceptCharsetNoHeader.__radd__� r{ r c �L � dj | j j � S r} r~ r� s r r� z AcceptCharsetNoHeader.__repr__� r r c � � yr� r+ r� s r r5 z AcceptCharsetNoHeader.__str__� r� r c � � |s| j � S | j |�� } t |�� S # t $ r | j � cY S w xY wr� )r� r� r� rV r� s r r� z?AcceptCharsetNoHeader._add_instance_and_non_accept_charset_type� sS � ���>�>�#� #� !� =� =�E� =� J�� $�+�9K�L� L��� $��>�>�#� #� $�r� N�r6 r7 r8 r9 r@ r� r� r� r� r� r� r� r5 r� r+ r r r� r� { sS � �� �"� �"� � � � �$� �#
�J)�6�(� $r r� c �^ � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d d
�Z
y )
r� a�
Represent an invalid ``Accept-Charset`` header.
An invalid header is one that does not conform to
:rfc:`7231#section-5.3.3`. As specified in the RFC, an empty header is an
invalid ``Accept-Charset`` header.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept-Charset`` header has an invalid value. This implementation
disregards the header, and treats it as if there is no ``Accept-Charset``
header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptCharsetInvalidHeader.__add__`).
c � � | j S r� r� r� s r r� z'AcceptCharsetInvalidHeader.header_value� r� r c � � | j S r� r� r� s r r� z!AcceptCharsetInvalidHeader.parsed� rp r c �. � || _ d| _ d| _ y)zI
Create an :class:`AcceptCharsetInvalidHeader` instance.
Nrr r� s r r� z#AcceptCharsetInvalidHeader.__init__
r� r c �8 � | j | j � S r� r� r� s r r� z AcceptCharsetInvalidHeader.copy
r� r c � � t |t � rt |j �� S t |t t f� r
t � S | j | |�� S r )rv r� r� r� r� r� r� s r r� z"AcceptCharsetInvalidHeader.__add__
s\ � �2 �e� 5� 6�+��9K�9K�L� L� � �)�+E�F�
� )�*� *��=�=��� >�
�
r c �* � | j | |d�� S r� r� r� s r r� z#AcceptCharsetInvalidHeader.__radd__9
r� r c �L � dj | j j � S r} r~ r� s r r� z#AcceptCharsetInvalidHeader.__repr__C
r r c � � yr� r+ r� s r r5 z"AcceptCharsetInvalidHeader.__str__I
r� r c � � |s
t � S | j |�� } t |�� S # t $ r
t � cY S w xY wr� )r� r� r� rV r� s r r� zDAcceptCharsetInvalidHeader._add_instance_and_non_accept_charset_typeM
sM � � �(�*� *� !� =� =�E� =� J�� +�+�9K�L� L��� +�(�*� *� +�r� Nr? r r+ r r r� r� � sX � ��" �"� �"� � � � �$�2�#
�J
�6� (�
6;� +r r� c � � | �
t � S t | t � r| j � S t | �� S # t
$ r t
| �� cY S w xY w)a�
Create an object representing the ``Accept-Charset`` header in a request.
:param header_value: (``str``) header value
:return: If `header_value` is ``None``, an :class:`AcceptCharsetNoHeader`
instance.
| If `header_value` is a valid ``Accept-Charset`` header, an
:class:`AcceptCharsetValidHeader` instance.
| If `header_value` is an invalid ``Accept-Charset`` header, an
:class:`AcceptCharsetInvalidHeader` instance.
r� )r� rv r� r� r� rV r� r� s r r� r� [
sY � � ��$�&�&��,�
�.�� � �"�"�E�'�\�B�B�� � E�)�|�D�D�E�r� c �p ��� d} d��fd�}��fd�}�fd��t ||�t j | � � S )Na�
Property representing the ``Accept-Charset`` header.
(:rfc:`RFC 7231, section 5.3.3 <7231#section-5.3.3>`)
The header value in the request environ is parsed and a new object
representing the header is created every time we *get* the value of the
property. (*set* and *del* change the header value in the request
environ, and do not involve parsing.)
�HTTP_ACCEPT_CHARSETc �N �� t | j j �� �� S r� )r� r� r� r� s �r r z%accept_charset_property.<locals>.fget�
s" �� �+� � � �,�,�[�9�
�
r c �� �� |�t |t � r
�| �� yt |t t f� r
|j }nt
j
|�� }|| j �< y)az
Set the corresponding key in the request environ.
`value` can be:
* ``None``
* a ``str`` header value
* a ``dict``, where keys are charsets and values are qvalues
* a ``tuple`` or ``list``, where each item is a charset ``str`` or a
``tuple`` or ``list`` (charset, qvalue) pair (``str``'s and pairs
can be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptCharsetValidHeader`, :class:`AcceptCharsetNoHeader`,
or :class:`AcceptCharsetInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
Nr� r� )rv r� r� r� r� r� r� r� r� s ��r r� z%accept_charset_property.<locals>.fset�
sf �� � �=�J�u�.C� D� �� !���0�2L�M�� %� 1� 1� � ,� H� H� � I� � � ,8�G�O�O�K� (r c �@ �� | j �= y# t $ r Y yw xY wr� r� r� s �r r� z%accept_charset_property.<locals>.fdel�
r� r� r� r� s @@r �accept_charset_propertyr, s
s< �� � �C� (�K�
� 8�:� �D�$��h�o�o�c�&:� ;�;r c �| � e Zd ZdZeZ ee�� Z ej e� Z
e e�� Z e
d� � Ze
d� � Zy)�AcceptEncodingz�
Represent an ``Accept-Encoding`` header.
Base class for :class:`AcceptEncodingValidHeader`,
:class:`AcceptEncodingNoHeader`, and :class:`AcceptEncodingInvalidHeader`.
r
r# c �` � t |t � r|}|S t |d� r t |j � d� d�� }t |t
t f� rOg }|D ]5 }t |t
t f� r t |�� }|j |� �7 dj |� }|S t |� }|S )Nrk c � � | d S rm r+ rn s r ro z<AcceptEncoding._python_value_to_header_str.<locals>.<lambda>�
rp r Trq r� ru r� r� s r r� z*AcceptEncoding._python_value_to_header_str�
r� r c �l � � � j j |� � t d� �� fd�} ||�� S )ak
Parse an ``Accept-Encoding`` header.
:param value: (``str``) header value
:return: If `value` is a valid ``Accept-Encoding`` header, returns an
iterator of (codings, quality value) tuples, as parsed from
the header from left to right.
:raises ValueError: if `value` is an invalid header
z,Invalid value for an Accept-Encoding header.c 3 � �K � �j j | � D ]9 }|j d� }|j d� }|r t |� nd}||f�� �; y �wr� )� codings_n_weight_compiled_rer� r� ry )r4 rF �codingsr rG s �r r� z'AcceptEncoding.parse.<locals>.generator�
r� r� r� )�accept_encoding_compiled_rerF rV r� s ` r r� zAcceptEncoding.parse�
s: �� � � *� *� 0� 0�� 7� ?� � K�L� L� (� �u�%�%r N)r6 r7 r8 r9 r� �
codings_rer �codings_n_weight_rer r! r3 r% r5 r� r� r� r+ r r r. r. �
sc � �� �J� ,�J�?��#-�2�:�:�.A�#B� �">�&�#� � �� ��* �&� �&r r. c � � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
e
Z d� Z d � Z
d
� Zd � Zd � Z dd
�Zd� Zd� Zdd�Zd� Zy)�AcceptEncodingValidHeaderav
Represent a valid ``Accept-Encoding`` header.
A valid header is one that conforms to :rfc:`RFC 7231, section 5.3.4
<7231#section-5.3.4>`.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptEncodingValidHeader.__add__`).
c � � | j S r� r� r� s r r� z&AcceptEncodingValidHeader.header_value r� r c � � | j S )a"
(``list`` or ``None``) Parsed form of the header.
A list of (*codings*, *qvalue*) tuples, where
*codings* (``str``) is a content-coding, the string "``identity``", or
"``*``"; and
*qvalue* (``float``) is the quality value of the codings.
r� r� s r r� z AcceptEncodingValidHeader.parsed s � � �|�|�r c � � || _ t | j |� � | _ | j D �cg c]
}|d s� |�� c}| _ yc c}w )z�
Create an :class:`AcceptEncodingValidHeader` instance.
:param header_value: (``str``) header value.
:raises ValueError: if `header_value` is an invalid value for an
``Accept-Encoding`` header.
rg Nr� r� s r r� z"AcceptEncodingValidHeader.__init__ r� r� c �8 � | j | j � S r� r� r� s r r� z AcceptEncodingValidHeader.copy r� r c �N � t |t � rQ|j dk( r | j | j �� S t | j dz |j z �� S t |t
t f� r | j | j �� S | j | |�� S )a�
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with content-coding, ``identity`` or ``*`` ``str``'s as
keys, and qvalue ``float``'s as values
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (content-coding/``identity``/``*``, qvalue) ``tuple``
or ``list``
* an :class:`AcceptEncodingValidHeader`,
:class:`AcceptEncodingNoHeader`, or
:class:`AcceptEncodingInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or another
:class:`AcceptEncodingValidHeader` instance, and the header value it
represents is not ``''``, then the two header values are joined with
``', '``, and a new :class:`AcceptEncodingValidHeader` instance with
the new header value is returned.
If `other` is a valid header value or another
:class:`AcceptEncodingValidHeader` instance representing a header value
of ``''``; or if it is ``None`` or an :class:`AcceptEncodingNoHeader`
instance; or if it is an invalid header value, or an
:class:`AcceptEncodingInvalidHeader` instance, then a new
:class:`AcceptEncodingValidHeader` instance with the same header value
as ``self`` is returned.
r@ r� ru r� )rv r9 r� r� � create_accept_encoding_header�AcceptEncodingNoHeader�AcceptEncodingInvalidHeader�*_add_instance_and_non_accept_encoding_typer� s r r� z!AcceptEncodingValidHeader.__add__' s� � �@ �e� 6� 7��!�!�R�'��~�~�4�3D�3D�~�E�E�4�!%�!2�!2�T�!9�E�<N�<N�!N�� � � �*�,G�H�
� �>�>�t�/@�/@�>�A� A��>�>��� ?�
�
r c � � y)a7
Return whether ``self`` represents a valid ``Accept-Encoding`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``True``.
Tr+ r� s r r� z"AcceptEncodingValidHeader.__bool__X r� r c � � t j dt � | j D ] \ }}| j ||� s� y y)aM
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of :meth:`AcceptEncodingValidHeader.__contains__` is
currently being maintained for backward compatibility, but it will
change in the future to better conform to the RFC.
:param offer: (``str``) a content-coding or ``identity`` offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
The behavior of this method does not fully conform to :rfc:`7231`.
It does not correctly interpret ``*``::
>>> 'gzip' in AcceptEncodingValidHeader('gzip;q=0, *')
True
and does not handle the ``identity`` token correctly::
>>> 'identity' in AcceptEncodingValidHeader('gzip')
False
z�The behavior of AcceptEncodingValidHeader.__contains__ is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.TNr� r� s r r� z&AcceptEncodingValidHeader.__contains__e sG � �2 �
�
�
F�
�
� "� 1� 1� �M�D�'����t�U�+�� r c # � K � t j dt � t | j d� d�� D ] \ }}|�� � y�w)aZ
Return all the ranges with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the (content-coding/``identity``/``*``) items
in the header with non-0 qvalues, in descending order of
qvalue. If two items have the same qvalue, they are returned
in the order of their positions in the header, from left to
right.
Please note that this is a simple filter for the items in the header
with non-0 qvalues, and is not necessarily the same as what the client
prefers, e.g. ``'gzip;q=0, *'`` means 'everything but gzip', but
``list(instance)`` would return only ``['*']``.
z�The behavior of AcceptEncodingLanguageValidHeader.__iter__ is currently maintained for backward compatibility, but will change in the future.c � � | d S rm r+ r� s r ro z4AcceptEncodingValidHeader.__iter__.<locals>.<lambda>� r� r Trq Nr� r� s r r� z"AcceptEncodingValidHeader.__iter__� sN � �� �( �
�
�
�
�
� � � � � ��
� �C�A�a�
�G� �r� c �* � | j | |d�� S �z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptEncodingValidHeader.__add__`.
Tr� �rB r� s r r� z"AcceptEncodingValidHeader.__radd__� �# � � �>�>���d� ?�
�
r c �` � dj | j j t | � � S r� r� r� s r r� z"AcceptEncodingValidHeader.__repr__� r� r c �F � dj d� | j D � � S )z�
Return a tidied up version of the header value.
e.g. If the ``header_value`` is ``",\t, a ;\t q=0.20 , b ,',"``,
``str(instance)`` returns ``"a;q=0.2, b, '"``.
ru c 3 �4 K � | ] }t |� � �� � y�wr� r� r� s r r� z4AcceptEncodingValidHeader.__str__.<locals>.<genexpr>� r� r� r r� s r r5 z!AcceptEncodingValidHeader.__str__� s& � � �y�y�
� �+�+�
�
�
r c � � |s | j |j �� S | j |�� }|dk( r | j |j �� S | j |�� |r|dz |j z n|j dz |z }| j |�� S # t $ r | j |j �� cY S w xY wr r r s r rB zDAcceptEncodingValidHeader._add_instance_and_non_accept_encoding_type� r r c �R � |dk( xs! |j � |j � k( S )a'
Return whether content-coding offer matches codings header item.
.. warning::
This is maintained for backward compatibility, and will be
deprecated in the future.
This method was WebOb's old criterion for deciding whether a
content-coding offer matches a header item (content-coding,
``identity`` or ``*``), used in
- :meth:`AcceptCharsetValidHeader.__contains__`
- :meth:`AcceptCharsetValidHeader.best_match`
- :meth:`AcceptCharsetValidHeader.quality`
It does not conform to :rfc:`RFC 7231, section 5.3.4
<7231#section-5.3.4>` in that it does not interpret ``*`` values in the
header correctly: ``*`` should only match content-codings not mentioned
elsewhere in the header.
r� r� r� s r r� z$AcceptEncodingValidHeader._old_match� s$ � �, �s�{�;�e�k�k�m�t�z�z�|� ;�;r c � �� | j D ��cg c] \ }}|j � |f�� }}}|D �cg c] }|j � �� }}t � }t � }d} |D ]6 \ }}|dk( r| ��|} �||vs�||vs�|dk( r|j |� �2|||< �8 t |j
� � }|j d� d�� g }
t |� D ]Z \ } �t �fd�|D � � r�d} |D ] \ }}�|k( s� |} n | r| } n | dk7 r�dk( rd } | ��D|
j || | | f� �\ |
j d
� � � |
j d � d�� |
D �
cg c] }
|
d
|
d f�� c}
S c c}}w c c}w c c}
w )a�
Return the offers that are acceptable according to the header.
The offers are returned in descending order of preference, where
preference is indicated by the qvalue of the item (content-coding,
"identity" or "*") in the header that matches the offer.
This uses the matching rules described in :rfc:`RFC 7231, section 5.3.4
<7231#section-5.3.4>`.
:param offers: ``iterable`` of ``str``s, where each ``str`` is a
content-coding or the string ``identity`` (the token
used to represent "no encoding")
:return: A list of tuples of the form (content-coding or "identity",
qvalue), in descending order of qvalue. Where two offers have
the same qvalue, they are returned in the same order as their
order in `offers`.
Use the string ``'identity'`` (without the quotes) in `offers` to
indicate an offer with no content-coding. From the RFC: 'If the
representation has no content-coding, then it is acceptable by default
unless specifically excluded by the Accept-Encoding field stating
either "identity;q=0" or "\*;q=0" without a more specific entry for
"identity".' The RFC does not specify the qvalue that should be
assigned to the representation/offer with no content-coding; this
implementation assigns it a qvalue of 1.0.
Nr� r c � � | d S rm r+ r s r ro z=AcceptEncodingValidHeader.acceptable_offers.<locals>.<lambda>( r� r Trq c 3 �( �K � | ] }�|k( �� � y �wr� r+ )r� r4 r� s �r r� z>AcceptEncodingValidHeader.acceptable_offers.<locals>.<genexpr>- r� r� �identityr c � � | d S r r+ r s r ro z=AcceptEncodingValidHeader.acceptable_offers.<locals>.<lambda>B r� r r c � � | d S rm r+ r s r ro z=AcceptEncodingValidHeader.acceptable_offers.<locals>.<lambda>F r� r r rg r� )r3 r� r4 r r� r� r� �not_acceptable_codingss�acceptable_codingssr� r� rc �matched_codings_qvaluer s ` r r z+AcceptEncodingValidHeader.acceptable_offers� s� �� �: @D�{�{�
�*;�7�F�W�]�]�_�f� %�
��
� 9?� ?�u�U�[�[�]� ?�� ?�"%�%� � "�f�� �� 0� :�O�G�V��#�~�"�*�&,�O�� 2�2�w�'�8(� �S�=�+�/�/��8�39�'��0� :� #�#6�#<�#<�#>� ?��� � �%=�t� �L� �� %�&7� 8� �L�E�5�� �2I�� � �%)� "�#6�
1�����G�#�-3�*��
1�
#�-<�*�$��+���0C�-0�*�%�1� �&�&��5�M�#9�5�(� �% �. � � �!9� �:� � � �!9�4� �H�/>�?�t��a��$�q�'�"�?�?��q
�� @��j @s � E4�E:� E?Nc �` � t j dt � d}|}d}|D ]� }t |t t
f� r|\ }}nd}| j D ]Y }|d } |d }
||
z } | |k r�| |k( r$|j d� | j d� k r�A| j | |� s�T| }|}| }�[ �� |S )a1
Return the best match from the sequence of `offers`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:meth:`AcceptEncodingValidHeader.best_match` uses its own algorithm
(one not specified in :rfc:`RFC 7231 <7231>`) to determine what is a
best match. The algorithm has many issues, and does not conform to
the RFC.
Each offer in `offers` is checked against each non-``q=0`` item
(content-coding/``identity``/``*``) in the header. If the two are a
match according to WebOb's old criterion for a match, the quality value
of the match is the qvalue of the item from the header multiplied by
the server quality value of the offer (if the server quality value is
not supplied, it is 1).
The offer in the match with the highest quality value is the best
match. If there is more than one match with the highest qvalue, the one
that shows up first in `offers` is the best match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` *codings*,
or a (*codings*, server quality value) ``tuple`` or
``list``, where *codings* is either a content-coding,
or the string ``identity`` (which represents *no
encoding*). ``str`` and ``tuple``/``list`` elements
may be mixed within the iterable.
:param default_match: (optional, any type) the value to be returned if
there is no match
:return: (``str``, or the type of `default_match`)
| The offer that is the best match. If there is no match, the
value of `default_match` is returned.
This method does not conform to :rfc:`RFC 7231, section 5.3.4
<7231#section-5.3.4>`, in that it does not correctly interpret ``*``::
>>> AcceptEncodingValidHeader('gzip;q=0, *').best_match(['gzip'])
'gzip'
and does not handle the ``identity`` token correctly::
>>> instance = AcceptEncodingValidHeader('gzip')
>>> instance.best_match(['identity']) is None
True
z�The behavior of AcceptEncodingValidHeader.best_match is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.rh r
rg r r� r1 r3 s r r: z$AcceptEncodingValidHeader.best_matchK s� � �l �
�
�
�
�
� � �"�
��
�� &�E��%�%�� �/�(-�%��~�!"�� �,�,�
&���A�w�� �q�'��#1�G�#;� �#�l�2� �%� �5�
"�'�'��,��
�
�3��?� ��?�?�4��/�#3�L�!&�J�!%�J�!
&� &�, �r c � � t j dt � d}| j D ]$ \ }}| j ||� s�t ||� }�& |xs dS )a�
Return quality value of given offer, or ``None`` if there is no match.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:param offer: (``str``) A content-coding, or ``identity``.
:return: (``float`` or ``None``)
| The quality value from the header item
(content-coding/``identity``/``*``) that matches the
`offer`, or ``None`` if there is no match.
The behavior of this method does not conform to :rfc:`RFC 7231, section
5.3.4<7231#section-5.3.4>`, in that it does not correctly interpret
``*``::
>>> AcceptEncodingValidHeader('gzip;q=0, *').quality('gzip')
1.0
and does not handle the ``identity`` token correctly::
>>> AcceptEncodingValidHeader('gzip').quality('identity') is None
True
z�The behavior of AcceptEncodingValidHeader.quality is currently being maintained for backward compatibility, but it will be deprecated in the future, as it does not conform to the RFC.r Nr< r s r r� z!AcceptEncodingValidHeader.quality� s^ � �8 �
�
�
K�
�
� ���{�{� &�G�D�!����t�U�+��E�1�
�� &� �}�� r r? r� )r6 r7 r8 r9 r@ r� r� r� r� r� r� rA r� r� r� r� r5 rB r� r r: r� r+ r r r9 r9 �
s� � � � �"� �"� � � � �
I�2�/
�b
� �K�! �F �D
�H�
� 6;�=�2<�0T@�nV�p& r r9 c �: � e Zd ZdZd� ZeZd� Zd� Zd� Zd d�Z d� Z
y)
� _AcceptEncodingInvalidOrNoHeadera)
Represent when an ``Accept-Encoding`` header is invalid or not in request.
This is the base class for the behaviour that
:class:`.AcceptEncodingInvalidHeader` and :class:`.AcceptEncodingNoHeader`
have in common.
:rfc:`7231` does not provide any guidance on what should happen if the
``AcceptEncoding`` header has an invalid value. This implementation
disregards the header when the header is invalid, so
:class:`.AcceptEncodingInvalidHeader` and :class:`.AcceptEncodingNoHeader`
have much behaviour in common.
c � � y)a8
Return whether ``self`` represents a valid ``Accept-Encoding`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``False``.
Fr+ r� s r r� z)_AcceptEncodingInvalidOrNoHeader.__bool__� r\ r c �8 � t j dt � y)a�
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of ``.__contains__`` for the ``Accept-Encoding``
classes is currently being maintained for backward compatibility,
but it will change in the future to better conform to the RFC.
:param offer: (``str``) a content-coding or ``identity`` offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
For this class, either there is no ``Accept-Encoding`` header in the
request, or the header is invalid, so any content-coding is acceptable,
and this always returns ``True``.
z�The behavior of .__contains__ for the Accept-Encoding classes is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.Tr^ rT s r r� z-_AcceptEncodingInvalidOrNoHeader.__contains__� r_ r c �L � t j dt � t d� S )a�
Return all the header items with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the (content-coding/``identity``/``*``) items
in the header with non-0 qvalues, in descending order of
qvalue. If two items have the same qvalue, they are returned
in the order of their positions in the header, from left to
right.
When there is no ``Accept-Encoding`` header in the request or the
header is invalid, there are no items in the header, so this always
returns an empty iterator.
z�The behavior of AcceptEncodingValidHeader.__iter__ is currently maintained for backward compatibility, but will change in the future.r+ ra r� s r r� z)_AcceptEncodingInvalidOrNoHeader.__iter__
s% � �& �
�
�
�
�
� �B�x�r c �0 � |D �cg c] }|df�� c}S c c}w )a�
Return the offers that are acceptable according to the header.
:param offers: ``iterable`` of ``str``s, where each ``str`` is a
content-coding or the string ``identity`` (the token
used to represent "no encoding")
:return: When the header is invalid, or there is no ``Accept-Encoding``
header in the request, all `offers` are considered acceptable,
so this method returns a list of (content-coding or
"identity", qvalue) tuples where each offer in `offers` is
paired with the qvalue of 1.0, in the same order as in
`offers`.
r r+ r s r r z2_AcceptEncodingInvalidOrNoHeader.acceptable_offers
s � � +1�1���� �1�1��1r Nc � � t j dt � d}|}|D ]* }t |t t
f� r|\ }}nd}||kD s�'|}|}�, |S )a�
Return the best match from the sequence of `offers`.
This is the ``.best_match()`` method for when the header is invalid or
not found in the request, corresponding to
:meth:`AcceptEncodingValidHeader.best_match`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptEncodingValidHeader.best_match`).
When the header is invalid, or there is no `Accept-Encoding` header in
the request, all `offers` are considered acceptable, so the best match
is the offer in `offers` with the highest server quality value (if the
server quality value is not supplied for a media type, it is 1).
If more than one offer in `offers` have the same highest server quality
value, then the one that shows up first in `offers` is the best match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` *codings*,
or a (*codings*, server quality value) ``tuple`` or
``list``, where *codings* is either a content-coding,
or the string ``identity`` (which represents *no
encoding*). ``str`` and ``tuple``/``list`` elements
may be mixed within the iterable.
:param default_match: (optional, any type) the value to be returned if
`offers` is empty.
:return: (``str``, or the type of `default_match`)
| The offer that has the highest server quality value. If
`offers` is empty, the value of `default_match` is returned.
z�The behavior of .best_match for the Accept-Encoding classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior is not specified in (and currently does not conform to) RFC 7231.rh rg rg rh s r r: z+_AcceptEncodingInvalidOrNoHeader.best_match-
sm � �N �
�
�
I�
�
� � �"�
�� '�E��%�$�� �/�!&���w���� �%� "�
� &� � '� �r c �8 � t j dt � y)a�
Return quality value of given offer, or ``None`` if there is no match.
This is the ``.quality()`` method for when the header is invalid or not
found in the request, corresponding to
:meth:`AcceptEncodingValidHeader.quality`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptEncodingValidHeader.quality`).
:param offer: (``str``) A content-coding, or ``identity``.
:return: (``float``) ``1.0``.
When the ``Accept-Encoding`` header is invalid or not in the request,
all offers are equally acceptable, so 1.0 is always returned.
z�The behavior of .quality for the Accept-Encoding classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior does not conform to RFC 7231.r r^ rT s r r� z(_AcceptEncodingInvalidOrNoHeader.qualityg
s � �( �
�
�
'�
�
� r r� r r+ r r r\ r\ � s- � � �
� �K��4�62� 8�tr r\ c �Z � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d
� Z
y ) r@ a&
Represent when there is no ``Accept-Encoding`` header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptEncodingNoHeader.__add__`).
c � � | j S rl r� r� s r r� z#AcceptEncodingNoHeader.header_value�
rm r c � � | j S ro r� r� s r r� z AcceptEncodingNoHeader.parsed�
rp r c �. � d| _ d| _ d| _ y)zE
Create an :class:`AcceptEncodingNoHeader` instance.
Nrr r� s r r� z AcceptEncodingNoHeader.__init__�
rs r c �" � | j � S r� ru r� s r r� zAcceptEncodingNoHeader.copy�
rv r c � � t |t � rt |j �� S t |t t f� r| j � S | j
| |�� S )aV
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with content-coding, ``identity`` or ``*`` ``str``'s as
keys, and qvalue ``float``'s as values
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (content-coding/``identity``/``*``, qvalue) ``tuple``
or ``list``
* an :class:`AcceptEncodingValidHeader`,
:class:`AcceptEncodingNoHeader`, or
:class:`AcceptEncodingInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an
:class:`AcceptEncodingValidHeader` instance, a new
:class:`AcceptEncodingValidHeader` instance with the valid header value
is returned.
If `other` is ``None``, an :class:`AcceptEncodingNoHeader` instance, an
invalid header value, or an :class:`AcceptEncodingInvalidHeader`
instance, a new :class:`AcceptEncodingNoHeader` instance is returned.
r� r� )rv r9 r� r@ rA r� rB r� s r r� z AcceptEncodingNoHeader.__add__�
s` � �6 �e� 6� 7�,�%�:L�:L�M� M� � �*�,G�H�
� �>�>�#� #��>�>��� ?�
�
r c �& � | j |�� S )z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptEncodingNoHeader.__add__`.
ry rz r� s r r� z AcceptEncodingNoHeader.__radd__�
r{ r c �L � dj | j j � S r} r~ r� s r r� z AcceptEncodingNoHeader.__repr__�
r r c � � yr� r+ r� s r r5 z AcceptEncodingNoHeader.__str__�
r� r c � � |�| j � S | j |�� } t |�� S # t $ r | j � cY S w xY wr� )r� r� r9 rV r� s r rB zAAcceptEncodingNoHeader._add_instance_and_non_accept_encoding_type�
sU � � �=��>�>�#� #� !� =� =�E� =� J�� $�,�:L�M� M��� $��>�>�#� #� $�r� N�r6 r7 r8 r9 r@ r� r� r� r� r� r� r� r5 rB r+ r r r@ r@ �
sS � �� �"� �"� � � � �$� �%
�N)�6�(� $r r@ c �^ � e Zd ZdZed� � Zed� � Zd� Zd� Zd� Z d� Z
d� Z d � Z d d
�Z
y )
rA ak
Represent an invalid ``Accept-Encoding`` header.
An invalid header is one that does not conform to
:rfc:`7231#section-5.3.4`.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept-Encoding`` header has an invalid value. This implementation
disregards the header, and treats it as if there is no ``Accept-Encoding``
header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptEncodingInvalidHeader.__add__`).
c � � | j S r� r� r� s r r� z(AcceptEncodingInvalidHeader.header_value r� r c � � | j S r� r� r� s r r� z"AcceptEncodingInvalidHeader.parsed rp r c �. � || _ d| _ d| _ y)zJ
Create an :class:`AcceptEncodingInvalidHeader` instance.
Nrr r� s r r� z$AcceptEncodingInvalidHeader.__init__ r� r c �8 � | j | j � S r� r� r� s r r� z AcceptEncodingInvalidHeader.copy r� r c � � t |t � rt |j �� S t |t t f� r
t � S | j | |�� S )a[
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with content-coding, ``identity`` or ``*`` ``str``'s as
keys, and qvalue ``float``'s as values
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (content-coding/``identity``/``*``, qvalue) ``tuple``
or ``list``
* an :class:`AcceptEncodingValidHeader`,
:class:`AcceptEncodingNoHeader`, or
:class:`AcceptEncodingInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an
:class:`AcceptEncodingValidHeader` instance, then a new
:class:`AcceptEncodingValidHeader` instance with the valid header value
is returned.
If `other` is ``None``, an :class:`AcceptEncodingNoHeader` instance, an
invalid header value, or an :class:`AcceptEncodingInvalidHeader`
instance, a new :class:`AcceptEncodingNoHeader` instance is returned.
r� r� )rv r9 r� r@ rA rB r� s r r� z#AcceptEncodingInvalidHeader.__add__ s\ � �6 �e� 6� 7�,�%�:L�:L�M� M� � �*�,G�H�
� *�+� +��>�>��� ?�
�
r c �* � | j | |d�� S rH rI r� s r r� z$AcceptEncodingInvalidHeader.__radd__F rJ r c �L � dj | j j � S r} r~ r� s r r� z$AcceptEncodingInvalidHeader.__repr__P r r c � � yr� r+ r� s r r5 z#AcceptEncodingInvalidHeader.__str__V r� r c � � |�
t � S | j |�� } t |�� S # t $ r
t � cY S w xY wr� )r@ r� r9 rV r� s r rB zFAcceptEncodingInvalidHeader._add_instance_and_non_accept_encoding_typeZ sO � � �=�)�+� +� !� =� =�E� =� J�� ,�,�:L�M� M��� ,�)�+� +� ,�r� Nr? rm r+ r r rA rA �
sX � �� �"� �"� � � � �$�2�%
�N
�6� (�
6;� ,r rA c � � | �
t � S t | t � r| j � S t | �� S # t
$ r t
| �� cY S w xY w)a
Create an object representing the ``Accept-Encoding`` header in a request.
:param header_value: (``str``) header value
:return: If `header_value` is ``None``, an :class:`AcceptEncodingNoHeader`
instance.
| If `header_value` is a valid ``Accept-Encoding`` header, an
:class:`AcceptEncodingValidHeader` instance.
| If `header_value` is an invalid ``Accept-Encoding`` header, an
:class:`AcceptEncodingInvalidHeader` instance.
r� )r@ rv r. r� r9 rV rA r� s r r? r? h �Y � � ��%�'�'��,��/�� � �"�"�F�(�l�C�C�� � F�*� �E�E�F�r� c �p ��� d} d��fd�}��fd�}�fd��t ||�t j | � � S )Na�
Property representing the ``Accept-Encoding`` header.
(:rfc:`RFC 7231, section 5.3.4 <7231#section-5.3.4>`)
The header value in the request environ is parsed and a new object
representing the header is created every time we *get* the value of the
property. (*set* and *del* change the header value in the request
environ, and do not involve parsing.)
�HTTP_ACCEPT_ENCODINGc �N �� t | j j �� �� S r� )r? r� r� r� s �r r z&accept_encoding_property.<locals>.fget� �" �� �,� � � �,�,�[�9�
�
r c �� �� |�t |t � r
�| �� yt |t t f� r
|j }nt
j
|�� }|| j �< y)a�
Set the corresponding key in the request environ.
`value` can be:
* ``None``
* a ``str`` header value
* a ``dict``, with content-coding, ``identity`` or ``*`` ``str``'s as
keys, and qvalue ``float``'s as values
* a ``tuple`` or ``list``, where each item is either a header element
``str``, or a (content-coding/``identity``/``*``, qvalue) ``tuple``
or ``list``
* an :class:`AcceptEncodingValidHeader`,
:class:`AcceptEncodingNoHeader`, or
:class:`AcceptEncodingInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
Nr� r� )rv r@ r9 rA r� r. r� r� r� s ��r r� z&accept_encoding_property.<locals>.fset� sf �� �$ �=�J�u�.D� E� �� !���1�3N�O�� %� 1� 1� � -� I� I� � J� � � ,8�G�O�O�K� (r c �@ �� | j �= y# t $ r Y yw xY wr� r� r� s �r r� z&accept_encoding_property.<locals>.fdel� r� r� r� r� s @@r �accept_encoding_propertyr� � s< �� � �C� )�K�
� 8�>� �D�$��h�o�o�c�&:� ;�;r c �| � e Zd ZdZdZ ee�� Z ej e� Z e
e�� Z e d� � Z
e d� � Zy)�AcceptLanguagez�
Represent an ``Accept-Language`` header.
Base class for :class:`AcceptLanguageValidHeader`,
:class:`AcceptLanguageNoHeader`, and :class:`AcceptLanguageInvalidHeader`.
z*\*|(?:[A-Za-z]{1,8}(?:-[A-Za-z0-9]{1,8})*)r
r# c �` � t |t � r|}|S t |d� r t |j � d� d�� }t |t
t f� rOg }|D ]5 }t |t
t f� r t |�� }|j |� �7 dj |� }|S t |� }|S )Nrk c � � | d S rm r+ rn s r ro z<AcceptLanguage._python_value_to_header_str.<locals>.<lambda>� rp r Trq r� ru r� )rG r4 r� r� r s r r� z*AcceptLanguage._python_value_to_header_str� s� � � �e�S� !� �J�& ��# �u�g�&� ��K�K�M�,� ���
�%�%�� �/��� $� +�G�!�'�E�4�=�9�"E�!(�#�� �M�M�'�*� +� "�Y�Y�v� .�
� �� !��Z�
��r c �l � � � j j |� � t d� �� fd�} ||�� S )ar
Parse an ``Accept-Language`` header.
:param value: (``str``) header value
:return: If `value` is a valid ``Accept-Language`` header, returns an
iterator of (language range, quality value) tuples, as parsed
from the header from left to right.
:raises ValueError: if `value` is an invalid header
z,Invalid value for an Accept-Language header.c 3 � �K � �j j | � D ]9 }|j d� }|j d� }|r t |� nd}||f�� �; y �wr� )� lang_range_n_weight_compiled_rer� r� ry )r4 rF �
lang_ranger rG s �r r� z'AcceptLanguage.parse.<locals>.generator s[ �� �� ��3�3�<�<�U�C�
+�� #�[�[��^�
� ���Q� ��*0��v� �c��!�6�*�*�
+�r� r� )�accept_language_compiled_rerF rV r� s ` r r� zAcceptLanguage.parse� s: �� � � *� *� 0� 0�� 7� ?� � K�L� L� +� �u�%�%r N)r6 r7 r8 r9 �
lang_range_rer �lang_range_n_weight_rer r! r� r( r� r� r� r� r+ r r r� r� � sf � �� � � /�}� E��&0�b�j�j�1G�&H�#�">�)�#� � �� ��. �&� �&r r� c � � e Zd ZdZd� Zd� Zed� � Zed� � Zd� Z d� Z
e
Z d� Z d � Z
d
� Zd � Zd � Z dd
�Zd� Zd� Zdd�Z dd�Zd� Zy)�AcceptLanguageValidHeadera�
Represent a valid ``Accept-Language`` header.
A valid header is one that conforms to :rfc:`RFC 7231, section 5.3.5
<7231#section-5.3.5>`.
We take the reference from the ``language-range`` syntax rule in :rfc:`RFC
7231, section 5.3.5 <7231#section-5.3.5>` to :rfc:`RFC 4647, section 2.1
<4647#section-2.1>` to mean that only basic language ranges (and not
extended language ranges) are expected in the ``Accept-Language`` header.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptLanguageValidHeader.__add__`).
c � � || _ t | j |� � | _ | j D �cg c]
}|d s� |�� c}| _ yc c}w )z�
Create an :class:`AcceptLanguageValidHeader` instance.
:param header_value: (``str``) header value.
:raises ValueError: if `header_value` is an invalid value for an
``Accept-Language`` header.
rg Nr� r� s r r� z"AcceptLanguageValidHeader.__init__ r� r� c �8 � | j | j � S r� r� r� s r r� z AcceptLanguageValidHeader.copy+ r� r c � � | j S r� r� r� s r r� z&AcceptLanguageValidHeader.header_value2 r� r c � � | j S )z~
(``list`` or ``None``) Parsed form of the header.
A list of (language range, quality value) tuples.
r� r� s r r� z AcceptLanguageValidHeader.parsed7 rp r c � � t |t � r&t | j dz |j z �� S t |t t
f� r | j
| j �� S | j | |�� S )a�
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str``
* a ``dict``, with language ranges as keys and qvalues as values
* a ``tuple`` or ``list``, of language range ``str``'s or of ``tuple``
or ``list`` (language range, qvalue) pairs (``str``'s and pairs can
be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptLanguageValidHeader`,
:class:`AcceptLanguageNoHeader`, or
:class:`AcceptLanguageInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or another
:class:`AcceptLanguageValidHeader` instance, the two header values are
joined with ``', '``, and a new :class:`AcceptLanguageValidHeader`
instance with the new header value is returned.
If `other` is ``None``, an :class:`AcceptLanguageNoHeader` instance, an
invalid header value, or an :class:`AcceptLanguageInvalidHeader`
instance, a new :class:`AcceptLanguageValidHeader` instance with the
same header value as ``self`` is returned.
ru r� r� )rv r� � create_accept_language_headerr� �AcceptLanguageNoHeader�AcceptLanguageInvalidHeaderr� �*_add_instance_and_non_accept_language_typer� s r r� z!AcceptLanguageValidHeader.__add__@ s� � �6 �e� 6� 7�0� !� .� .�� 5��8J�8J� J��
� � �*�,G�H�
� �>�>�t�/@�/@�>�A� A��>�>��� ?�
�
r c � � y)a7
Return whether ``self`` represents a valid ``Accept-Language`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``True``.
Tr+ r� s r rA z%AcceptLanguageValidHeader.__nonzero__i r� r c � � t j dt � | j D ] \ }}| j ||� s� y y)a'
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of :meth:`AcceptLanguageValidHeader.__contains__` is
currently being maintained for backward compatibility, but it will
change in the future to better conform to the RFC.
What is 'acceptable' depends on the needs of your application.
:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>` suggests three
matching schemes from :rfc:`RFC 4647 <4647>`, two of which WebOb
supports with :meth:`AcceptLanguageValidHeader.basic_filtering` and
:meth:`AcceptLanguageValidHeader.lookup` (we interpret the RFC to
mean that Extended Filtering cannot apply for the
``Accept-Language`` header, as the header only accepts basic
language ranges.) If these are not suitable for the needs of your
application, you may need to write your own matching using
:attr:`AcceptLanguageValidHeader.parsed`.
:param offer: (``str``) language tag offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
This uses the old criterion of a match in
:meth:`AcceptLanguageValidHeader._old_match`, which does not conform to
:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>` or any of the
matching schemes suggested there. It also does not properly take into
account ranges with ``q=0`` in the header::
>>> 'en-gb' in AcceptLanguageValidHeader('en, en-gb;q=0')
True
>>> 'en' in AcceptLanguageValidHeader('en;q=0, *')
True
(See the docstring for :meth:`AcceptLanguageValidHeader._old_match` for
other problems with the old criterion for a match.)
z�The behavior of AcceptLanguageValidHeader.__contains__ is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.TFr� r� s r r� z&AcceptLanguageValidHeader.__contains__v sM � �N �
�
�
F�
�
� "� 1� 1� �M�D�'����t�U�+�� � r c # � K � t j dt � t | j d� d�� D ] \ }}|�� � y�w)a=
Return all the ranges with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the language ranges in the header with non-0
qvalues, in descending order of qvalue. If two ranges have the
same qvalue, they are returned in the order of their positions
in the header, from left to right.
Please note that this is a simple filter for the ranges in the header
with non-0 qvalues, and is not necessarily the same as what the client
prefers, e.g. ``'en-gb;q=0, *'`` means 'everything but British
English', but ``list(instance)`` would return only ``['*']``.
r� c � � | d S rm r+ r� s r ro z4AcceptLanguageValidHeader.__iter__.<locals>.<lambda>� r� r Trq Nr� r� s r r� z"AcceptLanguageValidHeader.__iter__� sN � �� �& �
�
�
�
�
� � � � � ��
� �D�A�q�
�G� �r� c �* � | j | |d�� S �z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptLanguageValidHeader.__add__`.
Tr� �r� r� s r r� z"AcceptLanguageValidHeader.__radd__� rJ r c �` � dj | j j t | � � S r� r� r� s r r� z"AcceptLanguageValidHeader.__repr__� r� r c �F � dj d� | j D � � S )z�
Return a tidied up version of the header value.
e.g. If the ``header_value`` is ``', \t,de;q=0.000 \t, es;q=1.000, zh,
jp;q=0.210 ,'``, ``str(instance)`` returns ``'de;q=0, es, zh,
jp;q=0.21'``.
ru c 3 �4 K � | ] }t |� � �� � y�wr� r� r� s r r� z4AcceptLanguageValidHeader.__str__.<locals>.<genexpr>� r� r� r r� s r r5 z!AcceptLanguageValidHeader.__str__� r� r c �N � |s | j |j �� S | j |�� } | j |�� |r|dz |j z n|j dz |z }| j |�� S # t $ r | j |j �� cY S w xY wr� r r s r r� zDAcceptLanguageValidHeader._add_instance_and_non_accept_language_type� r� r� c �� � |j dd� j � }|j � }|dk( xs7 ||k( xs0 |j d� d |k( xs ||j d� d k( S )a6
Return whether a language tag matches a language range.
.. warning::
This is maintained for backward compatibility, and will be
deprecated in the future.
This method was WebOb's old criterion for deciding whether a language
tag matches a language range, used in
- :meth:`AcceptLanguageValidHeader.__contains__`
- :meth:`AcceptLanguageValidHeader.best_match`
- :meth:`AcceptLanguageValidHeader.quality`
It does not conform to :rfc:`RFC 7231, section 5.3.5
<7231#section-5.3.5>`, or any of the matching schemes suggested there.
:param mask: (``str``)
| language range
:param item: (``str``)
| language tag. Subtags in language tags are separated by
``-`` (hyphen). If there are underscores (``_``) in this
argument, they will be converted to hyphens before
checking the match.
:return: (``bool``) whether the tag in `item` matches the range in
`mask`.
`mask` and `item` are a match if:
- ``mask == *``.
- ``mask == item``.
- If the first subtag of `item` equals `mask`, or if the first subtag
of `mask` equals `item`.
This means that::
>>> instance._old_match(mask='en-gb', item='en')
True
>>> instance._old_match(mask='en', item='en-gb')
True
Which is different from any of the matching schemes suggested in
:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>`, in that none of
those schemes match both more *and* less specific tags.
However, this method appears to be only designed for language tags
and ranges with at most two subtags. So with an `item`/language tag
with more than two subtags like ``zh-Hans-CN``::
>>> instance._old_match(mask='zh', item='zh-Hans-CN')
True
>>> instance._old_match(mask='zh-Hans', item='zh-Hans-CN')
False
From commit history, this does not appear to have been from a
decision to match only the first subtag, but rather because only
language ranges and tags with at most two subtags were expected.
rI �-r� r )rD r� r� )r3 r r s r r� z$AcceptLanguageValidHeader._old_match� sw � �~ �|�|�C��%�+�+�-���z�z�|���� � *��t�|�*��z�z�#��q�!�T�)�*� �t�z�z�#��q�)�)�
r c � ��� | j D ��cg c] \ }}|j � |f�� }}}|D �cg c] }|j � �� }}t � }t � }d} t |� D ]= \ }
\ }}|dk( r| ��|} |
} �||vs�||vs� |dk( r|j |� �7||
f||< �? |j
� D ���
cg c]
\ }\ }}
|||
f�� }}}}
|j d� �� |j d� d�� d � �g } t |� D ]X \ }
�t ��fd
�|D � � r� d}|D ] \ }}}
��|� � s�|}|
} n | r| } }|��B| j ||
|f� �Z | j d � �� | j d
� d�� | D �cg c] }|d |d f�� c}S c c}}w c c}w c c}
}}w c c}w )ax
Return the tags that match the header, using Basic Filtering.
This is an implementation of the Basic Filtering matching scheme,
suggested as a matching scheme for the ``Accept-Language`` header in
:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>`, and defined in
:rfc:`RFC 4647, section 3.3.1 <4647#section-3.3.1>`. It filters the
tags in the `language_tags` argument and returns the ones that match
the header according to the matching scheme.
:param language_tags: (``iterable``) language tags
:return: A list of tuples of the form (language tag, qvalue), in
descending order of qvalue. If two or more tags have the same
qvalue, they are returned in the same order as that in the
header of the ranges they matched. If the matched range is the
same for two or more tags (i.e. their matched ranges have the
same qvalue and the same position in the header), then they
are returned in the same order as that in the `language_tags`
argument. If `language_tags` is unordered, e.g. if it is a set
or a dict, then that order may not be reliable.
For each tag in `language_tags`:
1. If the tag matches a non-``*`` language range in the header with
``q=0`` (meaning "not acceptable", see :rfc:`RFC 7231, section 5.3.1
<7231#section-5.3.1>`), the tag is filtered out.
2. The non-``*`` language ranges in the header that do not have ``q=0``
are considered in descending order of qvalue; where two or more
language ranges have the same qvalue, they are considered in the
order in which they appear in the header.
3. A language range 'matches a particular language tag if, in a
case-insensitive comparison, it exactly equals the tag, or if it
exactly equals a prefix of the tag such that the first character
following the prefix is "-".' (:rfc:`RFC 4647, section 3.3.1
<4647#section-3.3.1>`)
4. If the tag does not match any of the non-``*`` language ranges, and
there is a ``*`` language range in the header, then if the ``*``
language range has ``q=0``, the language tag is filtered out,
otherwise the tag is considered a match.
(If a range (``*`` or non-``*``) appears in the header more than once
-- this would not make sense, but is nonetheless a valid header
according to the RFC -- the first in the header is used for matching,
and the others are ignored.)
Nr� r c � � | d S r r+ r s r ro z;AcceptLanguageValidHeader.basic_filtering.<locals>.<lambda>� �
� �&��)� r r c � � | d S rm r+ r s r ro z;AcceptLanguageValidHeader.basic_filtering.<locals>.<lambda>� r� r Trq c �8 � | |k( xs | j |dz � S )Nr� )r` ��tag�range_s r rF z8AcceptLanguageValidHeader.basic_filtering.<locals>.match� s � �
�6�M�B�c�n�n�V�c�\�&B� Br c 3 �2 �K � | ] } ��|� � �� � y�w)r� Nr+ )r� r� rF r� s ��r r� z<AcceptLanguageValidHeader.basic_filtering.<locals>.<genexpr>� s# �� �� � �� �#�f�-�-��s �r� c � � | d S r r+ r s r ro z;AcceptLanguageValidHeader.basic_filtering.<locals>.<lambda>� �
� �f�Q�i� r c � � | d S rm r+ r s r ro z;AcceptLanguageValidHeader.basic_filtering.<locals>.<lambda>� r� r r rg )
r� r� r� r� r_ r� rk r# r� r{ )r3 �
language_tagsr� r r� r� �lowercased_tags�not_acceptable_ranges�acceptable_rangesr� �position_in_header�asterisk_position�
filtered_tagsrc �matched_range_qvalue�matched_range_positionr rF s ` @r �basic_filteringz)AcceptLanguageValidHeader.basic_filtering> sX �� �l >B�[�[�
�)9�&�&�V�\�\�^�V� $�
��
� 3@�@�3�3�9�9�;�@��@� #�� � �F�� ��4=� �5
� M� 0� � 0��� ��}�"�*�&,�O�(:�%�� /�/�F�%�5&� �S�=�)�-�-�f�5�17�9K�0L�%�f�-� M�& !�&�&�(�
�
�4��4��!3� �V� /� 0�
��
� � � �#;� �<�� � �#;�T� �J� C� �
�#�O�4� " �J�E�3�� � 3�� � �#'� �6G�
?�2��� 2� �S��0�+1�(�-?�*��
?� #� ,;�(�->�*�#�/� �$�$�!�%�(�*>�*�&� �?" �J ��� 7��8�
��� 7���F�/<�=�t��a��$�q�'�"�=�=��y
�� A��,
��F >s � F*�F0�F5�F<Nc �R � t j dt � d}|}d}|D ]� }t |t t
f� r|\ }}nd}| j D ]R \ }} || z }
|
|k r�|
|k( r$|j d� |j d� k r�:| j ||� s�M|
}|}|}�T �� |S )a�
Return the best match from the sequence of language tag `offers`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:meth:`AcceptLanguageValidHeader.best_match` uses its own algorithm
(one not specified in :rfc:`RFC 7231 <7231>`) to determine what is a
best match. The algorithm has many issues, and does not conform to
:rfc:`RFC 7231 <7231>`.
:meth:`AcceptLanguageValidHeader.lookup` is a possible alternative
for finding a best match -- it conforms to, and is suggested as a
matching scheme for the ``Accept-Language`` header in, :rfc:`RFC
7231, section 5.3.5 <7231#section-5.3.5>` -- but please be aware
that there are differences in how it determines what is a best
match. If that is not suitable for the needs of your application,
you may need to write your own matching using
:attr:`AcceptLanguageValidHeader.parsed`.
Each language tag in `offers` is checked against each non-0 range in
the header. If the two are a match according to WebOb's old criterion
for a match, the quality value of the match is the qvalue of the
language range from the header multiplied by the server quality value
of the offer (if the server quality value is not supplied, it is 1).
The offer in the match with the highest quality value is the best
match. If there is more than one match with the highest qvalue, the
match where the language range has a lower number of '*'s is the best
match. If the two have the same number of '*'s, the one that shows up
first in `offers` is the best match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` language
tag, or a (language tag, server quality value)
``tuple`` or ``list``. (The two may be mixed in the
iterable.)
:param default_match: (optional, any type) the value to be returned if
there is no match
:return: (``str``, or the type of `default_match`)
| The language tag that is the best match. If there is no
match, the value of `default_match` is returned.
**Issues**:
- Incorrect tiebreaking when quality values of two matches are the same
(https://github.com/Pylons/webob/issues/256)::
>>> header = AcceptLanguageValidHeader(
... header_value='en-gb;q=1, en;q=0.8'
... )
>>> header.best_match(offers=['en', 'en-GB'])
'en'
>>> header.best_match(offers=['en-GB', 'en'])
'en-GB'
>>> header = AcceptLanguageValidHeader(header_value='en-gb, en')
>>> header.best_match(offers=['en', 'en-gb'])
'en'
>>> header.best_match(offers=['en-gb', 'en'])
'en-gb'
- Incorrect handling of ``q=0``::
>>> header = AcceptLanguageValidHeader(header_value='en;q=0, *')
>>> header.best_match(offers=['en'])
'en'
>>> header = AcceptLanguageValidHeader(header_value='fr, en;q=0')
>>> header.best_match(offers=['en-gb'], default_match='en')
'en'
- Matching only takes into account the first subtag when matching a
range with more specific or less specific tags::
>>> header = AcceptLanguageValidHeader(header_value='zh')
>>> header.best_match(offers=['zh-Hans-CN'])
'zh-Hans-CN'
>>> header = AcceptLanguageValidHeader(header_value='zh-Hans')
>>> header.best_match(offers=['zh-Hans-CN'])
>>> header.best_match(offers=['zh-Hans-CN']) is None
True
>>> header = AcceptLanguageValidHeader(header_value='zh-Hans-CN')
>>> header.best_match(offers=['zh'])
'zh'
>>> header.best_match(offers=['zh-Hans'])
>>> header.best_match(offers=['zh-Hans']) is None
True
z�The behavior of AcceptLanguageValidHeader.best_match is currently being maintained for backward compatibility, but it will be deprecated in the future as it does not conform to the RFC.rh r
rg r� r1 r s r r: z$AcceptLanguageValidHeader.best_match� s� � �F �
�
�
�
�
� � �"�
��
� � &�E��%�%�� �/�(-�%��~�!"��!%�!5�!5�
&�
��g�#1�G�#;� �#�l�2� �%� �5� "�'�'��,��
�
�3��?� � �?�?�4��/�#3�L�!&�J�!%�J�/
&� &�: �r c �� ���� |�
|� t d� �|dk( r t d� �t | j � }|�g �g }d}d}|D ]O \ } }
|
dk( r(| dk( rd}��j | j � � �3|s| dk( rd}�=|j | |
f� �Q |j
d� d�� |D � cg c] } | d �� }} �D � cg c] } | j � �� c} ����fd
�}
|D ] } |
| j � � � }|�� |c S |s7|� |j � } |
|� � }|�|S |�|j � }|�vr|S |� S c c} w c c} w # t $ r |cY S w xY w) aP
Return the language tag that best matches the header, using Lookup.
This is an implementation of the Lookup matching scheme,
suggested as a matching scheme for the ``Accept-Language`` header in
:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>`, and described in
:rfc:`RFC 4647, section 3.4 <4647#section-3.4>`.
Each language range in the header is considered in turn, by descending
order of qvalue; where qvalues are tied, ranges are considered from
left to right.
Each language range in the header represents the most specific tag that
is an acceptable match: Lookup progressively truncates subtags from the
end of the range until a matching language tag is found. An example is
given in :rfc:`RFC 4647, section 3.4 <4647#section-3.4>`, under
"Example of a Lookup Fallback Pattern":
::
Range to match: zh-Hant-CN-x-private1-private2
1. zh-Hant-CN-x-private1-private2
2. zh-Hant-CN-x-private1
3. zh-Hant-CN
4. zh-Hant
5. zh
6. (default)
:param language_tags: (``iterable``) language tags
:param default_range: (optional, ``None`` or ``str``)
| If Lookup finds no match using the ranges in
the header, and this argument is not None,
Lookup will next attempt to match the range in
this argument, using the same subtag
truncation.
| `default_range` cannot be '*', as '*' is
skipped in Lookup. See :ref:`note
<acceptparse-lookup-asterisk-note>`.
| This parameter corresponds to the functionality
described in :rfc:`RFC 4647, section 3.4.1
<4647#section-3.4.1>`, in the paragraph
starting with "One common way to provide for a
default is to allow a specific language range
to be set as the default..."
:param default_tag: (optional, ``None`` or ``str``)
| At least one of `default_tag` or `default` must
be supplied as an argument to the method, to
define the defaulting behaviour.
| If Lookup finds no match using the ranges in the
header and `default_range`, this argument is not
``None``, and it does not match any range in the
header with ``q=0`` (exactly, with no subtag
truncation), then this value is returned.
| This parameter corresponds to "return a
particular language tag designated for the
operation", one of the examples of "defaulting
behavior" described in :rfc:`RFC 4647, section
3.4.1 <4647#section-3.4.1>`.
:param default: (optional, ``None`` or any type, including a callable)
| At least one of `default_tag` or `default` must be
supplied as an argument to the method, to define the
defaulting behaviour.
| If Lookup finds no match using the ranges in the
header and `default_range`, and `default_tag` is
``None`` or not acceptable because it matches a
``q=0`` range in the header, then Lookup will next
examine the `default` argument.
| If `default` is a callable, it will be called, and
the callable's return value will be returned.
| If `default` is not a callable, the value itself will
be returned.
| The difference between supplying a ``str`` to
`default_tag` and `default` is that `default_tag` is
checked against ``q=0`` ranges in the header to see
if it matches one of the ranges specified as not
acceptable, whereas a ``str`` for the `default`
argument is simply returned.
| This parameter corresponds to the "defaulting
behavior" described in :rfc:`RFC 4647, section 3.4.1
<4647#section-3.4.1>`
:return: (``str``, ``None``, or any type)
| The best match according to the Lookup matching scheme, or a
return value from one of the default arguments.
**Notes**:
.. _acceptparse-lookup-asterisk-note:
- Lookup's behaviour with '*' language ranges in the header may be
surprising. From :rfc:`RFC 4647, section 3.4 <4647#section-3.4>`:
In the lookup scheme, this range does not convey enough
information by itself to determine which language tag is most
appropriate, since it matches everything. If the language range
"*" is followed by other language ranges, it is skipped. If the
language range "*" is the only one in the language priority list
or if no other language range follows, the default value is
computed and returned.
So
::
>>> header = AcceptLanguageValidHeader('de, zh, *')
>>> header.lookup(language_tags=['ja', 'en'], default='default')
'default'
- Any tags in `language_tags` and `default_tag` and any tag matched
during the subtag truncation search for `default_range`, that are an
exact match for a non-``*`` range with ``q=0`` in the header, are
considered not acceptable and ruled out.
- If there is a ``*;q=0`` in the header, then `default_range` and
`default_tag` have no effect, as ``*;q=0`` means that all languages
not already matched by other ranges within the header are
unacceptable.
�:`default_tag` and `default` arguments cannot both be None.r� zdefault_range cannot be *.Fr Tc � � | d S rm r+ r s r ro z2AcceptLanguageValidHeader.lookup.<locals>.<lambda>& r� r rq r c �^ �� | j d� } t �� D ] \ }}|�v r� || k( s��| c S |d }t |� dk( r1|j � s|j � r|j
d� |j
d� dj |� } ��# t $ r Y y w xY w)Nr� ���rg rh )r� r_ �
IndexError�len�isdigit�isalpha�popr )r� �subtagsrc r� �subtag_before_this� lowered_tagsr� �tagss ���r r: z4AcceptLanguageValidHeader.lookup.<locals>.best_match- s� �� � �l�l�3�'�G��"+�L�"9� +�J�E�3�� 3�3� � �f�}� #�E�{�*� +� �)0���&� �)�*�a�/�&�.�.�0�&�.�.�0��K�K��O�� � �B�� ���'�*��9 ��& "� ���s �B � B,�+B,)r� )rL rV r~ r� r{ r� r# )r3 r� �
default_range� default_tag�defaultr� r� �asterisk_non0_found�asterisk_q0_foundr� r r� r� r: rF �lowered_default_range�lowered_default_tagr� r� r� s @@@r �lookupz AcceptLanguageValidHeader.lookupp s� �� �T � �7�?��L��
� �C� � � 9�:� :��d�k�k�"�� �� "� � �� #�� "�� %� ;�N�F�F���}��S�=�(,�%�)�0�0�� � � �@�&�6�S�=�&*�#� "�(�(�&�&�)9�:� ;� � � �#;�T� �J� 6G� G�6�V�A�Y� G�� G�/3�4��� � � �4� � +�@ (� �F� �f�l�l�n�5�E�� � � � �
!� �(�(5�(;�(;�(=�%�"�*?�@���$� �L��&�&1�&7�&7�&9�#�&�.C�C�&�&� ��9� ��k H��4��j � ��N� �s �. E� E �?E � E � E c � � t j dt � d}| j D ]$ \ }}| j ||� s�t ||� }�& |xs dS )a�
Return quality value of given offer, or ``None`` if there is no match.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future.
:meth:`AcceptLanguageValidHeader.quality` uses its own algorithm
(one not specified in :rfc:`RFC 7231 <7231>`) to determine what is a
best match. The algorithm has many issues, and does not conform to
:rfc:`RFC 7231 <7231>`.
What should be considered a match depends on the needs of your
application (for example, should a language range in the header
match a more specific language tag offer, or a less specific tag
offer?) :rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>` suggests
three matching schemes from :rfc:`RFC 4647 <4647>`, two of which
WebOb supports with
:meth:`AcceptLanguageValidHeader.basic_filtering` and
:meth:`AcceptLanguageValidHeader.lookup` (we interpret the RFC to
mean that Extended Filtering cannot apply for the
``Accept-Language`` header, as the header only accepts basic
language ranges.) :meth:`AcceptLanguageValidHeader.basic_filtering`
returns quality values with the matched language tags.
:meth:`AcceptLanguageValidHeader.lookup` returns a language tag
without the quality value, but the quality value is less likely to
be useful when we are looking for a best match.
If these are not suitable or sufficient for the needs of your
application, you may need to write your own matching using
:attr:`AcceptLanguageValidHeader.parsed`.
:param offer: (``str``) language tag offer
:return: (``float`` or ``None``)
| The highest quality value from the language range(s) that
match the `offer`, or ``None`` if there is no match.
**Issues**:
- Incorrect handling of ``q=0`` and ``*``::
>>> header = AcceptLanguageValidHeader(header_value='en;q=0, *')
>>> header.quality(offer='en')
1.0
- Matching only takes into account the first subtag when matching a
range with more specific or less specific tags::
>>> header = AcceptLanguageValidHeader(header_value='zh')
>>> header.quality(offer='zh-Hans-CN')
1.0
>>> header = AcceptLanguageValidHeader(header_value='zh-Hans')
>>> header.quality(offer='zh-Hans-CN')
>>> header.quality(offer='zh-Hans-CN') is None
True
>>> header = AcceptLanguageValidHeader(header_value='zh-Hans-CN')
>>> header.quality(offer='zh')
1.0
>>> header.quality(offer='zh-Hans')
>>> header.quality(offer='zh-Hans') is None
True
z�The behavior of AcceptLanguageValidHeader.quality iscurrently being maintained for backward compatibility, but it will be deprecated in the future as it does not conform to the RFC.r Nr< r s r r� z!AcceptLanguageValidHeader.qualityc s^ � �H �
�
�
�
�
� ���{�{� &�G�D�!����t�U�+��E�1�
�� &� �}�� r r? r� )NNN)r6 r7 r8 r9 r� r� r@ r� r� r� rA r� r� r� r� r� r5 r� r� r� r: r� r� r+ r r r� r�
s� � ��
I�2� �"� �"� � � � �'
�R
� �H�0�d �B
�H�
� 6;�=�(E
�NQ>�FM�` >B��q�fO r r� c �F � e Zd ZdZd� ZeZd� Zd� Zd� Zd
d�Z d d�Z
d � Z y) � _AcceptLanguageInvalidOrNoHeadera*
Represent when an ``Accept-Language`` header is invalid or not in request.
This is the base class for the behaviour that
:class:`.AcceptLanguageInvalidHeader` and :class:`.AcceptLanguageNoHeader`
have in common.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept-Language`` header has an invalid value. This implementation
disregards the header when the header is invalid, so
:class:`.AcceptLanguageInvalidHeader` and :class:`.AcceptLanguageNoHeader`
have much behaviour in common.
c � � y)a8
Return whether ``self`` represents a valid ``Accept-Language`` header.
Return ``True`` if ``self`` represents a valid header, and ``False`` if
it represents an invalid header, or the header not being in the
request.
For this class, it always returns ``False``.
Fr+ r� s r rA z,_AcceptLanguageInvalidOrNoHeader.__nonzero__� r\ r c �8 � t j dt � y)a�
Return ``bool`` indicating whether `offer` is acceptable.
.. warning::
The behavior of ``.__contains__`` for the ``AcceptLanguage`` classes
is currently being maintained for backward compatibility, but it
will change in the future to better conform to the RFC.
:param offer: (``str``) language tag offer
:return: (``bool``) Whether ``offer`` is acceptable according to the
header.
For this class, either there is no ``Accept-Language`` header in the
request, or the header is invalid, so any language tag is acceptable,
and this always returns ``True``.
z�The behavior of .__contains__ for the AcceptLanguage classes is currently being maintained for backward compatibility, but it will change in the future to better conform to the RFC.Tr^ rT s r r� z-_AcceptLanguageInvalidOrNoHeader.__contains__� r_ r c �L � t j dt � t d� S )a�
Return all the ranges with non-0 qvalues, in order of preference.
.. warning::
The behavior of this method is currently maintained for backward
compatibility, but will change in the future.
:return: iterator of all the language ranges in the header with non-0
qvalues, in descending order of qvalue. If two ranges have the
same qvalue, they are returned in the order of their positions
in the header, from left to right.
For this class, either there is no ``Accept-Language`` header in the
request, or the header is invalid, so there are no language ranges, and
this always returns an empty iterator.
r� r+ ra r� s r r� z)_AcceptLanguageInvalidOrNoHeader.__iter__� rc r c � � g S )a�
Return the tags that match the header, using Basic Filtering.
:param language_tags: (``iterable``) language tags
:return: A list of tuples of the form (language tag, qvalue), in
descending order of preference.
When the header is invalid and when the header is not in the request,
there are no matches, so this method always returns an empty list.
r+ )r3 r� s r r� z0_AcceptLanguageInvalidOrNoHeader.basic_filtering s � � � r Nc � � t j dt � d}|}|D ]* }t |t t
f� r|\ }}nd}||kD s�'|}|}�, |S )a}
Return the best match from the sequence of language tag `offers`.
This is the ``.best_match()`` method for when the header is invalid or
not found in the request, corresponding to
:meth:`AcceptLanguageValidHeader.best_match`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptLanguageValidHeader.best_match`).
When the header is invalid, or there is no `Accept-Language` header in
the request, any of the language tags in `offers` are considered
acceptable, so the best match is the tag in `offers` with the highest
server quality value (if the server quality value is not supplied, it
is 1).
If more than one language tags in `offers` have the same highest server
quality value, then the one that shows up first in `offers` is the best
match.
:param offers: (iterable)
| Each item in the iterable may be a ``str`` language
tag, or a (language tag, server quality value)
``tuple`` or ``list``. (The two may be mixed in the
iterable.)
:param default_match: (optional, any type) the value to be returned if
`offers` is empty.
:return: (``str``, or the type of `default_match`)
| The language tag that has the highest server quality value.
If `offers` is empty, the value of `default_match` is
returned.
z�The behavior of .best_match for the AcceptLanguage classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior is not specified in (and currently does not conform to) RFC 7231.rh rg rg rh s r r: z+_AcceptLanguageInvalidOrNoHeader.best_match sm � �P �
�
�
I�
�
� � �"�
�� '�E��%�$�� �/�!&���w���� �%� "�
� &� � '� �r c �Z � |�
|� t d� �|�|S |� S # t $ r |cY S w xY w)a�
Return the language tag that best matches the header, using Lookup.
When the header is invalid, or there is no ``Accept-Language`` header
in the request, all language tags are considered acceptable, so it is
as if the header is '*'. As specified for the Lookup matching scheme in
:rfc:`RFC 4647, section 3.4 <4647#section-3.4>`, when the header is
'*', the default value is to be computed and returned. So this method
will ignore the `language_tags` and `default_range` arguments, and
proceed to `default_tag`, then `default`.
:param language_tags: (optional, any type)
| This argument is ignored, and is only used as a
placeholder so that the method signature
corresponds to that of
:meth:`AcceptLanguageValidHeader.lookup`.
:param default_range: (optional, any type)
| This argument is ignored, and is only used as a
placeholder so that the method signature
corresponds to that of
:meth:`AcceptLanguageValidHeader.lookup`.
:param default_tag: (optional, ``None`` or ``str``)
| At least one of `default_tag` or `default` must
be supplied as an argument to the method, to
define the defaulting behaviour.
| If this argument is not ``None``, then it is
returned.
| This parameter corresponds to "return a
particular language tag designated for the
operation", one of the examples of "defaulting
behavior" described in :rfc:`RFC 4647, section
3.4.1 <4647#section-3.4.1>`.
:param default: (optional, ``None`` or any type, including a callable)
| At least one of `default_tag` or `default` must be
supplied as an argument to the method, to define the
defaulting behaviour.
| If `default_tag` is ``None``, then Lookup will next
examine the `default` argument.
| If `default` is a callable, it will be called, and
the callable's return value will be returned.
| If `default` is not a callable, the value itself will
be returned.
| This parameter corresponds to the "defaulting
behavior" described in :rfc:`RFC 4647, section 3.4.1
<4647#section-3.4.1>`
:return: (``str``, or any type)
| the return value from `default_tag` or `default`.
r� )rL )r3 r� r� r� r� s r r� z'_AcceptLanguageInvalidOrNoHeader.lookupM sN � �F � �7�?��L��
� � "� � � ��9� ��� ��N� �s � � *�*c �8 � t j dt � y)a�
Return quality value of given offer, or ``None`` if there is no match.
This is the ``.quality()`` method for when the header is invalid or not
found in the request, corresponding to
:meth:`AcceptLanguageValidHeader.quality`.
.. warning::
This is currently maintained for backward compatibility, and will be
deprecated in the future (see the documentation for
:meth:`AcceptLanguageValidHeader.quality`).
:param offer: (``str``) language tag offer
:return: (``float``) ``1.0``.
When the ``Accept-Language`` header is invalid or not in the request,
all offers are equally acceptable, so 1.0 is always returned.
z�The behavior of .quality for the AcceptLanguage classes is currently being maintained for backward compatibility, but the method will be deprecated in the future, as its behavior is not specified in (and currently does not conform to) RFC 7231.r r^ rT s r r� z(_AcceptLanguageInvalidOrNoHeader.quality� s � �( �
�
�
I�
�
� r r� )NNNN) r6 r7 r8 r9 rA r� r� r� r� r: r� r� r+ r r r� r� � s> � � �
� �H��4�4 �9�x CG��N�`r r� c �Z � e Zd ZdZd� Zd� Zed� � Zed� � Zd� Z d� Z
d� Z d � Z d
� Z
y ) r� a&
Represent when there is no ``Accept-Language`` header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptLanguageNoHeader.__add__`).
c �. � d| _ d| _ d| _ y)zE
Create an :class:`AcceptLanguageNoHeader` instance.
Nrr r� s r r� z AcceptLanguageNoHeader.__init__� rs r c �" � | j � S r� ru r� s r r� zAcceptLanguageNoHeader.copy� rv r c � � | j S rl r� r� s r r� z#AcceptLanguageNoHeader.header_value� rm r c � � | j S ro r� r� s r r� z AcceptLanguageNoHeader.parsed� rp r c � � t |t � rt |j �� S t |t t f� r| j � S | j
| |�� S )a3
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str``
* a ``dict``, with language ranges as keys and qvalues as values
* a ``tuple`` or ``list``, of language range ``str``'s or of ``tuple``
or ``list`` (language range, qvalue) pairs (``str``'s and pairs can be
mixed within the ``tuple`` or ``list``)
* an :class:`AcceptLanguageValidHeader`,
:class:`AcceptLanguageNoHeader`, or
:class:`AcceptLanguageInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an
:class:`AcceptLanguageValidHeader` instance, a new
:class:`AcceptLanguageValidHeader` instance with the valid header value
is returned.
If `other` is ``None``, an :class:`AcceptLanguageNoHeader` instance, an
invalid header value, or an :class:`AcceptLanguageInvalidHeader`
instance, a new :class:`AcceptLanguageNoHeader` instance is returned.
r� r� )rv r� r� r� r� r� r� r� s r r� z AcceptLanguageNoHeader.__add__� s` � �4 �e� 6� 7�,�%�:L�:L�M� M� � �*�,G�H�
� �>�>�#� #��>�>��� ?�
�
r c �& � | j |�� S )z�
Add to header, creating a new header object.
See the docstring for :meth:`AcceptLanguageNoHeader.__add__`.
ry rz r� s r r� z AcceptLanguageNoHeader.__radd__ r{ r c �L � dj | j j � S r} r~ r� s r r� z AcceptLanguageNoHeader.__repr__ r r c � � yr� r+ r� s r r5 z AcceptLanguageNoHeader.__str__ r� r c � � |s| j � S | j |�� } t |�� S # t $ r | j � cY S w xY wr� )r� r� r� rV r� s r r� zAAcceptLanguageNoHeader._add_instance_and_non_accept_language_type sS � ���>�>�#� #� !� =� =�E� =� J�� $�,�:L�M� M��� $��>�>�#� #� $�r� N�r6 r7 r8 r9 r� r� r@ r� r� r� r� r� r5 r� r+ r r r� r� � sS � ��$� � �"� �"� � � � �$
�L)�6�(� $r r� c �^ � e Zd ZdZd� Zd� Zed� � Zed� � Zd� Z d� Z
d� Z d � Z d d
�Z
y )
r� a�
Represent an invalid ``Accept-Language`` header.
An invalid header is one that does not conform to
:rfc:`7231#section-5.3.5`. As specified in the RFC, an empty header is an
invalid ``Accept-Language`` header.
:rfc:`7231` does not provide any guidance on what should happen if the
``Accept-Language`` header has an invalid value. This implementation
disregards the header, and treats it as if there is no ``Accept-Language``
header in the request.
This object should not be modified. To add to the header, we can use the
addition operators (``+`` and ``+=``), which return a new object (see the
docstring for :meth:`AcceptLanguageInvalidHeader.__add__`).
c �. � || _ d| _ d| _ y)zJ
Create an :class:`AcceptLanguageInvalidHeader` instance.
Nrr r� s r r� z$AcceptLanguageInvalidHeader.__init__8 r� r c �8 � | j | j � S r� r� r� s r r� z AcceptLanguageInvalidHeader.copy@ r� r c � � | j S r� r� r� s r r� z(AcceptLanguageInvalidHeader.header_valueG r� r c � � | j S r� r� r� s r r� z"AcceptLanguageInvalidHeader.parsedL rp r c � � t |t � rt |j �� S t |t t f� r
t � S | j | |�� S )a3
Add to header, creating a new header object.
`other` can be:
* ``None``
* a ``str``
* a ``dict``, with language ranges as keys and qvalues as values
* a ``tuple`` or ``list``, of language range ``str``'s or of ``tuple``
or ``list`` (language range, qvalue) pairs (``str``'s and pairs can
be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptLanguageValidHeader`,
:class:`AcceptLanguageNoHeader`, or
:class:`AcceptLanguageInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
If `other` is a valid header value or an
:class:`AcceptLanguageValidHeader` instance, a new
:class:`AcceptLanguageValidHeader` instance with the valid header value
is returned.
If `other` is ``None``, an :class:`AcceptLanguageNoHeader` instance, an
invalid header value, or an :class:`AcceptLanguageInvalidHeader`
instance, a new :class:`AcceptLanguageNoHeader` instance is returned.
r� r� )rv r� r� r� r� r� r� s r r� z#AcceptLanguageInvalidHeader.__add__U s\ � �4 �e� 6� 7�,�%�:L�:L�M� M� � �*�,G�H�
� *�+� +��>�>��� ?�
�
r c �* � | j | |d�� S r� r� r� s r r� z$AcceptLanguageInvalidHeader.__radd__{ rJ r c �L � dj | j j � S r} r~ r� s r r� z$AcceptLanguageInvalidHeader.__repr__� r r c � � yr� r+ r� s r r5 z#AcceptLanguageInvalidHeader.__str__� r� r c � � |s
t � S | j |�� } t |�� S # t $ r
t � cY S w xY wr� )r� r� r� rV r� s r r� zFAcceptLanguageInvalidHeader._add_instance_and_non_accept_language_type� sM � � �)�+� +� !� =� =�E� =� J�� ,�,�:L�M� M��� ,�)�+� +� ,�r� Nr? r� r+ r r r� r� & sX � ��"$�2� �"� �"� � � � �$
�L
�6� (�
6;� ,r r� c � � | �
t � S t | t � r| j � S t | �� S # t
$ r t
| �� cY S w xY w)a
Create an object representing the ``Accept-Language`` header in a request.
:param header_value: (``str``) header value
:return: If `header_value` is ``None``, an :class:`AcceptLanguageNoHeader`
instance.
| If `header_value` is a valid ``Accept-Language`` header, an
:class:`AcceptLanguageValidHeader` instance.
| If `header_value` is an invalid ``Accept-Language`` header, an
:class:`AcceptLanguageInvalidHeader` instance.
r� )r� rv r� r� r� rV r� r� s r r� r� � ry r� c �p ��� d} d��fd�}��fd�}�fd��t ||�t j | � � S )Na�
Property representing the ``Accept-Language`` header.
(:rfc:`RFC 7231, section 5.3.5 <7231#section-5.3.5>`)
The header value in the request environ is parsed and a new object
representing the header is created every time we *get* the value of the
property. (*set* and *del* change the header value in the request
environ, and do not involve parsing.)
�HTTP_ACCEPT_LANGUAGEc �N �� t | j j �� �� S r� )r� r� r� r� s �r r z&accept_language_property.<locals>.fget� r} r c �� �� |�t |t � r
�| �� yt |t t f� r
|j }nt
j
|�� }|| j �< y)a~
Set the corresponding key in the request environ.
`value` can be:
* ``None``
* a ``str``
* a ``dict``, with language ranges as keys and qvalues as values
* a ``tuple`` or ``list``, of language range ``str``'s or of ``tuple``
or ``list`` (language range, qvalue) pairs (``str``'s and pairs can
be mixed within the ``tuple`` or ``list``)
* an :class:`AcceptLanguageValidHeader`,
:class:`AcceptLanguageNoHeader`, or
:class:`AcceptLanguageInvalidHeader` instance
* object of any other type that returns a value for ``__str__``
Nr� r� )rv r� r� r� r� r� r� r� r� s ��r r� z&accept_language_property.<locals>.fset� sf �� �" �=�J�u�.D� E� �� !���1�3N�O�� %� 1� 1� � -� I� I� � J� � � ,8�G�O�O�K� (r c �@ �� | j �= y# t $ r Y yw xY wr� r� r� s �r r� z&accept_language_property.<locals>.fdel� r� r� r� r� s @@r �accept_language_propertyr� � s< �� � �C� )�K�
� 8�<� �D�$��h�o�o�c�&:� ;�;r )0r9 � collectionsr r r� r� r" �tchar_rer� r! rE � qvalue_rer r r r% r( r* �objectr0 r� rD rZ r� r� r� r� r� r� r r� r� r� r, r. r9 r\ r@ rA r? r� r� r� r� r� r� r� r� r+ r r �<module>r� s
��� #� � � �
�� *�� �c�>�� �B�J�J�s�X�~�� 3�4� � �
�
�S�L�6� !�H� ,�y� 8�3� >� �5�� ��<�*�]�,I�J� <�*@ �V� @ �F I
�� I
�XM*�� M*�`Q�v� Q�hk$�-� k$�\u$�2� u$�p>�0;<�|@&�F� @&�Fe �}� e �P
{�m� {�|g$� ;� g$�Ts+�!@� s+�lE�08<�vC&�V� C&�LU �� U �pv�~� v�ri$� =� i$�Xt,�"B� t,�nF�0:<�zM&�V� M&�`e �� e �P C�~� C�Lh$� =� h$�Vt,�"B� t,�nF�09<r