ki4dddlZddlZddlmZddlmZmZmZmZm Z m Z m Z ddl m Z ddlmZddlmZmZejdZejd Zejd Zejd Zejd Zejd ZejdZe dZe eeeeeffZGddZGddeZdS)N) OrderedDict)Any CollectionListOptionalSequenceTypeVarUnion) Generator)OrderedDictType)choices_distributionchoices_distribution_unique#%z\$!@z\?z\^TceZdZUdZdZeeed<dZiddddd d d d d ddddddddddddddddddddd d!dd"did#d$d%d&d'd(d)dd*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBidCddDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcidddedfd>dgdhdiddjddkd>dldmdnd5dodpdqddrddsdtdudvdwdxdydzd{d|d}d(id~dddmddddddddddpddddddddddddddddddddidd>ddddddddddadddddddddd5dddddddd1ddddidddddddddddddddd5ddÓddœddǓddɓdd˓dd͓ddÓddddidd(ddӓdddd1ddדddٓdd;ddܓddޓddddddddddddddddaiddדddÓdddddd dddddddddddddddddddd;ddddiddddddd dǓd dhd d-d d dd[dddddddd1dddd7ddMddדddddddd dWddMdmdddd Z d!e d"dfd#Z d"efd$Z d"efd%Z dSd)ed*ed+ed"efd,Zd"efd-Zd"efd.Zd"efd/Zd"eeeffd0Zd"eeeffd1ZdTd2eed3ed"efd4Zd"efd5ZdUd7ed"eefd8Zd"efd9Zd"efd:Z dVdeed"eef d?Z dWd ( (A . . >(00A66 62ric|jjddr |jjddSdS)zGenerate a random non-zero digit (1 to 9) or an empty string. This method will return an empty string 50% of the time, and each digit has a 1/18 chance of being generated. rrtr}rr~rrs rgrandom_digit_not_null_or_emptyz+BaseProvider.random_digit_not_null_or_empty]rridigitsfix_lencl||}|dkrtd|rW|dkrB|jjt d|dz t d|dz Std|jjdt d|dz S)aXGenerate a random integer according to the following rules: - If ``digits`` is ``None`` (default), its value will be set to a random integer from 1 to 9. - If ``fix_len`` is ``False`` (default), all integers that do not exceed the number of ``digits`` can be generated. - If ``fix_len`` is ``True``, only integers with the exact number of ``digits`` can be generated. :sample: fix_len=False :sample: fix_len=True :sample: digits=3 :sample: digits=3, fix_len=False :sample: digits=3, fix_len=True Nrz7The digit parameter must be greater than or equal to 0. rtz=A number of fixed length cannot have less than 1 digit in it.)r ValueErrorrcryrpow)rfrrs rg random_numberzBaseProvider.random_numberis >//11F A::VWW W  Izz~,44SVaZ5H5H#bRX//\]J]^^^ !`aaa>(00CFOOa4GHH Hric||jjttdtjS)z-Generate a random ASCII letter (a-z and A-Z).letters)rcrychoicegetattrstring ascii_lettersrrs rg random_letterzBaseProvider.random_letters,~$++GFIvG[,\,\]]]rilengthcl|ttdtj|S)zwGenerate a list of random ASCII letters (a-z and A-Z) of the specified ``length``. :sample: length=10 rr)random_choicesrrr)rfrs rgrandom_letterszBaseProvider.random_letterss6 "" FIv'; < <#   ricT|jjtjS)z/Generate a random lowercase ASCII letter (a-z).)rcryrrascii_lowercaserrs rgrandom_lowercase_letterz$BaseProvider.random_lowercase_letter ~$++F,BCCCricT|jjtjS)z/Generate a random uppercase ASCII letter (A-Z).)rcryrrascii_uppercaserrs rgrandom_uppercase_letterz$BaseProvider.random_uppercase_letterrriabcelementsunique use_weightingc||n|j}t|tr$t|tst d|rt nt }|-|jj dt|}|r"|t|krt dt|trct|ds&t| |_|j}|r!t|nd}n&|r |jj||S|}d}|t|||jj|S)a Generate a list of randomly sampled objects from ``elements``. Set ``unique`` to ``False`` for random sampling with replacement, and set ``unique`` to ``True`` for random sampling without replacement. If ``length`` is set to ``None`` or is omitted, ``length`` will be set to a random integer from 1 to the size of ``elements``. The value of ``length`` cannot be greater than the number of objects in ``elements`` if ``unique`` is set to ``True``. The value of ``elements`` can be any sequence type (``list``, ``tuple``, ``set``, ``string``, etc) or an ``OrderedDict`` type. If it is the latter, the keys will be used as the objects for sampling, and the values will be used as weighted probabilities if ``unique`` is set to ``False``. For example: .. code-block:: python # Random sampling with replacement fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), # Generates "variable_1" 50% of the time ("variable_2", 0.2), # Generates "variable_2" 20% of the time ("variable_3", 0.2), # Generates "variable_3" 20% of the time ("variable_4": 0.1), # Generates "variable_4" 10% of the time ]), unique=False ) # Random sampling without replacement (defaults to uniform distribution) fake.random_elements( elements=OrderedDict([ ("variable_1", 0.5), ("variable_2", 0.2), ("variable_3", 0.2), ("variable_4": 0.1), ]), unique=True ) :sample: elements=('a', 'b', 'c', 'd'), unique=False :sample: elements=('a', 'b', 'c', 'd'), unique=True :sample: elements=('a', 'b', 'c', 'd'), length=10, unique=False :sample: elements=('a', 'b', 'c', 'd'), length=4, unique=True :sample: elements=OrderedDict([ ("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]), length=20, unique=False :sample: elements=OrderedDict([ ("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]), unique=True NzFUse OrderedDict only to avoid dependency on PYTHONHASHSEED (See #363).rtzOSample length cannot be longer than the number of unique elements to pick from. _key_cacher)__use_weighting__ isinstancedictrrrrrcryrlenhasattrtuplerqrvaluessample)rfrrrrfnchoices probabilitiess rgrandom_elementszBaseProvider.random_elementssm|*7)B H^ h % % gj;.O.O geff f,2 L ( (8L >^*221c(mmDDF  pfs8}},,noo o h % % !8\22 =&+HMMOO&<&<#)G8EOE(//"3"34444MM F~,33HfEEEG Mr 'NN  N !     ric2|||dS)a\Generate a list of objects randomly sampled from ``elements`` with replacement. For information on the ``elements`` and ``length`` arguments, please refer to :meth:`random_elements() ` which is used under the hood with the ``unique`` argument explicitly set to ``False``. :sample: elements=('a', 'b', 'c', 'd') :sample: elements=('a', 'b', 'c', 'd'), length=10 :sample: elements=OrderedDict([ ("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]) :sample: elements=OrderedDict([ ("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]), length=20 Frrrfrrs rgrzBaseProvider.random_choicess4##HfU#CCCric<||ddS)aWGenerate a randomly sampled object from ``elements``. For information on the ``elements`` argument, please refer to :meth:`random_elements() ` which is used under the hood with the ``unique`` argument set to ``False`` and the ``length`` argument set to ``1``. :sample: elements=('a', 'b', 'c', 'd') :sample size=10: elements=OrderedDict([ ("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]) rtrrr)rfrs rgrmzBaseProvider.random_elements""##HQ#77::ric2|||dS)aGenerate a list of objects randomly sampled from ``elements`` without replacement. For information on the ``elements`` and ``length`` arguments, please refer to :meth:`random_elements() ` which is used under the hood with the ``unique`` argument explicitly set to ``True``. :sample: elements=('a', 'b', 'c', 'd', 'e', 'f') :sample: elements=('a', 'b', 'c', 'd', 'e', 'f'), length=3 Trrrs rg random_samplezBaseProvider.random_sample,s##HfT#BBBrirnumberlegec|r|r|S|rdnd}|rdnd}t||jj||zdz }|||kr|}|||kr|}|S)a1Generate a random integer near ``number`` according to the following rules: - If ``le`` is ``False`` (default), allow generation up to 140% of ``number``. If ``True``, upper bound generation is capped at 100%. - If ``ge`` is ``False`` (default), allow generation down to 60% of ``number``. If ``True``, lower bound generation is capped at 100%. - If a numerical value for ``min`` is provided, generated values less than ``min`` will be clamped at ``min``. - If a numerical value for ``max`` is provided, generated values greater than ``max`` will be clamped at ``max``. - If both ``le`` and ``ge`` are ``True``, the value of ``number`` will automatically be returned, regardless of the values supplied for ``min`` and ``max``. :sample: number=100 :sample: number=100, ge=True :sample: number=100, ge=True, min=120 :sample: number=100, le=True :sample: number=100, le=True, max=80 :sample: number=79, le=True, ge=True, min=80 d<)intrcryr) rfrrrrurv_min_maxrs rgrandomize_nb_elementsz"BaseProvider.randomize_nb_elements:s8  " M ssb!ssc $./77dCCCcI J J ?rCxxB ?rCxxB ri###textc4tfd|}tfd|}tfd|}tfd|}t fd|}|S)aJGenerate a string with each placeholder in ``text`` replaced according to the following rules: - Number signs ('#') are replaced with a random digit (0 to 9). - Percent signs ('%') are replaced with a random non-zero digit (1 to 9). - Dollar signs ('$') are replaced with a random digit above two (2 to 9). - Exclamation marks ('!') are replaced with a random digit or an empty string. - At symbols ('@') are replaced with a random non-zero digit or an empty string. Under the hood, this method uses :meth:`random_digit() `, :meth:`random_digit_not_null() `, :meth:`random_digit_or_empty() `, and :meth:`random_digit_not_null_or_empty() ` to generate the random values. :sample: text='Intel Core i%-%%##K vs AMD Ryzen % %%##X' :sample: text='!!! !!@ !@! !@@ @!! @!@ @@! @@@' cFtSN)strrxrfs rgz'BaseProvider.numerify..tsc$*;*;*=*=&>&>ricFtSr)rrrs rgrz'BaseProvider.numerify..uc$*D*D*F*F&G&GricFtSr)rrrs rgrz'BaseProvider.numerify..vsS)D)D)F)F%G%GricFtSr)rrrs rgrz'BaseProvider.numerify..wrricFtSr)rrrs rgrz'BaseProvider.numerify..xsC(K(K(M(M$N$Nri)_re_hashsub_re_perc_re_dol_re_excl_re_at)rfrs` rgnumerifyzBaseProvider.numerifyas&||>>>>EE||GGGGNN{{GGGGNN||GGGGNNzzNNNNPTUU riz????rcDtfd|S)aSGenerate a string with each question mark ('?') in ``text`` replaced with a random character from ``letters``. By default, ``letters`` contains all ASCII letters, uppercase and lowercase. :sample: text='Random Identifier: ??????????' :sample: text='Random Identifier: ??????????', letters='ABCDE' c.Srrmrrrfs rgrz%BaseProvider.lexify..sD$7$7$@$@ri)_re_qmrrfrrs` `rglexifyzBaseProvider.lexify{s'zz@@@@@$GGGriz## ??cV||||S)auGenerate a string with each placeholder in ``text`` replaced according to the following rules: - Number signs ('#') are replaced with a random digit (0 to 9). - Percent signs ('%') are replaced with a random non-zero digit (1 to 9). - Dollar signs ('$') are replaced with a random digit above two (2 to 9). - Exclamation marks ('!') are replaced with a random digit or an empty string. - At symbols ('@') are replaced with a random non-zero digit or an empty string. - Question marks ('?') are replaced with a random character from ``letters``. By default, ``letters`` contains all ASCII letters, uppercase and lowercase. Under the hood, this method uses :meth:`numerify() ` and and :meth:`lexify() ` to generate random values for number signs and question marks respectively. :sample: letters='ABCDE' :sample: text='Product Number: ????-########' :sample: text='Product Number: ????-########', letters='ABCDE' :sample: text='Order: ##??-$' )r)rrrs rgbothifyzBaseProvider.bothifys&*{{4==..{@@@ri^^^^upperctjdd|rtfd|S)aGenerate a string with each circumflex ('^') in ``text`` replaced with a random hexadecimal character. By default, ``upper`` is set to False. If set to ``True``, output will be formatted using uppercase hexadecimal characters. :sample: text='MAC Address: ^^:^^:^^:^^:^^:^^' :sample: text='MAC Address: ^^:^^:^^:^^:^^:^^', upper=True Nic.Srrrs rgrz%BaseProvider.hexify..sT%8%8%A%Ari)r hexdigitsr_re_cirr)rfrrrs` @rghexifyzBaseProvider.hexifysM"3B3'  &mmooG{{AAAAA4HHHri)rrsrt)NF)r)rNFN)rN)r)rFFNN)r)rF)*__name__ __module__ __qualname__ __provider__rrr__annotations__rrnrrhrorlrr{rrrr rrboolrrrrrr ElementsTyperrrrmrrrrrrrrrirgrrsYL"Hhsm"""   g g g  g  w   J gKL wMN wOP lQR gST wUV |WX gYZ w[\ w]^ l_` lab gcd wef ggh wij &kl gmn wop wqr wst guv wwx gyz g{| g}~ 2@ wAB gCD gEF lGH  It guv  wd gef lgh gij gkl gmn wop gqr &st wuv lwx gyz g{| |}~ g@ gAB gCD gEF wGH gIJ gKL wMN gOP wQR gST gUV gWX gYZ g[\ g]^ g_` gab lcd gef ggh gij gkl gmn gop gqr gst guv wwx gyz g{| g}~ g@ gAB gCD lEF wGH gIJ gKL gMN gOP wQR wST wUV gWX wYZ g[\ g]^ g_` gab wcd gef ggh gij gkl wmn gop |qr gst wuv |wx  yz g{| g}~ w@ gAB lCD gEF gGH lIJ !KL gMN gOP lQR wST wUV gWX lYZ g[\ g]^ w_` gab lcd gef wgh gij wkl gmn gop &qr lst luv gwx gyz l{| l}~ w@ lAB wCD gEF gGH gIJ wKL lMN wOP gQR gST gUV lWX gYZ g[\ g]^ g_` wab lcd gef&}B###$####       NsNNNN C Cc CC Cc C# C C C C3c3333 3s3333 33333 uS#X     c3h    IIHSMI4ITWIIII8^s^^^^   S (3-    DDDDD DDDDD%4 $(, ] ] q/]  ]  ]  ~ ] ! ] ] ] ] B%4 $DDq/D D ! DDDD8;;|A;Q;;;;(TX C C$Q CCKC= C ! C C C C !! %%% %  % c] % c] % %%%%NSS4"(8L H H3 H# HQT H H H H#*&:NAACACASVAAAA. I I3 I I I I I I I IrircleZdZ d dedeedeeffd ZdeddfdZd d e defd Z xZ S)DynamicProviderN provider_namerrcc |st}t||drt d||_g|_|r||_t|||jdS)a A faker Provider capable of getting a list of elements to randomly select from, instead of using the predefined list of elements which exist in the default providers in faker. :param provider_name: Name of provider, which would translate into the function name e.g. faker.my_fun(). :param elements: List of values to randomly select from :param generator: Generator object. If missing, the default Generator is used. :example: >>>from faker import Faker >>>from faker.providers import DynamicProvider >>>medical_professions_provider = DynamicProvider( >>> provider_name="medical_profession", >>> elements=["dr.", "doctor", "nurse", "surgeon", "clerk"], >>>) >>>fake = Faker() >>>fake.add_provider(medical_professions_provider) >>>fake.medical_profession() "dr." __zBProvider name cannot start with __ as it would be ignored by FakerN) r superrh startswithrrrsetattrget_random_value)rfrrrc __class__s rgrhzDynamicProvider.__init__s< $! I ###  # #D ) ) cabb b*  %$DMmT%:;;;;;rielementrdc:|j|dS)zAdd new element.N)rappend)rfrs rg add_elementzDynamicProvider.add_elements W%%%%%riTrc|jrt|jdkrtd||jd|dS)zReturns a random value for this provider. :param use_weighting: boolean option to use weighting. Defaults to True rz=Elements should be a list of values the provider samples fromrt)rr)rrrr)rfrs rgrz DynamicProvider.get_random_valuesU } ^DM 2 2a 7 7\]] ]##DM!=#YYZ[\\ri)NN)T) rrrrrrrrhrrr __classcell__)rs@rgrrs$(#' *<*<*<4.*<C= *<*<*<*<*<*rs ######LLLLLLLLLLLLLLLLLL!!!!!!$$$$$$RRRRRRRR 2:d   2:d   "*U   2:d   D   E   "*U   GCLLZ]OAuH$==> S IS IS IS IS IS IS IS Il9]9]9]9]9]l9]9]9]9]9]ri