gp:SrSSKJrJrJrJr SSKrSSKJr SSK J r SSK J r Jr SSKr\R""\5rSSKrSSKrSSKJr SSKJrJrJrJr SS KJrJrJr SS K J!r! /S Qr"\#"S S SSSS9r$Sr%Sr&S(Sjr'\(\)4r*\+\,4r-\+"5r.S)Sjr/"SS\05r1\#"SSSSS9r2"SS\15r3S*Sjr4S r5"S!S"\ 5r6\6"5r7S#Rq5Hr9\7Ru\9S$\9-5 M "S%S&\15r;S*S'jr# UHo[US5-v M g7f)r.N)logf).0values r* "_self_info_rate.._sJ6%tE1~56s)len TypeErrorrintvaluessumrr0)sourcesizecountscharr8s r*_self_info_rater>>s 6{ F   |6{F#  a=3J6JJTQ QQ s B BBc:U(a%[R"U5"[U55$[RR U5(a [ US5$URS5up#nU(d[SU<35e[R"X$5$)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)rFencodingpackagesepsubpaths r*rDrDjs)*:4*@AA ww}}TD$ NN3/G' DHKL L  ( ( ::r,cR[nSnX;ag[U[5(d![ [ U55[ U5:XaU(aUR U5 gg[ 5n[ 5nUHnXd;aUOUR U5 M [U5nSn[ U5U:aSnSRSUSU55n[ U5U:aUS[ U5U- -- n[S U<S U<35e![a SnGNf=f![a gf=f) 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# UHn[[U55v M g7fN)reprstrr1words r*r3!_ensure_unique..sB\Tc$i\s!#Nz, ... plus %d others`z%` cannot contain duplicate elements: ) _ensure_unique_cacher6 isinstance _set_typesr5setaddsortedjoinrJ) r:paramcachehashableseendupselemtruncdup_reprs r*_ensure_uniquerls/ !EH ?  &*%%S[)9S[)H   &!  5D 5D4,,T2 $URcS5eUcUc_Uc URn[RX5nUS::a [ S5e[ [ XR- 55nUbX%:aUnXlUS:a [ S5eX lUbX0l U(aD[U[5[4:Xa+[SSRUR55-5e[ [U]F"S0UD6 g) Nzsubclass must set .symbol_countrz!`entropy` must be positive numberr#z!`length` must be positive integerzUnexpected keyword(s): %srT) symbol_countrequested_entropyentropy_aliasesgetrJr7r entropy_per_symbollengthrr+rnobjectr6rckeyssuper__init__)selfentropyrwrkwds min_length __class__s r*r{SequenceGenerator.__init__s  ,O.OO,  &.00%))';G!| !DEET',C,C"CDEJ~!4#!( A:@A A  ?H M$(9:viG7$))DIIK:PPQ Q /7$7r,c.[URS5$)zJ Average entropy per symbol (assuming all symbols have equal probability) r.)r0rrr|s r*rv$SequenceGenerator.entropy_per_symbols D%%q))r,c4URUR-$)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`. )rwrvrs r*r}SequenceGenerator.entropys{{T4444r,c[S5e)z;main generation function, should create one password/phrasezimplement in subclass)NotImplementedErrorrs r*__next__SequenceGenerator.__next__)s!"9::r,cUc [U5$[U[5(a%[U5Vs/sHn[U5PM sn$U[LaU$[ R "USS5es snf)z> frontend used by genword() / genphrase() to create passwords z, int, or returns)nextr^rr iterr ExpectedTypeError)r|r_s r*__call__SequenceGenerator.__call__-sd ?:   + +(.w81DJ8 8 _K''1I9U U 9sA,cU$rVrqrs r*__iter__SequenceGenerator.__iter__:s r,c"UR5$rV)rrs r*rSequenceGenerator.next>s==? "r,)rwrsrNNNrV)__name__ __module__ __qualname____firstlineno____doc__rwrsrrrr{rrvr}rrrr r__static_attributes__ __classcell__rs@r*rnrnsx&XF! CL 8F** 55; V  # # r,rnzH0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*?/>0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2234679abcdefghjkmnpqrstuvwxyzACDEFGHJKMNPQRTUVWXYZ0123456789abcdef)ascii_72ascii_62ascii_50hexcN^\rSrSrSrSrSrS U4Sjjr\S5r Sr Sr U=r $) 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 >U(aU(a [S5eO%U(dURnU(de[UnX l[USS9n[ USS9 Xl[ [U]""S0UD6 g)Nz,`chars` and `charset` are mutually exclusivecharsrdrq) r6charsetrrrlrrzrr{)r|rrr~rs r*r{WordGenerator.__init__~so  NOO,,w$W-E 50uG,  mT+3d3r,c,[UR5$rV)r5rrs r*rrWordGenerator.symbol_count4::r,cX[URURUR5$rV)rrrrwrs r*rWordGenerator.__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. )rwr}rq)rr}rwrr~gens r*rrs!L  ?v ?$ ?C w<r,c[US5nSU5n[SU55nSSS5 [RS[ W5U5 U$!,(df  N0=f)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@# UHoR5v M g7frV)striprYs r*r3 _load_wordset..s+zz||sc36# UHo(dM Uv M g7frVrqrYs r*r3rs3stdddss  Nz!loaded %d-element wordset from %r)rDtupler debugr5) asset_pathfhrwordss r* _load_wordsetrsT *g ."++3s33 /$II13u:zJ L' / .s A A!cn^\rSrSrSrSrSrU4SjrSrSr Sr Sr \ S 5r S rS rS rS rU=r$) 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. NcJ>0Ul0Ul[[U]"U0UD6 grV)paths_loadedrzrr{)r|argsr~rs r*r{WordsetDict.__init__%s%   k4)4848r,cURU$![a Of=fURUn[U5=o0RU'U$rV)rKeyErrorrr)r|keyrFr2s r* __getitem__WordsetDict.__getitem__*sP <<$ $   zz#$1$$77 S! s  c X RU'g)z+ set asset path to lazy-load wordset from. N)r)r|rrFs r*set_pathWordsetDict.set_path3s 3r,c X RU'grV)r)r|rr2s r* __setitem__WordsetDict.__setitem__9s! Sr,c|X;a*URU URRUS5 gURU grV)rrpopr|rs r* __delitem__WordsetDict.__delitem__<s0 ; S! JJNN3 % 3r,cf[UR5nURUR5 U$rV)r`rupdater)r|rys r*_keysetWordsetDict._keysetCs%4<<  DJJ r,c,[UR5$rV)rrrs r*rWordsetDict.__iter__IsDLL!!r,c,[UR5$rV)r5rrs r*__len__WordsetDict.__len__Ls4<<  r,cHXR;=(d XR;$rVrrrs r* __contains__WordsetDict.__contains__Psll"7cZZ&77r,r)rrrrrrrr{rrrrpropertyrrrrrrrs@r*rrsW EG9  "  "!88r,rz%eff_long eff_short eff_prefixed bip39zpasslib:_data/wordsets/%s.txtcR^\rSrSrSrSrSrSrS U4Sjjr\ S5r Sr S r U=r $) 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 >>UbUb [S5eO!UcURnU(de[UnXl[U[5(d [ U5n[ USS9 X lUc URn[USS9nX0l[[U]2"S0UD6 g)Nz,`words` and `wordset` are mutually exclusiverrrOrq) r6wordsetrr^_sequence_typesrrlrrOrrzrr{)r|rrrOr~rs r*r{PhraseGenerator.__init__~s  " NOO#,,w$W-E %11%LEuG,  ;((CE* ot-55r,c,[UR5$rV)r5rrs r*rrPhraseGenerator.symbol_countrr,cx^U4Sj[TR55nTRRU5$)Nc3n># UH*nTRRTR5v M, g7frV)rchoicer)r1rr|s r*r3+PhraseGenerator.__next__..s'J6I,,6Is25)r rwrOrc)r|rs` r*rPhraseGenerator.__next__s)JfT[[6IJxx}}U##r,)rOrrr)rrrrrrrrOr{rrrrrrrs@r*rr_sA &G E C 6D$$r,rc ,[SXS.UD6nU"U5$)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. )r}rwrq)rrs r*rrs!B  A' AD AC w<r,rV)r:r)=r __future__rrrrrB collectionsrcollections.abcr ImportErrormathr r r0logging getLoggerrrKrEpasslibr passlib.utils.compatr r rr passlib.utilsrrrpasslib.utils.decorr__all__dictrtr+r>rDlistrrr` frozensetr_r]rlrxrnrrrrrrsplitnamerrrrqr,r*rsj0SR #+.#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 DD