+ ipTRt^RIHtHtHtHt^RIt^RIHt^RI H t ^RI H t Ht^RIt]P"!]4t^RIt^RIt^RIHt^RIHtHtHtHt^RIHtHtHt^R I H!t!.R!Ot"]#!^ ^^$^0^"_self_info_rate.._sJ6%tE1~556s!)len TypeErrorrintvaluessumr r%)sourcesizecountscharr-s& r_self_info_rater3>s 6{ F   |6{F#  a=3J6JJTQ QQ s B B('B(c@V'd&\P!V4!\V44#\PP V4'd \ VR4#VPR4wr#pV'g\RV: 24h\P!W$4#)z :param asset_path: string containing absolute path to file, or package-relative path using format ``"python.module:relative/file/path"``. :returns: filehandle opened in 'rb' mode (unless encoding explicitly specified) rb:zIasset path must be absolute file path or use 'pkg.name:sub/path' format: ) codecs getreader_open_asset_pathospathisabsopen partition ValueError pkg_resourcesresource_stream)r;encodingpackagesepsubpaths&& rr9r9js)*:4*@AA ww}}TD$ NN3/G' DHKL L  ( ( ::r!c\pRpW9dR#\V\4'g#\ \ V44\ V48XdV'dVP V4R#R#\ 4p\ 4pVFpWd9dTMTP V4K \V4p^p\ V4V8d^pRPRVRV44p\ V4V8d!VR\ V4V, ,, p\RV: RV: 24h \dRpELi;i \dR#i;i) z helper for generators -- Throws ValueError if source elements aren't unique. Error message will display (abbreviated) repr of the duplicates in a string/list TF, c3J"TFp\\V44xK R#5iN)reprstrr&words& rr(!_ensure_unique..sB\Tc$i\s!#Nz, ... plus %d others`z%` cannot contain duplicate elements: ) _ensure_unique_cacher+ isinstance _set_typesr*setaddsortedjoinr?) r/paramcachehashableseendupselemtruncdup_reprs && r_ensure_uniquer_s/ !EH ?  &*%%S[)9S[)H   &!  5D 5D4,,T2 $D?caa]tRt^toRtRtRt]tRtR V3Rllt ] R4t ] R4t Rt R RltR t]'d R tR tVtV;t#R tVtV;t#)SequenceGeneratora Base class used by word & phrase generators. These objects take a series of options, corresponding to those of the :func:`generate` function. They act as callables which can be used to generate a password or a list of 1+ passwords. They also expose some read-only informational attributes. Parameters ---------- :param entropy: Optionally specify the amount of entropy the resulting passwords should contain (as measured with respect to the generator itself). This will be used to auto-calculate the required password size. :param length: Optionally specify the length of password to generate, measured as count of whatever symbols the subclass uses (characters or words). Note if ``entropy`` requires a larger minimum length, that will be used instead. :param rng: Optionally provide a custom RNG source to use. Should be an instance of :class:`random.Random`, defaults to :class:`random.SystemRandom`. Attributes ---------- .. autoattribute:: length .. autoattribute:: symbol_count .. autoattribute:: entropy_per_symbol .. autoattribute:: entropy Subclassing ----------- Subclasses must implement the ``.__next__()`` method, and set ``.symbol_count`` before calling base ``__init__`` method. Nrc *<VPfQR4hVfVfhVf VPp\PW4pV^8:d \ R4h\ \ WP, 44pVeW%8dTpWnV^8d \ R4hW nVeW0n V'dJ\V\4\38Xd0\RRPVP44,4h\ \V`F!R/VBR#)Nzsubclass must set .symbol_countz!`entropy` must be positive numberz!`length` must be positive integerzUnexpected keyword(s): %srG) symbol_countrequested_entropyentropy_aliasesgetr?r,rentropy_per_symbollengthrr raobjectr+rVkeyssuper__init__)selfentropyrirkwds min_length __class__s&&&&, rrmSequenceGenerator.__init__s  ,O.OO,  &.00%))';G!| !DEET',C,C"CDEJ~!4#!( A:@A A  ?H M$(9:viG7$))DIIK:PPQ Q /7$7r!c .\VP^4#)zJ Average entropy per symbol (assuming all symbols have equal probability) )r%rdrns&rrh$SequenceGenerator.entropy_per_symbols D%%q))r!c <VPVP,#)a Effective entropy of generated passwords. This value will always be a multiple of :attr:`entropy_per_symbol`. If entropy is specified in constructor, :attr:`length` will be chosen so so that this value is the smallest multiple >= :attr:`requested_entropy`. )rirhrus&rroSequenceGenerator.entropys{{T4444r!c \R4h)z;main generation function, should create one password/phrasezimplement in subclass)NotImplementedErrorrus&r__next__SequenceGenerator.__next__)s!"9::r!c Vf \V4#\V\4'd%\V4Uu.uFp\V4NK up#V\JdV#\ P !VRR4huupi)z> frontend used by genword() / genphrase() to create passwords z, int, or returns)nextrQrr iterr ExpectedTypeError)rnr~_s&& r__call__SequenceGenerator.__call__-sd ?:   + +(.w81DJ8 8 _K''1I9U U 9sA.cV#rIrcrus&r__iter__SequenceGenerator.__iter__:s r!c"VP4#rI)r{rus&rrSequenceGenerator.next>s==? "r!)rirerNNNrI)__name__ __module__ __qualname____firstlineno____doc__rirerrdrmrrhror{rrr r__static_attributes____classdictcell__ __classcell__rr __classdict__s@@rrarasz&XF! CL 8F** 55; V  # # r!razH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZ0123456789abcdef)ascii_72ascii_62ascii_50hexcXaa]tRtRtoRtRtRtR V3Rllt]R4t Rt Rt Vt V;t #) WordGeneratori\a Class which generates passwords by randomly choosing from a string of unique characters. Parameters ---------- :param chars: custom character string to draw from. :param charset: predefined charset to draw from. :param \*\*kwds: all other keywords passed to the :class:`SequenceGenerator` parent class. Attributes ---------- .. autoattribute:: chars .. autoattribute:: charset .. autoattribute:: default_charsets rNc  <V'dV'd \R4hM+V'gVPpV'gQh\V,pW n\VRR7p\ VRR7Wn\ \V`"!R/VBR#)z,`chars` and `charset` are mutually exclusivecharsrWNrc) r+charsetdefault_charsetsrr_rrlrrm)rnrrrprrs&&&,rrmWordGenerator.__init__~so  NOO,,w$W-E 50uG,  mT+3d3r!c,\VP4#rI)r*rrus&rrdWordGenerator.symbol_count4::r!cX\VPVPVP4#rI)rrrrirus&rr{WordGenerator.__next__s$((DJJ <>> # generate a random alphanumeric string with 48 bits of entropy (the default) >>> from passlib import pwd >>> pwd.genword() 'DnBHvDjMK6' >>> # generate a random hexadecimal string with 52 bits of entropy >>> pwd.genword(entropy=52, charset="hex") '310f1a7ac793f' :param entropy: Strength of resulting password, measured in 'guessing entropy' bits. An appropriate **length** value will be calculated based on the requested entropy amount, and the size of the character set. This can be a positive integer, or one of the following preset strings: ``"weak"`` (24), ``"fair"`` (36), ``"strong"`` (48), and ``"secure"`` (56). If neither this or **length** is specified, **entropy** will default to ``"strong"`` (48). :param length: Size of resulting password, measured in characters. If omitted, the size is auto-calculated based on the **entropy** parameter. If both **entropy** and **length** are specified, the stronger value will be used. :param returns: Controls what this function returns: * If ``None`` (the default), this function will generate a single password. * If an integer, this function will return a list containing that many passwords. * If the ``iter`` constant, will return an iterator that yields passwords. :param chars: Optionally specify custom string of characters to use when randomly generating a password. This option cannot be combined with **charset**. :param charset: The predefined character set to draw from (if not specified by **chars**). There are currently four presets available: * ``"ascii_62"`` (the default) -- all digits and ascii upper & lowercase letters. Provides ~5.95 entropy per character. * ``"ascii_50"`` -- subset which excludes visually similar characters (``1IiLl0Oo5S8B``). Provides ~5.64 entropy per character. * ``"ascii_72"`` -- all digits and ascii upper & lowercase letters, as well as some punctuation. Provides ~6.17 entropy per character. * ``"hex"`` -- Lower case hexadecimal. Providers 4 bits of entropy per character. :returns: :class:`!unicode` string containing randomly generated password; or list of 1+ passwords if :samp:`returns={int}` is specified. rirorc)rrorir~rpgens&&&, rgenwordrs&L  ?v ?w ?$ ?C w<r!c\VR4;_uu_4pRV4p\;QJd.RV4FNK 5M !RV44pRRR4\PR\ X4V4V# +'giL2;i)a load wordset from compressed datafile within package data. file should be utf-8 encoded :param asset_path: string containing absolute path to wordset file, or "python.module:relative/file/path". :returns: tuple of words, as loaded from specified words file. zutf-8c3@"TFqP4xK R#5irI)striprLs& rr( _load_wordset..s+zz||sc38"TFq'gK VxK R#5irIrcrLs& rr(rs3stdddss  Nz!loaded %d-element wordset from %r)r9tupler debugr*) asset_pathfhrwordss& r _load_wordsetrse *g . ."++3s33s33 /$II13u:zJ L' / .s 6A55 B cxaa]tRtRtoRtRtRtV3RltRtRt Rt Rt ] R 4t R tR tR tR tVtV;t#) WordsetDictiz Special mapping used to store dictionary of wordsets. Different from a regular dict in that some wordsets may be lazy-loaded from an asset path. NcL</Vn/Vn\\V`!V/VBR#rI)paths_loadedrlrrm)rnargsrprrs&*,rrmWordsetDict.__init__%s%   k4)4848r!cVPV,# \dMi;iTPT,p\T4;q0PT&T#rI)rKeyErrorrr)rnkeyr;r's&& r __getitem__WordsetDict.__getitem__*sP <<$ $   zz#$1$$77 S! s  ##c "W PV&R#)z+ set asset path to lazy-load wordset from. N)r)rnrr;s&&&rset_pathWordsetDict.set_path3s 3r!c"W PV&R#rI)r)rnrr's&&&r __setitem__WordsetDict.__setitem__9s! Sr!cW9d,VPVVPPVR4R#VPVR#rI)rrpoprnrs&&r __delitem__WordsetDict.__delitem__<s0 ; S! JJNN3 % 3r!cf\VP4pVPVP4V#rI)rSrupdater)rnrks& r_keysetWordsetDict._keysetCs%4<<  DJJ r!c,\VP4#rI)rrrus&rrWordsetDict.__iter__IsDLL!!r!c,\VP4#rI)r*rrus&r__len__WordsetDict.__len__Ls4<<  r!cJWP9;'gWP9#rIrrrs&&r __contains__WordsetDict.__contains__Psll"77cZZ&77r!r)rrrrrrrrmrrrrpropertyrrrrrrrrs@@rrrsY EG9  "  "!88r!rz%eff_long eff_short eff_prefixed bip39zpasslib:_data/wordsets/%s.txtc\aa]tRtRtoRtRtRtRtR V3Rllt] R4t Rt R t Vt V;t#) PhraseGeneratori_aclass which generates passphrases by randomly choosing from a list of unique words. :param wordset: wordset to draw from. :param preset: name of preset wordlist to use instead of ``wordset``. :param spaces: whether to insert spaces between words in output (defaults to ``True``). :param \*\*kwds: all other keywords passed to the :class:`SequenceGenerator` parent class. .. autoattribute:: wordset eff_longN c `<VeVe \R4hM'VfVPpV'gQh\V,pWn\V\4'g \ V4p\ VRR7W nVf VPp\VRR7pW0n\\V`2!R/VBR#)Nz,`words` and `wordset` are mutually exclusiverrrDrc) r+wordsetdefault_wordsetsrQ_sequence_typesrr_rrDrrlrrm)rnrrrDrprrs&&&&,rrmPhraseGenerator.__init__~s  " NOO#,,w$W-E %11%LEuG,  ;((CE* ot-55r!c,\VP4#rI)r*rrus&rrdPhraseGenerator.symbol_countrr!cxaV3Rl\SP44pSPPV4#)c3n<"TF*pSPPSP4xK, R#5irI)rchoicer)r&rrns& rr(+PhraseGenerator.__next__..s'J6I,,6Is25)r rirDrV)rnrsf rr{PhraseGenerator.__next__s)JfT[[6IJxx}}U##r!)rDrrr)rrrrrrrrDrmrrdr{rrrrs@@rrr_sC &G E C 6D$$r!rc 0\RRVRV/VBpV!V4#)a]Generate one or more random password / passphrases. This function uses :mod:`random.SystemRandom` to generate one or more passwords; it can be configured to generate alphanumeric passwords, or full english phrases. The complexity of the password can be specified by size, or by the desired amount of entropy. Usage Example:: >>> # generate random phrase with 48 bits of entropy >>> from passlib import pwd >>> pwd.genphrase() 'gangly robbing salt shove' >>> # generate a random phrase with 52 bits of entropy >>> # using a particular wordset >>> pwd.genword(entropy=52, wordset="bip39") 'wheat dilemma reward rescue diary' :param entropy: Strength of resulting password, measured in 'guessing entropy' bits. An appropriate **length** value will be calculated based on the requested entropy amount, and the size of the word set. This can be a positive integer, or one of the following preset strings: ``"weak"`` (24), ``"fair"`` (36), ``"strong"`` (48), and ``"secure"`` (56). If neither this or **length** is specified, **entropy** will default to ``"strong"`` (48). :param length: Length of resulting password, measured in words. If omitted, the size is auto-calculated based on the **entropy** parameter. If both **entropy** and **length** are specified, the stronger value will be used. :param returns: Controls what this function returns: * If ``None`` (the default), this function will generate a single password. * If an integer, this function will return a list containing that many passwords. * If the ``iter`` builtin, will return an iterator that yields passwords. :param words: Optionally specifies a list/set of words to use when randomly generating a passphrase. This option cannot be combined with **wordset**. :param wordset: The predefined word set to draw from (if not specified by **words**). There are currently four presets available: ``"eff_long"`` (the default) Wordset containing 7776 english words of ~7 letters. Constructed by the EFF, it offers ~12.9 bits of entropy per word. This wordset (and the other ``"eff_"`` wordsets) were `created by the EFF `_ to aid in generating passwords. See their announcement page for more details about the design & properties of these wordsets. ``"eff_short"`` Wordset containing 1296 english words of ~4.5 letters. Constructed by the EFF, it offers ~10.3 bits of entropy per word. ``"eff_prefixed"`` Wordset containing 1296 english words of ~8 letters, selected so that they each have a unique 3-character prefix. Constructed by the EFF, it offers ~10.3 bits of entropy per word. ``"bip39"`` Wordset of 2048 english words of ~5 letters, selected so that they each have a unique 4-character prefix. Published as part of Bitcoin's `BIP 39 `_, this wordset has exactly 11 bits of entropy per word. This list offers words that are typically shorter than ``"eff_long"`` (at the cost of slightly less entropy); and much shorter than ``"eff_prefixed"`` (at the cost of a longer unique prefix). :param sep: Optional separator to use when joining words. Defaults to ``" "`` (a space), but can be an empty string, a hyphen, etc. :returns: :class:`!unicode` string containing randomly generated passphrase; or list of 1+ passphrases if :samp:`returns={int}` is specified. rorirc)rrs&&&, r genphrasers&B  A' A& AD AC w<r!)rrrrrI)r/r)=r __future__rrrrr7 collectionsrcollections.abcr ImportErrormathrr r%logging getLoggerrr@r:passlibr passlib.utils.compatr r r r passlib.utilsrrrpasslib.utils.decorr__all__dictrfr r3r9listrrrS frozensetrRrPr_rjrarrrrrrsplitnamerrrrcr!rrsm0SR #+.#g''1 CC551      *" !RX;.-9  u)(\I#I#h WNB  $E=%E=XGZ F98.98|= 4 9 9 ;Dd$Cd$JK < K$'K$dbM+**+sD D'&D'