
    K}bgz                        d Z ddlmZmZmZ ddlmZmZmZ	m
Z ddlmZmZmZ ddlZ ej        e          ZddlmZ ddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z# ddl$m%Z% g d	Z& e!d
          Z' e!d          Z( e!d          Z) e!d          Z*e' e!d          z   Z+ e!d          Z, e!d          Z- e!d          Z. e ed                    Z/dZ0dZ1dZ2 e3 ee/                    Z4d)dZ5d Z6d Z7dZ8dZ9dZ:d Z;d Z<d Z
 e5ddd           Z=e2d!z  Z>d" Z G d# d$e?          Z@ G d% d&e@          ZA eAe)          ZB eAe)d'(          ZC eAe*d'(          ZDdS )*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                 `   |t           dd         }nFt          |t                    rt          |          dk    sJ t	          t          |                    }|                                 D ]\  }}t          |t                    rt          |          }t          |t                    rd|cxk    rdk     sn J t          |t                    r|                    d          }t          |t                    rt          |          dk    sJ |||<   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   r   r2   ascii   )_TRANSLATE_SOURCE
isinstancebyteslenlistr   itemsr   ordintr   encodeB_EMPTYjoin)mappingsourcetargetkvs        g/home/e360mart.nyusoft.in/public_html/e360mart_env/lib/python3.11/site-packages/passlib/utils/binary.pyr$   r$   n   s    ~"111%&%((?S[[C-?-?-??of--..  1a/00 	AA!S!!2a1llllslllll2a!! 	"!!A!U##3A!3q		<<r3   c                 P    t          |                               t                    S )zr
    encode using shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    )r
   rstrip_BASE64_STRIPdatas    rJ   r'   r'      s     
 d""=111r3   c                    t          | t                    rA	 |                     d          } n*# t          $ r t	          t          d                    w xY wt          |           dz  }|dk    rn1|dk    r| t          z  } n |dk    r| t          z  } nt          d          	 t          |           S # t          $ r!}t	          t          |                    d}~ww xY w)zq
    decode from shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    r8   4string argument should contain only ASCII characters   r      zinvalid base64 inputN)r;   r   rB   UnicodeEncodeErrorr   
ValueErrorr=   _BASE64_PAD2_BASE64_PAD1r   _BinAsciiError	TypeError)rO   offerrs      rJ   r(   r(      s    
 $   e	e;;w''DD! 	e 	e 	e ,b!c!cddd	e
d))a-C
axx		/000-$ - - -Ys^^,,,-s!   - 'A"B1 1
C;CCs   =
s   ==c                 H    t          |                               dd          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'   replacerN   s    rJ   r%   r%      s"     t$$T4000r3   c                     t          | t                    rA	 |                     d          } n*# t          $ r t	          t          d                    w xY wt          |                     dd                    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.
    r8   rQ   r^   r]   )r;   r   rB   rT   r   rU   r(   r_   rN   s    rJ   r&   r&      s     $   e	e;;w''DD! 	e 	e 	e ,b!c!cddd	et||D$//000s	   - 'Ac                 j    t          t          |                               t                              S )zh
    wrapper around :func:`base64.b32encode` which strips padding,
    and returns a native string.
    )r   
_b32encoderL   B_EQUAL)rF   s    rJ   r	   r	      s(     F++227;;<<<r3   BO)80   c                     t          | t                    r|                     d          } |                     t                    } t          |           dz  }|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;   r   rB   	translate_b32_translater=   _b32_decode_pad
_b32decode)rF   	remainders     rJ   r   r      s{     &'"" (w''n--F Fc!I //+I:+.. fd###r3   c                       e Zd ZdZdZdZdZdZdZdZ	ddZ
ed             Zd Zd Zd Zd	 Zd
 Zd Zd Zed             Zed             Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&dS ) r)   ac  Provides 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                    st	          j        |d          t          |          dk    rt          d          t          t          |                    dk    rt          d          || _	        |j
        | _        t          d t          |          D                       }|j
        | _        || _        |r| j        | _        | j        | _        d S | j        | _        | j        | _        d S )Nlatin-1charmap@   z'charmap must be 64 characters in lengthz-charmap must not contain duplicate charactersc              3   $   K   | ]\  }}||fV  d S N ).0idxvalues      rJ   	<genexpr>z(Base64Engine.__init__.<locals>.<genexpr>]  s*      HHzsEuclHHHHHHr3   )r;   r   rB   r<   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)selfrs   r   lookups       rJ   __init__zBase64Engine.__init__Q  s   gw'' 	>nnY//GGGU++ 	>)'9===w<<2FGGGs7||""LMMM ,HHYw5G5GHHHHH+  	;!%!7D!%!7D!%!:D!%!:Dr3   c                 6    | j                             d          S )zcharmap as unicoderr   )r~   decode)r   s    rJ   rs   zBase64Engine.charmaps  s     |""9---r3   c                    t          |t                    st          dt          |                    t	          t          |          d          \  }}t          rt          t          |                    }nt          d |D                       }| 	                    |||          }t          t          | j        |                    }|S )zencode bytes to base64 string.

        :arg source: byte string to encode.
        :returns: byte string containing encoded data.
        source must be bytes, not rR   c              3   4   K   | ]}t          |          V  d S rv   )r@   )rx   elems     rJ   r{   z,Base64Engine.encode_bytes.<locals>.<genexpr>  s(      #A#A$CII#A#A#A#A#A#Ar3   )r;   r<   rY   typedivmodr=   r   r   iterr   r   r   r   )r   rF   chunkstail
next_valuegenouts          rJ   encode_byteszBase64Engine.encode_bytes{  s     &%(( 	N)d6lllLMMMc&kk1-- 	B#DLL11JJ##A#A&#A#A#AAAJ  VT::d4>37788
 
r3   c              #   p  K   d}||k     rW |            } |            } |            }|dz  V  |dz  dz  |dz	  z  V  |dz  dz  |dz	  z  V  |dz	  V  |dz  }||k     W|rR |            }|dk    r|dz  V  |dz	  V  d	S |dk    sJ  |            }|dz  V  |dz  dz  |dz	  z  V  |dz	  V  d	S d	S )
z>helper used by encode_bytes() to handle little-endian encodingr   ?      rS      rR      r9   Nrw   r   r   r   r   ry   v1v2v3s           rJ   r   z!Base64Engine._encode_bytes_little  s8      FllBBBt)OOOI>BE****I>BE****a%KKK1HC Fll  	Bqyy4i!eqyyyyZ\\4iT	A~A....!e	 	r3   c              #   |  K   d}||k     rW |            } |            } |            }|dz	  V  |dz  dz  |dz	  z  V  |dz  dz  |dz	  z  V  |dz  V  |dz  }||k     W|rX |            }|dk    r|dz	  V  |dz  dz  V  d	S |dk    sJ  |            }|dz	  V  |dz  dz  |dz	  z  V  |dz  dz  V  d	S d	S )
z;helper used by encode_bytes() to handle big-endian encodingr   rS   rR   r   r   r   r   r9   Nrw   r   s           rJ   r   zBase64Engine._encode_bytes_big  sJ      FllBBBa%KKKtGa<"a%((((tGa<"a%((((t)OOO1HC Fll  	%Bqyy!e$wl"""""qyyyyZ\\!e4!|b!e,,,,4!|$$$$$	% 	%r3   c                    t          |t                    st          dt          |                    t	          t          |          d          \  }}|dk    rt          d          t          t          | j	        |                    }	 t          |                     |||                    S # t          $ r"}t          d|j        d                   d}~ww xY w)zdecode bytes from base64 string.

        :arg source: byte string to decode.
        :returns: byte string containing decoded data.
        r   r   r9   z(input string length cannot be == 1 mod 4zinvalid character: r   N)r;   r<   rY   r   r   r=   rU   r   r   r   r   r   KeyErrorargs)r   rF   r   r   r   r[   s         rJ   decode_byteszBase64Engine.decode_bytes  s     &%(( 	N)d6lllLMMM
 c&kk1--199GHHHT^V < <==
	G#D$6$6z64$P$PQQQ 	G 	G 	G*EFFF	Gs   #B1 1
C;CCc              #   b  K   d}||k     r] |            } |            } |            } |            }||dz  dz  z  V  |dz	  |dz  dz  z  V  |dz	  |dz  z  V  |dz  }||k     ]|rC |            } |            }||dz  dz  z  V  |dk    r |            }|dz	  |dz  dz  z  V  dS dS dS )	z>helper used by decode_bytes() to handle little-endian encodingr   rR   r   rS   r   r   r9   Nrw   	r   r   r   r   ry   r   r   r   v4s	            rJ   r   z!Base64Engine._decode_bytes_little  s&      FllBBBBca((((q5b3h1_----q5RU####1HC Fll  		2BBca((((qyyZ\\1u"s(q111111		2 		2 yr3   c              #   b  K   d}||k     r] |            } |            } |            } |            }|dz  |dz	  z  V  |dz  dz  |dz	  z  V  |dz  dz  |z  V  |dz  }||k     ]|rC |            } |            }|dz  |dz	  z  V  |dk    r |            }|dz  dz  |dz	  z  V  dS dS dS )	z;helper used by decode_bytes() to handle big-endian encodingr   rS   r   r   rR   r   r9   Nrw   r   s	            rJ   r   zBase64Engine._decode_bytes_big  s&      FllBBBBq5RU####sFQ;2q5))))sFQ;"$$$$1HC Fll  		.BBq5RU####qyyZ\\3{r1u------		. 		. yr3   c                     t          fdt          | j                  D                       }|                    fdt          | j                  D                        t          |          S )z2helper to generate set of valid last chars & bytesc              3   ,   K   | ]\  }}|z  
|V  d S rv   rw   rx   icbitss      rJ   r{   z-Base64Engine.__make_padset.<locals>.<genexpr>G  s0      HH1q4xH1HHHHHHr3   c              3   ,   K   | ]\  }}|z  
|V  d S rv   rw   r   s      rJ   r{   z-Base64Engine.__make_padset.<locals>.<genexpr>H  s0      II#!ADIAIIIIIIr3   )r}   r   r~   updaters   	frozenset)r   r   psets    ` rJ   __make_padsetzBase64Engine.__make_padsetE  sl    HHHH	$, 7 7HHHHHIIII4<!8!8IIIIIIr3   c                 H    | j         rdnd}| |                     |          fS )zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)r   <   r   _Base64Engine__make_padsetr   r   s     rJ   	_padinfo2zBase64Engine._padinfo2K  s/     X*rrEud((....r3   c                 H    | j         rdnd}| |                     |          fS )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rR   0   r   r   s     rJ   	_padinfo3zBase64Engine._padinfo3R  s/     H(qq4ud((....r3   c                    t          |          dz  }|dk    r| j        \  }}n&|dk    r| j        \  }}n|sd|fS t          d          |d         }||v rd|fS t	          |t
                    r4| j        }||                    |          |z           }||v s
J d            nP|                     | 	                    |          |z            }||v s
J d            t          rt          |g          }d|dd         |z   fS )	a  helper 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.
        rR   rS   Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r=   r   r   rU   r;   r   rs   indexr   r   r   r<   )r   rF   r   maskpadsetlastcms          rJ   check_repair_unusedz Base64Engine.check_repair_unusedY  s-    6{{Q199>LD&&QYY>LD&& 	>&= <=== bz6>>&=  fg&& 
	%Bbhhtnnt+,D6>>>#J>>>> >>$.."6"6"=>>D6>>>#J>>> %dV}}VCRC[4'''r3   c                 8    |                      |          d         S )Nr9   )r   r   rF   s     rJ   repair_unusedzBase64Engine.repair_unused  s    ''//22r3   c                     t          t                    st          dt                              t	          fd|D                       }|                     |          S )z>encode byte string, first transposing source using offset listr   c              3   (   K   | ]}|         V  d S rv   rw   )rx   rZ   rF   s     rJ   r{   z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>  s'      ==cfSk======r3   )r;   r<   rY   r   r   r   )r   rF   offsetstmps    `  rJ   encode_transposed_bytesz$Base64Engine.encode_transposed_bytes  sg    &%(( 	N)d6lllLMMM====W=====  %%%r3   c                     |                      |          }dgt          |          z  }t          ||          D ]
\  }}|||<   t          |          S )zGdecode byte string, then reverse transposition described by offset listN)r   r=   zipr   )r   rF   r   r   bufrZ   chars          rJ   decode_transposed_bytesz$Base64Engine.decode_transposed_bytes  s_    
 ''fs7||#Wc** 	 	ICCHHs###r3   c                    t          |t                    st          dt          |                    | j        }| dz  }||z   dz  }t          |          |k    rt          d|fz            | j        }d}	 |r|nt          |          D ]}|dz   ||          z   }n # t          $ r t          d|          w xY w|r|r||z  }n|d|z  dz
  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   zsource must be %d charsr   zinvalid character in string: r9   )
r;   r<   rY   r   r   r=   rU   r   reversedr   )	r   rF   r   r   padcharsr   r   r   s	            rJ   _decode_intzBase64Engine._decode_int  s-    &%(( 	N)d6lllLMMMheaic1v;;%6%ABBB	G"8VV(8(8 + +Av*+ 	G 	G 	G*!!EFFF	G 	# #4{"
s   :'B" "B?c                 2   t          |t                    st          dt          |                    t	          |          dk    rt          d          t          r|d         }	 |                     |          S # t          $ r t          d          w xY w)z(decode single character -> 6 bit integerr   r9   zsource must be exactly 1 byter   invalid character)	r;   r<   rY   r   r=   rU   r   r   r   r   s     rJ   decode_int6zBase64Engine.decode_int6  s    &%(( 	N)d6lllLMMMv;;!<=== 	AYF	2>>&))) 	2 	2 	20111	2s   'A< <Bc                    t          |t                    st          dt          |                    t	          |          dk    rt          d          | j        }	 | j        r& ||d                    ||d                   dz  z   S  ||d                    ||d                   dz  z   S # t          $ r t          d          w xY w)z'decodes 2 char string -> 12-bit integerr   rS   zsource must be exactly 2 bytesr9   r   r   r   	r;   r<   rY   r   r=   rU   r   r   r   r   rF   r   s      rJ   decode_int12zBase64Engine.decode_int12  s    &%(( 	N)d6lllLMMMv;;!=>>>	2x BvfQi((FF6!9,=,=q,@AAvfQi((FF6!9,=,=q,@AA 	2 	2 	20111	2s   ,B2 %B2 2Cc                 F   t          |t                    st          dt          |                    t	          |          dk    rt          d          | j        }	 | j        rP ||d                    ||d                   dz  z    ||d                   dz  z    ||d	                   d
z  z   S  ||d	                    ||d                   dz  z    ||d                   dz  z    ||d                   d
z  z   S # t          $ r t          d          w xY w)z'decodes 4 char string -> 24-bit integerr   r   zsource must be exactly 4 bytesrR   rS   r   r9      r      r   r   r   s      rJ   decode_int24zBase64Engine.decode_int24  s_   &%(( 	N)d6lllLMMMv;;!=>>>	2x IvfQi((FF6!9,=,=q,@Avay))2-/28&2C2CR2GI I vfQi((FF6!9,=,=q,@Avay))2-/28&2C2CR2GI I 	2 	2 	20111	2s   AD 6AD D c                 .    |                      |d          S )&decode 5 char string -> 30 bit integer   r   r   s     rJ   decode_int30zBase64Engine.decode_int30  s    +++r3   c                 .    |                      |d          S )zdecode 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.
        rt   r   r   s     rJ   decode_int64zBase64Engine.decode_int64  s     +++r3   c                     dk    s
J d            | dz  }||z  }| j         rt          |dz
  dd          }|z  nt          d|d          }t          t          | j        fd|D                                 S )zencode 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))``.
        r   zcaller did not sanitize inputr   ic              3   (   K   | ]}|z	  d z  V  dS )r   Nrw   )rx   rZ   rz   s     rJ   r{   z+Base64Engine._encode_int.<locals>.<genexpr>"  s,       D D%*!4 D D D D D Dr3   )r   r   r   r   r   )r   rz   r   r   itrs    `   rJ   _encode_intzBase64Engine._encode_int  s     zzz:zzzeai8 	%aR((CcMEED!$$CtDN D D D D D D D F  F G G 	Gr3   c                     |dk     s|dk    rt          d          t          r| j        ||dz            S |                     |          S )z0encodes 6-bit integer -> single hash64 characterr   r   value out of ranger9   )rU   r   r~   r   r   rz   s     rJ   encode_int6zBase64Engine.encode_int6(  sQ    199

1222 	)<eAg..>>%(((r3   c                     |dk     s|dk    rt          d          |dz  |dz	  dz  g}| j        rt          |          }t          t	          | j        |                    S )z'encodes 12-bit integer -> 2 char stringr   i  r   r   r   rU   r   r   r   r   r   r   rz   raws      rJ   encode_int12zBase64Engine.encode_int121  sh    1991222t|eQh$./8 	 3--CtDNC88999r3   c                     |dk     s|dk    rt          d          |dz  |dz	  dz  |dz	  dz  |dz	  dz  g}| j        rt          |          }t          t	          | j        |                    S )z'encodes 24-bit integer -> 4 char stringr   i r   r   r   r   r   r   r   s      rJ   encode_int24zBase64Engine.encode_int24:  s    199((1222t|eQh$.r	T!E2I#578 	 3--CtDNC88999r3   c                 d    |dk     s|dk    rt          d          |                     |d          S )r   r   i?r   r   rU   r   r   s     rJ   encode_int30zBase64Engine.encode_int30D  s:    199
**1222r***r3   c                 d    |dk     s|dk    rt          d          |                     |d          S )zencode 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.
        r   l    r   rt   r   r   s     rJ   encode_int64zBase64Engine.encode_int64J  s=     199 2221222r***r3   )F)'__name__
__module____qualname____doc__r~   r   r   r   r   r   r   propertyrs   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rw   r3   rJ   r)   r)      s       > >H G
C II MM
; ; ; ;D . . X.  *% % %N%% %% %%VG G G,!2 !2 !2F!. !. !.T   / / / / / /'( '( '(R3 3 3$& & &	$ 	$ 	$" " "P2 2 22 2 22 2 2", , ,, , ,G G G4) ) ): : :: : :+ + ++ + + + +r3   r)   c                   2     e Zd ZdZdZd Z fdZd Z xZS )r*   z<Base64Engine which delays initialization until it's accessedNc                     ||f| _         d S rv   )
_lazy_opts)r   r   kwdss      rJ   r   zLazyBase64Engine.__init__\  s    ,r3   c                 x    | j         \  }} t          t          |           j        |i | | ` t          | _        d S rv   )r
  superr*   r   r)   	__class__)r   r   r  r  s      rJ   
_lazy_initzLazyBase64Engine._lazy_init_  sA    _
d.%%.====O%r3   c                     |                     d          s|                                  t                              | |          S )N_)
startswithr  object__getattribute__)r   attrs     rJ   r  z!LazyBase64Engine.__getattribute__e  s<    s## 	OO&&tT222r3   )	r  r  r  r  r
  r   r  r  __classcell__)r  s   @rJ   r*   r*   X  sa        FFJ' ' '& & & & &3 3 3 3 3 3 3r3   r*   T)r   rv   )Er  
__future__r   r   r   base64r   r   r   rn   r	   rb   binasciir
   r   r   rX   logging	getLoggerr  logpasslibr   passlib.utils.compatr   r   r   r   r   r   r   r   r   r   r   r   passlib.utils.decorr   __all__r   r   r   r   r   r    r"   r!   r#   rC   B_NULLrc   r>   r:   r$   r'   r(   rM   rW   rV   r%   r&   rl   rm   r  r)   r*   r+   r,   r-   rw   r3   rJ   <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 #QQsVV+  A&''	 !&'' !&'' #"66#;;// 	
 D99::        B2 2 2- - -8 
1 1 11 1 1&= = = *)#*>*>?? A+$ $ $0U	+ U	+ U	+ U	+ U	+6 U	+ U	+ U	+v3 3 3 3 3| 3 3 3, |$$		,D	1	1	1Ld333r3   