� I�g�z���dZddlmZmZmZddlmZmZmZ m Z ddl m Z mZmZddlZeje��ZddlmZddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#ddl$m%Z%gd �Z&e!d ��Z'e!d ��Z(e!d ��Z)e!d ��Z*e'e!d��zZ+e!d��Z,e!d��Z-e!d��Z.eed����Z/dZ0dZ1dZ2e3ee/����Z4d)d�Z5d�Z6d�Z7dZ8dZ9dZ:d�Z;d�Z<d�Z e5ddd ���Z=e2d!zZ>d"�ZGd#�d$e?��Z@Gd%�d&e@��ZAeAe)��ZBeAe)d'�(��ZCeAe*d'�(��ZDdS)*zC passlib.utils.binary - binary data encoding/decoding/manipulation �)�absolute_import�division�print_function)� b64encode� b64decode� b32decode� b32encode)� b2a_base64� a2b_base64�ErrorN)�exc) �PY3� bascii_to_str�irange�imap�iter_byte_chars�join_byte_values�join_byte_elems� nextgetter�suppress_cause�u�unicode�unicode_or_bytes_types)�memoized_property)� BASE64_CHARS�PADDED_BASE64_CHARS� AB64_CHARS� HASH64_CHARS� BCRYPT_CHARS� HEX_CHARS�LOWER_HEX_CHARS�UPPER_HEX_CHARS�ALL_BYTE_VALUES�compile_byte_translation� ab64_encode� ab64_decode� b64s_encode� b64s_decoder r� Base64Engine�LazyBase64Engine�h64�h64big�bcrypt64z@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/z@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./z@./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789�=�0123456789abcdefABCDEF�0123456789ABCDEF�0123456789abcdef����=c�`�|�tdd�}nFt|t��rt|��dksJ�t t |����}|���D]�\}}t|t��rt|��}t|t��rd|cxkrdksnJ�t|t��r|� d��}t|t��rt|��dksJ�|||<��t� |��S)a� return a 256-byte string for translating bytes using specified mapping. bytes not specified by mapping will be left alone. :param mapping: dict mapping input byte (str or int) -> output byte (str or int). :param source: optional existing byte translation string to use as base. (must be 255-length byte string). defaults to identity mapping. :returns: 255-length byte string for passing to bytes().translate. N��rr2�ascii�)�_TRANSLATE_SOURCE� isinstance�bytes�len�listr�itemsr�ord�intr�encode�B_EMPTY�join)�mapping�source�target�k�vs �d/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/passlib/utils/binary.pyr$r$ns���~�"�1�1�1�%����&�%�(�(�?�S��[�[�C�-?�-?�-?�?��o�f�-�-�.�.��� � �������1� �a�/� 0� 0� ��A���A��!�S�!�!�2�a�1�l�l�l�l�s�l�l�l�l�l�2� �a�� !� !� "�����!�!�A��!�U�#�#�3��A���!� � � �3���q� � � �<�<�� � �r3c�P�t|���t��S)zr encode using shortened base64 format which omits padding & whitespace. uses default ``+/`` altchars. )r �rstrip� _BASE64_STRIP��datas rJr'r'�s �� �d� � � "� "�=� 1� 1�1r3c��t|t��rA |�d��}n*#t$rt t d�����wxYwt |��dz}|dkrn1|dkr |tz }n |dkr |tz }nt d��� t|��S#t$r!}t t|�����d}~wwxYw)zq decode from shortened base64 format which omits padding & whitespace. uses default ``+/`` altchars. r8�4string argument should contain only ASCII characters�r�zinvalid base64 inputN) r;rrB�UnicodeEncodeErrorr� ValueErrorr=� _BASE64_PAD2� _BASE64_PAD1r �_BinAsciiError� TypeError)rO�off�errs rJr(r(�s�� �$�� � �e� e��;�;�w�'�'�D�D��!� e� e� e� ��,b�!c�!c�d�d� d� e���� �d�)�)�a�-�C� �a�x�x� � ���� � ���� ���� � �����/�0�0�0�-��$����� �-�-�-��Y�s�^�^�,�,�,�����-���s!�-�'A�"B1�1 C�;C�Cs= s==c�H�t|���dd��S)z� encode using shortened base64 format which omits padding & whitespace. uses custom ``./`` altchars. it is primarily used by Passlib's custom pbkdf2 hashes. �+�.)r'�replacerNs rJr%r%�s"�� �t� � � $� $�T�4� 0� 0�0r3c���t|t��rA |�d��}n*#t$rt t d�����wxYwt |�dd����S)z� decode from shortened base64 format which omits padding & whitespace. uses custom ``./`` altchars, but supports decoding normal ``+/`` altchars as well. it is primarily used by Passlib's custom pbkdf2 hashes. r8rQr^r])r;rrBrTrrUr(r_rNs rJr&r&�s����$�� � �e� e��;�;�w�'�'�D�D��!� e� e� e� ��,b�!c�!c�d�d� d� e���� �t�|�|�D�$�/�/� 0� 0�0s �-�'Ac�j�tt|���t����S)zh wrapper around :func:`base64.b32encode` which strips padding, and returns a native string. )r� _b32encoderL�B_EQUAL)rFs rJr r �s(�� ��F�+�+�2�2�7�;�;� <� <�<r3�B�O)�8�0�c���t|t��r|�d��}|�t��}t |��dz}|r|t d| �z }t|d��S)z� wrapper around :func:`base64.b32decode` which handles common mistyped chars. padding optional, ignored if present. r8�NT)r;rrB� translate�_b32_translater=�_b32_decode_pad� _b32decode)rF� remainders rJrr�s{���&�'�"�"�(����w�'�'�� � � �n� -� -�F��F� � �c�!�I��/��/�+�I�:�+�.�.�� �f�d� #� #�#r3c���eZdZdZdZdZdZdZdZdZ dd�Z e d���Z d�Z d�Zd�Zd �Zd �Zd �Zd �Zed ���Zed���Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d�Z&dS) r)acProvides routines for encoding/decoding base64 data using arbitrary character mappings, selectable endianness, etc. :arg charmap: A string of 64 unique characters, which will be used to encode successive 6-bit chunks of data. A character's position within the string should correspond to its 6-bit value. :param big: Whether the encoding should be big-endian (default False). .. note:: This class does not currently handle base64's padding characters in any way what so ever. Raw Bytes <-> Encoded Bytes =========================== The following methods convert between raw bytes, and strings encoded using the engine's specific base64 variant: .. automethod:: encode_bytes .. automethod:: decode_bytes .. automethod:: encode_transposed_bytes .. automethod:: decode_transposed_bytes .. .. automethod:: check_repair_unused .. automethod:: repair_unused Integers <-> Encoded Bytes ========================== The following methods allow encoding and decoding unsigned integers to and from the engine's specific base64 variant. Endianess is determined by the engine's ``big`` constructor keyword. .. automethod:: encode_int6 .. automethod:: decode_int6 .. automethod:: encode_int12 .. automethod:: decode_int12 .. automethod:: encode_int24 .. automethod:: decode_int24 .. automethod:: encode_int64 .. automethod:: decode_int64 Informational Attributes ======================== .. attribute:: charmap unicode string containing list of characters used in encoding; position in string matches 6bit value of character. .. attribute:: bytemap bytes version of :attr:`charmap` .. attribute:: big boolean flag indicating this using big-endian encoding. NFc�R�t|t��r|�d��}n*t|t��st j|d���t |��dkrtd���t t|����dkrtd���||_ |j |_ td�t|��D����}|j |_||_|r|j|_|j|_dS|j|_|j|_dS)N�latin-1�charmap�@z'charmap must be 64 characters in lengthz-charmap must not contain duplicate charactersc3�$K�|] \}}||fV�� dS�N�)�.0�idx�values rJ� <genexpr>z(Base64Engine.__init__.<locals>.<genexpr>]s*����H�H�z�s�E�u�c�l�H�H�H�H�H�Hr3)r;rrBr<r �ExpectedStringErrorr=rU�set�bytemap� __getitem__� _encode64�dict� enumerate� _decode64�big�_encode_bytes_big� _encode_bytes�_decode_bytes_big� _decode_bytes�_encode_bytes_little�_decode_bytes_little)�selfrsr��lookups rJ�__init__zBase64Engine.__init__Qs�� �g�w� '� '� >��n�n�Y�/�/�G�G��G�U�+�+� >��)�'�9�=�=� =� �w�<�<�2� � ��F�G�G� G� �s�7�|�|� � �� "� "��L�M�M� M��� � �,����H�H�Y�w�5G�5G�H�H�H�H�H���+������ � ;�!%�!7�D� �!%�!7�D� � � �!%�!:�D� �!%�!:�D� � � r3c�6�|j�d��S)zcharmap as unicoderr)r~�decode)r�s rJrszBase64Engine.charmapss���|�"�"�9�-�-�-r3c��t|t��stdt|�������t t |��d��\}}t rtt|����}ntd�|D����}|� |||��}tt|j |����}|S)z�encode bytes to base64 string. :arg source: byte string to encode. :returns: byte string containing encoded data. �source must be bytes, not rRc3�4K�|]}t|��V��dSrv)r@)rx�elems rJr{z,Base64Engine.encode_bytes.<locals>.<genexpr>�s(����#A�#A�$�C��I�I�#A�#A�#A�#A�#A�#Ar3) r;r<rY�type�divmodr=rr�iterr�rrr�)r�rF�chunks�tail� next_value�gen�outs rJ� encode_byteszBase64Engine.encode_bytes{s��� �&�%�(�(� N��)�d�6�l�l�l�L�M�M� M��c�&�k�k�1�-�-� ��� � B�#�D��L�L�1�1�J�J�#�#A�#A�&�#A�#A�#A�A�A�J�� � ��V�T�:�:���d�4�>�3�7�7�8�8�� � r3c#�pK�d}||krW|��}|��}|��}|dzV�|dzdz|dz zV�|dzdz|dz zV�|dz V�|dz }||k�W|rR|��}|dkr|dzV�|dz V�d S|dksJ�|��}|dzV�|dzdz|dz zV�|dz V�d Sd S) z>helper used by encode_bytes() to handle little-endian encodingr�?�rS�rR�r9Nrw�r�r�r�r�ry�v1�v2�v3s rJr�z!Base64Engine._encode_bytes_little�s8�������F�l�l�����B�����B�����B��t�)�O�O�O���I��>�B��E�*� *� *� *���I��>�B��E�*� *� *� *��a�%�K�K�K� �1�H�C��F�l�l� � �����B��q�y�y��4�i�����!�e� � � � � ��q�y�y�y�y��Z�\�\���4�i�����T� �A�~��A��.�.�.�.��!�e� � � � � � � r3c#�|K�d}||krW|��}|��}|��}|dz V�|dzdz|dz zV�|dzdz|dz zV�|dzV�|dz }||k�W|rX|��}|dkr|dz V�|dzdzV�d S|dksJ�|��}|dz V�|dzdz|dz zV�|dzdzV�d Sd S) z;helper used by encode_bytes() to handle big-endian encodingrrSrRr�r�r�r�r9Nrwr�s rJr�zBase64Engine._encode_bytes_big�sJ�������F�l�l�����B�����B�����B��a�%�K�K�K��t�G�a�<�"�a�%�(� (� (� (��t�G�a�<�"�a�%�(� (� (� (��t�)�O�O�O� �1�H�C��F�l�l� � %�����B��q�y�y��!�e� � � ��$�w��l�"�"�"�"�"��q�y�y�y�y��Z�\�\���!�e� � � ��4��!�|�b�!�e�,�,�,�,��4��!�|�$�$�$�$�$� %� %r3c���t|t��stdt|�������t t |��d��\}}|dkrt d���tt|j |����} t|� |||����S#t$r"}t d|j d�����d}~wwxYw)z�decode bytes from base64 string. :arg source: byte string to decode. :returns: byte string containing decoded data. r�r�r9z(input string length cannot be == 1 mod 4zinvalid character: rN)r;r<rYr�r�r=rUrrr�rr��KeyError�args)r�rFr�r�r�r[s rJ� decode_byteszBase64Engine.decode_bytes�s��� �&�%�(�(� N��)�d�6�l�l�l�L�M�M� M� �c�&�k�k�1�-�-� ��� �1�9�9��G�H�H� H���T�^�V� <� <�=�=� � G�#�D�$6�$6�z�6�4�$P�$P�Q�Q� Q��� G� G� G��*���� � �E�F�F� F����� G���s� #B1�1 C�;C�Cc#�bK�d}||kr]|��}|��}|��}|��}||dzdzzV�|dz |dzdzzV�|dz |dzzV�|dz }||k�]|rC|��}|��}||dzdzzV�|dkr|��}|dz |dzdzzV�dSdSdS) z>helper used by decode_bytes() to handle little-endian encodingrrRr�rSr�r�r9Nrw� r�r�r�r�ryr�r�r��v4s rJr�z!Base64Engine._decode_bytes_little�s&�������F�l�l�����B�����B�����B�����B���c��a��(� (� (� (��q�5�b�3�h�1�_�-� -� -� -��q�5�R��U�#� #� #� #� �1�H�C��F�l�l� � 2�����B�����B���c��a��(� (� (� (��q�y�y��Z�\�\���1�u�"�s�(�q��1�1�1�1�1�1� 2� 2� �yr3c#�bK�d}||kr]|��}|��}|��}|��}|dz|dz zV�|dzdz|dz zV�|dzdz|zV�|dz }||k�]|rC|��}|��}|dz|dz zV�|dkr|��}|dzdz|dz zV�dSdSdS) z;helper used by decode_bytes() to handle big-endian encodingrrSr�r�rRr�r9Nrwr�s rJr�zBase64Engine._decode_bytes_bigs&�������F�l�l�����B�����B�����B�����B��q�5�R��U�#� #� #� #��s�F�Q�;�2�q�5�)� )� )� )��s�F�Q�;�"�$� $� $� $� �1�H�C��F�l�l� � .�����B�����B��q�5�R��U�#� #� #� #��q�y�y��Z�\�\���3���{�r�1�u�-�-�-�-�-�-� .� .� �yr3c����t�fd�t|j��D����}|��fd�t|j��D����t |��S)z2helper to generate set of valid last chars & bytesc3�,�K�|]\}}|�z� |V��dSrvrw�rx�i�c�bitss �rJr{z-Base64Engine.__make_padset.<locals>.<genexpr>Gs0�����H�H���1�q�4�x�H�1�H�H�H�H�H�Hr3c3�,�K�|]\}}|�z� |V��dSrvrwr�s �rJr{z-Base64Engine.__make_padset.<locals>.<genexpr>Hs0�����I�I�#�!�A��D��I�A�I�I�I�I�I�Ir3)r}r�r~�updaters� frozenset)r�r��psets ` rJ� __make_padsetzBase64Engine.__make_padsetEsl����H�H�H�H� �$�,� 7� 7�H�H�H�H�H�� � � �I�I�I�I��4�<�!8�!8�I�I�I�I�I�I�����r3c�H�|jrdnd}||�|��fS)zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)r��<�r��_Base64Engine__make_padset�r�r�s rJ� _padinfo2zBase64Engine._padinfo2Ks/���X�*�r�r�E���u�d�(�(��.�.�.�.r3c�H�|jrdnd}||�|��fS)zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rR�0r�r�s rJ� _padinfo3zBase64Engine._padinfo3Rs/���H�(�q�q�4���u�d�(�(��.�.�.�.r3c��t|��dz}|dkr |j\}}n&|dkr |j\}}n|sd|fStd���|d}||vrd|fSt |t ��r4|j}||�|��|z}||vs Jd���nP|�|� |��|z��}||vs Jd���trt|g��}d|dd�|zfS) ahelper to detect & clear invalid unused bits in last character. :arg source: encoded data (as ascii bytes or unicode). :returns: `(True, result)` if the string was repaired, `(False, source)` if the string was ok as-is. rRrSFzsource length must != 1 mod 4�����z%failed to generate valid padding charTN) r=r�r�rUr;rrs�indexr�r�rr<)r�rFr��mask�padset�last�cms rJ�check_repair_unusedz Base64Engine.check_repair_unusedYs-���6�{�{�Q��� �1�9�9��>�L�D�&�&� �Q�Y�Y��>�L�D�&�&�� >��&�=� ��<�=�=� =��b�z�� �6�>�>��&�=� � �f�g� &� &� %���B��b�h�h�t�n�n�t�+�,�D��6�>�>�>�#J�>�>�>�>��>�>�$�.�.��"6�"6��"=�>�>�D��6�>�>�>�#J�>�>�>�� %��d�V�}�}���V�C�R�C�[�4�'�'�'r3c�8�|�|��dS)Nr9)r��r�rFs rJ� repair_unusedzBase64Engine.repair_unused�s���'�'��/�/��2�2r3c����t�t��stdt��������t �fd�|D����}|�|��S)z>encode byte string, first transposing source using offset listr�c3�(�K�|] }�|V�� dSrvrw)rxrZrFs �rJr{z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>�s'�����=�=�c�f�S�k�=�=�=�=�=�=r3)r;r<rYr�rr�)r�rF�offsets�tmps ` rJ�encode_transposed_bytesz$Base64Engine.encode_transposed_bytes�sg����&�%�(�(� N��)�d�6�l�l�l�L�M�M� M��=�=�=�=�W�=�=�=�=�=��� � ��%�%�%r3c��|�|��}dgt|��z}t||��D] \}}|||<� t|��S)zGdecode byte string, then reverse transposition described by offset listN)r�r=�zipr)r�rFr�r��bufrZ�chars rJ�decode_transposed_bytesz$Base64Engine.decode_transposed_bytes�s_�� ����'�'���f�s�7�|�|�#���W�c�*�*� � �I�C���C��H�H��s�#�#�#r3c��t|t��stdt|�������|j}| dz}||zdz }t |��|krt d|fz���|j}d} |r|nt|��D]}|dz||��z}�n #t$rt d|�����wxYw|r|r||z}n |d|zdz z}|S)a�decode base64 string -> integer :arg source: base64 string to decode. :arg bits: number of bits in resulting integer. :raises ValueError: * if the string contains invalid base64 characters. * if the string is not long enough - it must be at least ``int(ceil(bits/6))`` in length. :returns: a integer in the range ``0 <= n < 2**bits`` r�r�zsource must be %d charsrzinvalid character in string: r9) r;r<rYr�r�r=rUr��reversedr�) r�rFr�r��pad�charsr�r�r�s rJ� _decode_intzBase64Engine._decode_int�s-���&�%�(�(� N��)�d�6�l�l�l�L�M�M� M��h���e�a�i���c��1� �� �v�;�;�%� � ��6�%��A�B�B� B������ G�"�8�V�V���(8�(8� +� +���A�v������*��� +��� G� G� G��*�!�!�E�F�F� F� G���� � #�� #��� �����4���{�"��� s �:'B"�"B?c�2�t|t��stdt|�������t |��dkrt d���t r|d} |�|��S#t$rt d���wxYw)z(decode single character -> 6 bit integerr�r9zsource must be exactly 1 byter�invalid character) r;r<rYr�r=rUrr�r�r�s rJ� decode_int6zBase64Engine.decode_int6�s����&�%�(�(� N��)�d�6�l�l�l�L�M�M� M� �v�;�;�!� � ��<�=�=� =� � ��A�Y�F� 2��>�>�&�)�)� )��� 2� 2� 2��0�1�1� 1� 2���s �'A<�<Bc��t|t��stdt|�������t |��dkrt d���|j} |jr&||d��||d��dzzS||d��||d��dzzS#t$rt d���wxYw)z'decodes 2 char string -> 12-bit integerr�rSzsource must be exactly 2 bytesr9rr�r�� r;r<rYr�r=rUr�r�r��r�rFr�s rJ� decode_int12zBase64Engine.decode_int12�s����&�%�(�(� N��)�d�6�l�l�l�L�M�M� M� �v�;�;�!� � ��=�>�>� >���� 2��x� B��v�f�Q�i�(�(�F�F�6�!�9�,=�,=�q�,@�A�A��v�f�Q�i�(�(�F�F�6�!�9�,=�,=�q�,@�A�A��� 2� 2� 2��0�1�1� 1� 2���s�,B2� %B2�2C c�F�t|t��stdt|�������t |��dkrt d���|j} |jrP||d��||d��dzz||d��dzz||d ��d zzS||d ��||d��dzz||d��dzz||d��d zzS#t$rt d ���wxYw) z'decodes 4 char string -> 24-bit integerr�r�zsource must be exactly 4 bytesrRrSr�r9� r�r�r�r�s rJ� decode_int24zBase64Engine.decode_int24�s_���&�%�(�(� N��)�d�6�l�l�l�L�M�M� M� �v�;�;�!� � ��=�>�>� >���� 2��x� I��v�f�Q�i�(�(�F�F�6�!�9�,=�,=�q�,@�A���v�a�y�)�)�2�-�/�28�&����2C�2C�R�2G�I�I��v�f�Q�i�(�(�F�F�6�!�9�,=�,=�q�,@�A���v�a�y�)�)�2�-�/�28�&����2C�2C�R�2G�I�I��� 2� 2� 2��0�1�1� 1� 2���s�AD�6AD�D c�.�|�|d��S)�&decode 5 char string -> 30 bit integer��r�r�s rJ� decode_int30zBase64Engine.decode_int30�s�������+�+�+r3c�.�|�|d��S)z�decode 11 char base64 string -> 64-bit integer this format is used primarily by des-crypt & variants to encode the DES output value used as a checksum. rtr�r�s rJ� decode_int64zBase64Engine.decode_int64s�� �����+�+�+r3c�����dks Jd���| dz}||z }|jrt|dz dd��}�|z�ntd|d��}tt|j�fd�|D������S)z�encode integer into base64 format :arg value: non-negative integer to encode :arg bits: number of bits to encode :returns: a string of length ``int(ceil(bits/6.0))``. rzcaller did not sanitize inputr�i����c3�(�K�|] }�|z dzV�� dS)r�Nrw)rxrZrzs �rJr{z+Base64Engine._encode_int.<locals>.<genexpr>"s,����� D� D��%��*��!4� D� D� D� D� D� Dr3)r�rrrr�)r�rzr�r��itrs ` rJ� _encode_intzBase64Engine._encode_ints������z�z�z�:�z�z�z��e�a�i�� �� �� �8� %���a���R�(�(�C� �c�M�E�E���D�!�$�$�C��t�D�N� D� D� D� D�� D� D� D� F� F�G�G� Gr3c��|dks|dkrtd���tr|j||dz�S|�|��S)z0encodes 6-bit integer -> single hash64 characterrr��value out of ranger9)rUrr~r��r�rzs rJ� encode_int6zBase64Engine.encode_int6(sQ�� �1�9�9��� � ��1�2�2� 2� � )��<��e�A�g� �.� .��>�>�%�(�(� (r3c���|dks|dkrtd���|dz|dz dzg}|jrt|��}tt |j|����S)z'encodes 12-bit integer -> 2 char stringri�r�r�r��rUr�r�rrr��r�rz�raws rJ� encode_int12zBase64Engine.encode_int121sh�� �1�9�9��� � ��1�2�2� 2��t�|�e�Q�h�$�.�/�� �8� ��3�-�-�C��t�D�N�C�8�8�9�9�9r3c���|dks|dkrtd���|dz|dz dz|dz dz|dz dzg}|jrt|��}tt |j|����S)z'encodes 24-bit integer -> 4 char stringri���r�r�r�r�r�r�r�s rJ� encode_int24zBase64Engine.encode_int24:s��� �1�9�9���(�(��1�2�2� 2��t�|�e�Q�h�$�.��r� �T�!�E�2�I��#5�7�� �8� ��3�-�-�C��t�D�N�C�8�8�9�9�9r3c�d�|dks|dkrtd���|�|d��S)r�ri���?r�r��rUr�r�s rJ� encode_int30zBase64Engine.encode_int30Ds:�� �1�9�9�� �*�*��1�2�2� 2�����r�*�*�*r3c�d�|dks|dkrtd���|�|d��S)z�encode 64-bit integer -> 11 char hash64 string this format is used primarily by des-crypt & variants to encode the DES output value used as a checksum. rl����r�rtr�r�s rJ� encode_int64zBase64Engine.encode_int64Js=�� �1�9�9�� 2�2�2��1�2�2� 2�����r�*�*�*r3)F)'�__name__� __module__� __qualname__�__doc__r~r�r�r�r�r�r��propertyrsr�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrwr3rJr)r)�s������>�>�H�G� �C��I��I��M��M� ;�;�;�;�D�.�.��X�.����*%�%�%�N%%�%%�%%�VG�G�G�,!2�!2�!2�F!.�!.�!.�T��� �/�/���/� �/�/���/� '(�'(�'(�R3�3�3�$&�&�&� $� $� $�"�"�"�P 2� 2� 2� 2� 2� 2�2�2�2�",�,�,�,�,�,�G�G�G�4)�)�)�:�:�:�:�:�:�+�+�+� +�+�+�+�+r3r)c�2��eZdZdZdZd�Z�fd�Zd�Z�xZS)r*z<Base64Engine which delays initialization until it's accessedNc��||f|_dSrv)� _lazy_opts)r�r��kwdss rJr�zLazyBase64Engine.__init__\s����,����r3c�x��|j\}}tt|��j|i|��|`t|_dSrv)r �superr*r�r)� __class__)r�r�r rs �rJ� _lazy_initzLazyBase64Engine._lazy_init_sA����_� ��d�.����%�%�.��=��=�=�=� �O�%����r3c��|�d��s|���t�||��S)N�_)� startswithr�object�__getattribute__)r��attrs rJrz!LazyBase64Engine.__getattribute__es<�����s�#�#� � �O�O� � � ��&�&�t�T�2�2�2r3) rrrrr r�rr� __classcell__)rs@rJr*r*Xsa�������F�F��J�'�'�'�&�&�&�&�&� 3�3�3�3�3�3�3r3r*T)r�rv)Er� __future__rrr�base64rrrrnr rb�binasciir r r rX�logging� getLoggerr�log�passlibr �passlib.utils.compatrrrrrrrrrrrr�passlib.utils.decorr�__all__rrrrrr r"r!r#rC�B_NULLrcr>r:r$r'r(rMrWrVr%r&rlrmrr)r*r+r,r-rwr3rJ�<module>r"s�����A�@�@�@�@�@�@�@�@�@������������� E�D�D�D�D�D�D�D�D�D������g���!�!������������������������������������ 2�1�1�1�1�1� � � ��J�q�S�T�T� ��q�S�T�T� ��q�S�T�T� ��q�S�T�T� �#�Q�Q�s�V�V�+�� �A�&� '� '� ��!�&�'�'���!�&�'�'��#�"�6�6�#�;�;�/�/�� �� �� ���D����9�9�:�:�� � � � �B2�2�2�-�-�-�8� �� �� � 1�1�1� 1� 1� 1�&=�=�=�*�)��#�*>�*>�?�?���A�+��$�$�$�0U +�U +�U +�U +�U +�6�U +�U +�U +�v3�3�3�3�3�|�3�3�3�,��|�$�$�� � �,�D� 1� 1� 1�� � �L�d� 3� 3� 3���r3
Memory