Current File : //usr/lib/python3.9/site-packages/passlib/utils/__pycache__/__init__.cpython-39.pyc
a
f�Wc�� � @ sF d Z ddlmZ ddlmZmZmZ ddlm Z m
Z
z ddl m Z ddl m
Z
W n* eyz ddlm Z ddlm
Z
Y n0 ddlmZ ddlmZ dd lZdd lZdd lZe�e�Zdd lZdd l Z dd l Z dd l Z dd l Z e�rz dd l Z W n e�y d Z d
Z!Y n0 ndd l Z dd l"Z"e �r.dd l#Z#z dd l$Z$W n e�yR d Z$Y n0 dd l%Z%dd l&Z&dd l'm(Z( dd l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 dd
l7m8Z8m9Z9m:Z:m;Z;m<Z< ddl=m>Z>m?Z? ddlm@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZP g d�ZQeRe�eF�r>e jSne jTd�d �ZUg d�ZVddgZWddl=mXZX dZYeGd�ZZeGd�Z[eRe j\�]d��p�d�Z^G d d � d e_�Z`eF�r�ejajbZcedecejajeg�Zfd d � Zgnd d � Zgd�d"d#�Zhd$d%� Zid&d'� ZjejZkzdd(llmmZj W n e�y Y n0 d�d*d+�Znd�d-d.�Zoe d u �r@d�d/d.�Zod0d1� ZpeF�r`d2d3� Zqd4d5� Zrn dd6lmsZsmtZt d7d3� Zqd8d5� Zre@eqd9� e@erd:� d;d<� Zud=d>� Zvd?d@� ZwdAZxeGdB�Zyd�dCdD�ZzdEdF� Z{dGZ|e|�}dH�Z~dIdJ� ZdKdL� Z�dMZ�eGdN�Z�dOdP� Z�d�dRdS�Z�d�dTdU�Z�eF�r"d�dVdW�Z�n
d�dXdW�Z�e@e�dY� e8dZd[d\�d�d]d^��Z�edd_��� �Z�edd`��� �Z�edddag�Z�d�dcdd�Z�dedf� Z�zddgl�m�Z� W n0 e�y� d Z�d!Z�d!Z�d!Z�d Z�dhdi� Z�Y n�0 djZ�dBZ�e$�reP�rdke j� k�r�dlk�rn ne$��� Z�djZ�nddmlm�Z� e�� Z�d!Z�eGdn�Z�eF�rhdjZ�ze�dodp� W n" e��yR d!Z�Y n Y n0 dqdi� Z�n djZ�drdi� Z�e@e�ds� dtdu� Z�e%j�Z�e�Z�dvdw� Z�ze ��dx� djZ�W n e��y� d!Z�Y n0 d�dydz�Z�e��r�e ��� Z�n e ��e�� �Z�d{d|� Z�d}d~� Z�dZ�e8d[d�d�d��d�e�fd�d���Z�d�Z�d�d�� Z�d�Z�d�d�� Z�d�d�� Z�d�d�� Z�d S )�z4passlib.utils -- helpers for writing password hashes� )�JYTHON)�
b2a_base64�
a2b_base64�Error)� b64encode� b64decode)�Sequence)�Iterable)�lookup)�update_wrapperNznot present under Jython)�warn)
� BASE64_CHARS�
AB64_CHARS� HASH64_CHARS� BCRYPT_CHARS� Base64Engine�LazyBase64Engine�h64�h64big�bcrypt64� ab64_encode� ab64_decode� b64s_encode� b64s_decode)�deprecated_function�deprecated_method�memoized_property�
classproperty�
hybrid_method)�ExpectedStringError�ExpectedTypeError)�add_doc�
join_bytes�join_byte_values�join_byte_elems�irange�imap�PY3�u� join_unicode�unicode�byte_elem_value�
nextgetter�unicode_or_str�unicode_or_bytes_types�get_method_function�suppress_cause�PYPY)r �sys_bits�unix_crypt_schemes�rounds_cost_values�consteq�saslprep� xor_bytes� render_bytes�
is_same_codec�
is_ascii_safe�to_bytes�
to_unicode�
to_native_str� has_crypt�
test_crypt�
safe_crypt�tick�rng� getrandbytes�
getrandstr�generate_password�is_crypt_handler�is_crypt_context�has_rounds_info�
has_salt_info� g �?)Z sha512_cryptZ sha256_cryptZ
sha1_cryptZbcryptZ md5_cryptZ
bsdi_cryptZ des_cryptZlinearZlog2)�MissingBackendError� � � ZPASSLIB_MAX_PASSWORD_SIZEi c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dS )�
SequenceMixinz�
helper which lets result object act like a fixed-length sequence.
subclass just needs to provide :meth:`_as_tuple()`.
c C s t d��d S )Nzimplement in subclass)�NotImplementedError��self� rS �:/usr/lib/python3.9/site-packages/passlib/utils/__init__.py� _as_tuple� s zSequenceMixin._as_tuplec C s t | �� �S �N)�reprrU rQ rS rS rT �__repr__� s zSequenceMixin.__repr__c C s | � � | S rV �rU )rR �idxrS rS rT � __getitem__� s zSequenceMixin.__getitem__c C s t | �� �S rV )�iterrU rQ rS rS rT �__iter__� s zSequenceMixin.__iter__c C s t | �� �S rV )�lenrU rQ rS rS rT �__len__� s zSequenceMixin.__len__c C s | � � |kS rV rY �rR �otherrS rS rT �__eq__� s zSequenceMixin.__eq__c C s | � |� S rV )rb r` rS rS rT �__ne__� s zSequenceMixin.__ne__N) �__name__�
__module__� __qualname__�__doc__rU rX r[ r] r_ rb rc rS rS rS rT rO � s rO c C sJ t �t| ��j}|sdS |�|�}|r4|jtvr4dS |t|�d jtkS )�*test if function accepts specified keywordFT���) �inspectZ signaturer/ �
parameters�get�kind� _VAR_ANY_SET�list� _VAR_KEYWORD)�func�key�params�argrS rS rT �accepts_keyword� s
ru c C s" t �t| ��}||jv p |jduS )rh N)rj Z
getargspecr/ �args�keywords)rq rr �specrS rS rT ru � s Fc s8 t |t�r|g}t| j�}|rXt |t�r.|g}|D ]$� |rD� |v rDq2� |v r2|�� � q2|�r$|D ]�� t� fdd�|D ��r~qb|r�t|�D ](\}} t� | �r� q�|r�t| |�r� q�q�t|�}nX|�rtt |��D ]:\}
} t| |�r�t|�|
}||d | k�sJ � �qq�d}nd}|�
|� � qb|�s4t |�| _dS )a
helper to update mixin classes installed in target class.
:param target:
target class whose bases will be modified.
:param add:
class / classes to install into target's base class list.
:param remove:
class / classes to remove from target's base class list.
:param append:
by default, prepends mixins to front of list.
if True, appends to end of list instead.
:param after:
optionally make sure all mixins are inserted after
this class / classes.
:param before:
optionally make sure all mixins are inserted before
this class / classes.
:param dryrun:
optionally perform all calculations / raise errors,
but don't actually modify the class.
c 3 s | ]}t |� �V qd S rV )�
issubclass)�.0�base�ZmixinrS rT � <genexpr>� rL z'update_mixin_classes.<locals>.<genexpr>� r N) �
isinstance�typero � __bases__�remove�any� enumeratery r^ �reversed�insert�tuple) �target�addr� �append�beforeZafterZdryrun�basesrZ r{ Zend_idxrS r| rT �update_mixin_classes� sB
r� c c s� |dk rt d��t| t�rLt| �}d}||k r�|| }| ||� V |}q&n^t| t�r�t| �}t�||�}z t|�}W n t y� Y q�Y n0 t�
|f|�V q^nt d��dS )z8
split iterable into chunks of <size> elements.
r~ z size must be positive integerr zsource must be iterableN) �
ValueErrorr r r^ r r\ � itertools�islice�next�
StopIteration�chain� TypeError)�source�size�end�i�n�itrZ chunk_itr�firstrS rS rT �batch s$
r� c C s� t | t�r"t |t�s td��d}n*t | t�rDt |t�s>td��t}ntd��t| �t|�k}|rh| }d}|st|}d}|r�t||�D ]\}}|||A O }q�n(t||�D ] \}}|t|�t|�A O }q�|dkS )a� Check two strings/bytes for equality.
This function uses an approach designed to prevent
timing analysis, making it appropriate for cryptography.
a and b must both be of the same type: either str (ASCII only),
or any type that supports the buffer protocol (e.g. bytes).
Note: If a and b are of different lengths, or if an error occurs,
a timing attack could theoretically reveal information about the
types and lengths of a and b--but not their values.
z)inputs must be both unicode or both bytesFr r~ )r r* r� �bytesr' r^ �zip�ord)�left�rightZ is_py3_bytesZ same_size�tmp�result�l�rrS rS rT r5 ; s,
r5 )�compare_digest�,c C s: | � � } | �|�r | dd� } | s&g S dd� | �|�D �S )zRsplit comma-separated string into list of elements,
stripping whitespace.
Nri c S s g | ] }|� � �qS rS )�strip�rz �elemrS rS rT �
<listcomp>� rL z splitcomma.<locals>.<listcomp>)r� �endswith�split)r� �seprS rS rT �
splitcomma� s
r� �valuec s� t | t�s tdt| �f ��tj�tj� t� �fdd�| D ��}t� d|�}|sTt
S tj }||d �r�||d �s~t d| ��tj
}n|}tj}tj}tj}tj}tj} tj}
tj} tj} tj}
|D ]�}� |�r�J d���|�r�J d ��||�r�t d
| ��||��rt d | ��||��r(t d | ��||��r>t d
| ��| |��rTt d| ��|
|��rjt d| ��| |��r�t d| ��| |��r�t d| ��|
|��r�t d| ��||�r�t d| ��q�|S )a Normalizes unicode strings using SASLPrep stringprep profile.
The SASLPrep profile is defined in :rfc:`4013`.
It provides a uniform scheme for normalizing unicode usernames
and passwords before performing byte-value sensitive operations
such as hashing. Among other things, it normalizes diacritic
representations, removes non-printing characters, and forbids
invalid characters such as ``\n``. Properly internationalized
applications should run user passwords through this function
before hashing.
:arg source:
unicode string to normalize & validate
:param param:
Optional noun identifying source parameter in error messages
(Defaults to the string ``"value"``). This is mainly useful to make the caller's error
messages make more sense contextually.
:raises ValueError:
if any characters forbidden by the SASLPrep profile are encountered.
:raises TypeError:
if input is not :class:`!unicode`
:returns:
normalized unicode string
.. note::
This function is not available under Jython,
as the Jython stdlib is missing the :mod:`!stringprep` module
(`Jython issue 1758320 <http://bugs.jython.org/issue1758320>`_).
.. versionadded:: 1.6
z$input must be unicode string, not %sc 3 s& | ] }� |�s�|�rt n|V qd S rV )�_USPACE�rz �c�� in_table_b1� in_table_c12rS rT r} � s �zsaslprep.<locals>.<genexpr>�NFKCr ri zmalformed bidi sequence in z$failed to strip B.1 in mapping stagez(failed to replace C.1.2 in mapping stagez$unassigned code points forbidden in z control characters forbidden in z$private use characters forbidden in z"non-char code points forbidden in z surrogate codes forbidden in z!non-plaintext chars forbidden in z!non-canonical chars forbidden in z1display-modifying / deprecated chars forbidden inz tagged characters forbidden in z forbidden bidi character in )r r* r� r� �
stringprepr� r� r) � unicodedata� normalize�_UEMPTYZ in_table_d1r� Z in_table_d2� in_table_a1�in_table_c21_c22� in_table_c3� in_table_c4� in_table_c5� in_table_c6� in_table_c7� in_table_c8� in_table_c9)r� �param�dataZ is_ral_charZis_forbidden_bidi_charr� r� r� r� r� r� r� r� r� r� rS r� rT r6 � sj ,
��
�
r6 c C s t dt ��dS )zstub for saslprep()z>saslprep() support requires the 'stringprep' module, which is N)rP �_stringprep_missing_reason)r� r� rS rS rT r6 s �c G s4 t | t�r| �d�} | tdd� |D �� }|�d�S )a� Peform ``%`` formating using bytes in a uniform manner across Python 2/3.
This function is motivated by the fact that
:class:`bytes` instances do not support ``%`` or ``{}`` formatting under Python 3.
This function is an attempt to provide a replacement:
it converts everything to unicode (decoding bytes instances as ``latin-1``),
performs the required formatting, then encodes the result to ``latin-1``.
Calling ``render_bytes(source, *args)`` should function roughly the same as
``source % args`` under Python 2.
.. todo::
python >= 3.5 added back limited support for bytes %,
can revisit when 3.3/3.4 is dropped.
�latin-1c s s& | ] }t |t�r|�d �n|V qdS )r� N)r r� �decode)rz rt rS rS rT r} , s �z render_bytes.<locals>.<genexpr>)r r� r� r� �encode)r� rv r� rS rS rT r8 s
�
r8 c C s t �| d�S �NZbig)�int�
from_bytes�r� rS rS rT � bytes_to_int2 s r� c C s | � |d�S r� )r; �r� �countrS rS rT � int_to_bytes4 s r� )�hexlify� unhexlifyc C s t t| �d�S )N� )r� r� r� rS rS rT r� 9 s c C s t d|d> | �S )Nz%%0%dxr~ )r� r� rS rS rT r� ; s z/decode byte string as single big-endian integerz/encode integer as single big-endian byte stringc C s t t| �t|�A t| ��S )z;Perform bitwise-xor of two byte strings (must be same size))r� r� r^ �r� r� rS rS rT r7 A s r7 c C s$ d|d t | � }| | d|� S )zE
repeat or truncate <source> string, so it has length <size>
r~ N)r^ �r� r� ZmultrS rS rT �
repeat_stringE s r� c C s" d|d t | � }t| | |�S )zN
variant of repeat_string() which truncates to nearest UTF8 boundary.
r~ )r^ �
utf8_truncater� rS rS rT �utf8_repeat_stringM s r� � � c C sJ t | �}||kr:|du r*t| t�r&tnt}| ||| S | d|� S dS )z>right-pad or truncate <source> string, so it has length <size>N)r^ r r* �_UNULL�_BNULL)r� r� ZpadZcurrS rS rT �right_pad_stringX s r� c s� t �t�st�td��t��}|dk r4td|| �}||kr@�S t|d |�}||k rvt�| �d@ dkrlq�|d7 }qN||ks�J ��d|� � � �fdd �}|� s�J �� S )
a�
helper to truncate UTF8 byte string to nearest character boundary ON OR AFTER <index>.
returned prefix will always have length of at least <index>, and will stop on the
first byte that's not a UTF8 continuation byte (128 - 191 inclusive).
since utf8 should never take more than 4 bytes to encode known unicode values,
we can stop after ``index+3`` is reached.
:param bytes source:
:param int index:
:rtype: bytes
r� r � � � r~ Nc s< z�� d�} W n ty" Y dS 0 | �� � d��s8J �dS )N�utf-8T)r� �UnicodeDecodeError�
startswith)�text�r� r� rS rT � sanity_check� s z#utf8_truncate.<locals>.sanity_check)r r� r r^ �max�minr+ )r� �indexr� r� rS r� rT r� c s"
r� s
aA:#!�asciic C s t �| �tkS )zRTest if codec is compatible with 7-bit ascii (e.g. latin-1, utf-8; but not utf-16))�_ASCII_TEST_UNICODEr� �_ASCII_TEST_BYTES)�codecrS rS rT �is_ascii_codec� s r� c C s, | |kr dS | r|sdS t | �jt |�jkS )z3Check if two codec names are aliases for same codecTF)�
_lookup_codec�namer� rS rS rT r9 � s
r9 r� � c s( t | t�rtnt� t� fdd�| D ��S )z<Check if string (bytes or unicode) contains only 7-bit asciic 3 s | ]}|� k V qd S rV rS r� �r� rS rT r} � rL z is_ascii_safe.<locals>.<genexpr>)r r� �_B80�_U80�all)r� rS r� rT r: � s r: r� c C sX |sJ �t | t�r6|r0t||�s0| �|��|�S | S n t | t�rJ| �|�S t| |��dS )a Helper to normalize input to bytes.
:arg source:
Source bytes/unicode to process.
:arg encoding:
Target encoding (defaults to ``"utf-8"``).
:param param:
Optional name of variable/noun to reference when raising errors
:param source_encoding:
If this is specified, and the source is bytes,
the source will be transcoded from *source_encoding* to *encoding*
(via unicode).
:raises TypeError: if source is not unicode or bytes.
:returns:
* unicode strings will be encoded using *encoding*, and returned.
* if *source_encoding* is not specified, byte strings will be
returned unchanged.
* if *source_encoding* is specified, byte strings will be transcoded
to *encoding*.
N)r r� r9 r� r� r* r )r� �encodingr� Zsource_encodingrS rS rT r; � s
r; c C s8 |sJ �t | t�r| S t | t�r*| �|�S t| |��dS )a� Helper to normalize input to unicode.
:arg source:
source bytes/unicode to process.
:arg encoding:
encoding to use when decoding bytes instances.
:param param:
optional name of variable/noun to reference when raising errors.
:raises TypeError: if source is not unicode or bytes.
:returns:
* returns unicode strings unchanged.
* returns bytes strings decoded using *encoding*
N)r r* r� r� r �r� r� r� rS rS rT r< � s
r< c C s0 t | t�r| �|�S t | t�r"| S t| |��d S rV )r r� r� r* r r� rS rS rT r= � s
r= c C s0 t | t�r| S t | t�r"| �|�S t| |��d S rV )r r� r* r� r r� rS rS rT r= s
a> Take in unicode or bytes, return native string.
Python 2: encodes unicode using specified encoding, leaves bytes alone.
Python 3: leaves unicode alone, decodes bytes using specified encoding.
:raises TypeError: if source is not unicode or bytes.
:arg source:
source unicode or bytes string.
:arg encoding:
encoding to use when encoding unicode or decoding bytes.
this defaults to ``"utf-8"``.
:param param:
optional name of variable/noun to reference when raising errors.
:returns: :class:`str` instance
z1.6z1.7)�
deprecated�removedc C s t | |dd�S )z'deprecated, use to_native_str() instead�hash)r� )r= )r� r� rS rS rT � to_hash_str$ s r� z true t yes y on 1 enable enabledz#false f no n off 0 disable disabled�none�booleanc C s~ |dv s J �t | t�rX| �� �� }|tv r.dS |tv r:dS |tv rF|S td|| f ��n"t | t�rf| S | du rr|S t| �S dS )z\
helper to convert value to boolean.
recognizes strings such as "true", "false"
)TFNTFzunrecognized %s value: %rN) r r. �lowerr� � _true_set�
_false_set� _none_setr� �bool)r� r� r� ZcleanrS rS rT �as_bool- s
r c C s< t st| t�sdS z| �d� W dS ty6 Y dS 0 dS )z�
UT helper --
test if value is safe to pass to crypt.crypt();
under PY3, can't pass non-UTF8 bytes to crypt.crypt.
Tr� FN)�crypt_accepts_bytesr r� r� r� r� rS rS rT �is_safe_crypt_inputG s
r )�cryptc C s d S rV rS ��secretr� rS rS rT r@ ] s r@ T)� rJ r )r r� r� )� nullcontextz*:!� ��xxc C s$ t r>t| t�r| �d�} t| v r(td��t|t�r�|�d�}nlt| t�r�| }z| �d�} W n tyn Y d S 0 | �d�|ks�J d��t | v r�td��t|t�r�|�d�}z2t
� t | |�}W d � n1 s�0 Y W n t y� Y d S 0 t|t��r|�d�}|�r |d t
v �r d S |S )Nr� �null character in secretr� z"utf-8 spec says this can't happen!r )r r r* r� r� r� r� r� r� �_NULL�_safe_crypt_lock�_crypt�OSError�_invalid_prefixes)r
r� Zorigr� rS rS rT r@ � s<
�
,
c C s� t | t�r| �d�} t| v r$td��t |t�r8|�d�}t� t| |�}W d � n1 s\0 Y |snd S |�d�}|d tv r�d S |S )Nr� r r� r ) r r* r� r r� r r r� r )r
r� r� rS rS rT r@ � s
(
a� Wrapper around stdlib's crypt.
This is a wrapper around stdlib's :func:`!crypt.crypt`, which attempts
to provide uniform behavior across Python 2 and 3.
:arg secret:
password, as bytes or unicode (unicode will be encoded as ``utf-8``).
:arg hash:
hash or config string, as ascii bytes or unicode.
:returns:
resulting hash as ascii unicode; or ``None`` if the password
couldn't be hashed due to one of the issues:
* :func:`crypt()` not available on platform.
* Under Python 3, if *secret* is specified as bytes,
it must be use ``utf-8`` or it can't be passed
to :func:`crypt()`.
* Some OSes will return ``None`` if they don't recognize
the algorithm being used (though most will simply fall
back to des-crypt).
* Some OSes will return an error string if the input config
is recognized but malformed; current code converts these to ``None``
as well.
c C s4 t |t�sJ dt|� ��|s&J d��t| |�|kS )z�check if :func:`crypt.crypt` supports specific hash
:arg secret: password to test
:arg hash: known hash of password to use as reference
:returns: True or False
z#hash must be unicode_or_str, got %szhash must be non-empty)r r- r� r@ r rS rS rT r? � s
� r? c C s2 t �d| �}|r.tdd� |�d��d�D ��S dS )z helper to parse version stringz(\d+(?:\.\d+)+)c s s | ]}t |�V qd S rV )r� r� rS rS rT r} � rL z parse_version.<locals>.<genexpr>r~ �.N)�re�searchr� �groupr� )r� �mrS rS rT �
parse_version� s r r~ c C s� ddl m} t| d�rJt| d�rJz | �� } W n tyH | �d�} Y n0 td�| ttd�rdt�� ndt t
� �t � � t � t
r�t�d ��d
�ndf }t||�d ���� d �S )
z.generate prng seed value from system resourcesr )�sha512�getstate� getrandbitsi � z%s %s %s %.15f %.15f %s�getpidN� r� r� r� )Zhashlibr �hasattrr rP r r( �osr �id�object�timerA � has_urandom�urandomr� r� r� � hexdigest)r� r r� rS rS rT �genseed s �r( c s � st S � �fdd�}t|� �S )z]return byte-string containing *count* number of randomly generated bytes, using specified rngc 3 s: �� � d> �} d}|� k r6| d@ V | dL } |d7 }qd S )Nr� r � r~ )r �r� r� �r� rB rS rT �helperM s
z getrandbytes.<locals>.helper)�_BEMPTYr# )rB r� r, rS r+ rT rC B s rC c sl �dk rt d��t� ���dkr(t d���dkr8� � S � ���fdd�}t� t�r^t|� �S t|� �S dS )z|return string containing *count* number of chars/bytes, whose elements are drawn from specified charset, using specified rngr zcount must be >= 0zalphabet must not be emptyr~ c 3 s@ �� d�� �} d}|�k r<� | � V | � } |d7 }qd S )Nr r~ )Z randranger* ��charsetr� ZlettersrB rS rT r, f s zgetrandstr.<locals>.helperN)r� r^ r r* r) r$ )rB r/ r� r, rS r. rT rD W s
rD Z42346789ABCDEFGHJKMNPQRTUVWXYZabcdefghjkmnpqrstuvwxyzz2.0z/passlib.pwd.genword() / passlib.pwd.genphrase())r� r� Z replacement�
c C s t t|| �S )aw generate random password using given length & charset
:param size:
size of password.
:param charset:
optional string specified set of characters to draw from.
the default charset contains all normal alphanumeric characters,
except for the characters ``1IiLl0OoS5``, which were omitted
due to their visual similarity.
:returns: :class:`!str` containing randomly generated password.
.. note::
Using the default character set, on a OS with :class:`!SystemRandom` support,
this function should generate passwords with 5.7 bits of entropy per character.
)rD rB )r� r/ rS rS rT rE v s rE )r� � setting_kwdsZ context_kwds�verifyr� �identifyc s t � fdd�tD ��S )z4check if object follows the :ref:`password-hash-api`c 3 s | ]}t � |�V qd S rV �r �rz r� ��objrS rT r} � rL z#is_crypt_handler.<locals>.<genexpr>)r� �_handler_attrsr6 rS r6 rT rF � s rF )Z needs_updateZ genconfigZgenhashr2 Zencryptr3 c s t � fdd�tD ��S )zOcheck if object appears to be a :class:`~passlib.context.CryptContext` instancec 3 s | ]}t � |�V qd S rV r4 r5 r6 rS rT r} � rL z#is_crypt_context.<locals>.<genexpr>)r� �_context_attrsr6 rS r6 rT rG � s rG c C s d| j v ot| dd�duS )z_check if handler provides the optional :ref:`rounds information <rounds-attributes>` attributes�roundsZ
min_roundsN�r1 �getattr�ZhandlerrS rS rT rH � s
�rH c C s d| j v ot| dd�duS )z[check if handler provides the optional :ref:`salt information <salt-attributes>` attributesZsaltZ
min_salt_sizeNr; r= rS rS rT rI � s
�rI )NNFNNF)r� )r� )r� )N)r� r� N)r� r� )r� r� )r� r� )r� )Nr� )N)�rg Zpasslib.utils.compatr Zbinasciir r r Z_BinAsciiError�base64r r �collections.abcr r � ImportError� collections�codecsr
r� � functoolsr r� rj ZloggingZ getLoggerrd �logZmathr! �sysZrandomr r� r� r$ r� � threadingZtimeit�types�warningsr Zpasslib.utils.binaryr
r r r r r r r r r r r r Zpasslib.utils.decorr r r r r Z passlib.excr r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 �__all__r� �maxsizeZmaxintr2 r3 r4 rK r- r� r� �environrl ZMAX_PASSWORD_SIZEr# rO Z ParameterZ VAR_KEYWORDrp �setZVAR_POSITIONALrn ru r� r� r5 Z str_consteqZhmacr� r� r6 r8 r� r� r� r� r7 r� r� r� r� r� r� r� r� r� r� r9 r� r� r: r; r< r= r� r� r r r r r r r r> r Zcrypt_needs_lockr r@ r Zpypy_version_info�Lockr r r� r? Z
default_timerZtimerrA r r& r% rP r( Z SystemRandomrB ZRandomrC rD Z
_52charsetrE r8 rF r9 rG rH rI rS rS rS rT �<module> sH
< L."
�
W >
F
%
�
*
/
!
�
Mini Shell