Ei4dSSKrSSKJs Jr SSKrSSKrSSKJ r SSK J r J r J r JrJrJrJr SSKJr SSK Jr SSKJrJr \R0"S5r\R0"S 5r\R0"S 5r\R0"S 5r\R0"S 5r\R0"S 5r\R0"S5r\"S5r \\ \ \\ \!44r""SS5r#"SS\#5r$g)N) OrderedDict)Any CollectionListOptionalSequenceTypeVarUnion) Generator)OrderedDictType)choices_distributionchoices_distribution_unique#%z\$!@z\?z\^Tc\rSrSr%SrSr\\\S'Sr 0SS_SS _S S _S S _SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_S S!_S"S_S#S_0S$S%_S&S'_S(S)_S*S_S+S,_S-S._S/S0_S1S2_S3S4_S5S6_S7S8_S9S:_S;S<_S=S2_S>S?_S@SA_SBSC_E0SDS_SESF_SGSH_SISJ_SKSL_SMSN_SOSP_SQSR_SSST_SUSV_SWSX_SYSZ_S[S\_S]S^_S_S`_SaSb_ScSd_E0SeSf_SgS?_ShSi_SjS_SkS_SlS?_SmSn_SoS6_SpSq_SrS_SsS_StSu_SvSw_SxSy_SzS{_S|S}_S~S)_E0SS_SSn_SS_SS_SS_SS_SSq_SS_SS_SS_SS_SS_SS_SS_SS_SS_SS_E0SS?_SS_SS_SS_SS_SSb_SS_SS_SS_SS_SS6_SS_SS_SS_SS2_SS_SS_E0SS_SS_SS_SS_SS_SS_SS_SS6_SS_SS_SS_SS_SS_SS_SS_SS _SS _E0SS)_SS_SS_SS2_SS_SS_SS<_SS_SS_SS_SS_SS_SS_SS_SS_SS_SSb_E0SS_SS_SS_SS_SS _SS_SS_SS_SS_SS_SS _SS _SS_SGS_GSS<_GSGS_GSS_E0GSS_GSGS_GSGS _GS S_GS Si_GS S._GS GS_GSS\_GSS _GSGS_GSS _GSS2_GSGS_GSS8_GSSN_GSS_GSGS_ES GSGSGSS SXS SNSnGSGS S GS!. Er GS"\ GS#S4GS$jr GS#\4GS%jr GS#\4GS&jrGSMGS'\GS(\GS)\GS#\4GS*jjrGS#\4GS+jrGS#\4GS,jrGS#\4GS-jrGS#\\\44GS.jrGS#\\\44GS/jrGSNGS0\\GS1\GS#\4GS2jjrGS#\4GS3jrGSOGS4\GS#\\4GS5jjrGS#\4GS6jrGS#\4GS7jrGSPGS8\\GS4\\GS9\GS:\\GS#\\4 GS;jjr GSQGS8\\GS4\\GS#\\4GS<jjr!GSRGS8\\GS#\4GS=jjr"GSQGS8\\GS4\\GS#\\4GS>jjr#GSSGS?\GS@\GSA\GS'\\GS(\\GS#\4 GSBjjr$GSTGSC\GS#\4GSDjjr%GSE\&RN4GSC\GSF\GS#\4GSGjjr(GSH\&RN4GSC\GSF\GS#\4GSIjjr)GSUGSC\GSJ\GS#\4GSKjjr*GSLr+g(V BaseProviderbaseN__lang__Faa)DJERETaf)ZAak)GHam)ran)ESapn)INar)AEBHrDZEGEHrILr&IQJOKMKWLBLYMAMROMPSQASASDSOSSSYTDTNYEasastayc)PEaz)AZr&be)BYbem)ZMber)r*r4bg)BGbhbbhobn)BDr&bo)CNr&br)FRbrxbs)BAbyn)rca)ADr$rUITce)RUckb)r.cmn)TWcrh)UAcs)CZcsb)PLcvcy)GBda)DKde)ATBECHDELILUdoidv)MVdz)BTel)GRCYen)AGAUrQBWCArlrjHKIEr&NGNZPHPKSGUSrrJZWKEeo)res)ARBOCLCOCRCUDOECr$GTHNMXNIPArDPRPYSVrUYVEet)EEeu)r$rUfa)IRff)SNfi)FIfil)rfo)FOfr)rrprUrsfur)r\fy)NLrqga)rgdgez)rrglgugvha)rhakhe)r-hihnehr)HRhsb)rqht)HThu)HUhy)AMiaid)IDigik)ris)ISit)rpr\iuiwja)JPka)GEkk)KZkl)GLkm)KHknko)KRkokksku)TRkwky)KGlb)rslg)UGli)rorlijln)CDlo)LAlt)LTlv)LVlzhmagmaimg)MGmhrmi)rmk)MKmlmn)MNmnimrms)MYmt)MTmy)MMnannb)NOnds)rqrne)NPnhn)rniu)NUrnl)AWrornnnrnsoocom)rrorospa)r&rpap)ANr CWplps)AFpt)BRPTquzrajro)ROru)r^rcrw)RWsasatscsdseshssi)LKsidsk)SKsl)SIso)rrrr;sq)ALMLsr)MERSssstsv)rSEsw)rTZszlta)r&r,tcytetg)TJth)THthetitigtk)TMtltntr)r{rtsttug)rSukunmuruz)UZ)VN)ro)rp)r)rSrrra) veviwawaewalwoxhyiyoyuezhzu generatorreturncXlg)zK Base class for fake data providers :param generator: `Generator` instance Nrd)selfrds U/home/mande/repo/quber/.venv/lib/python3.13/site-packages/faker/providers/__init__.py__init__BaseProvider.__init__s #crUR5nUS-UR[RU5-$)z> ( (A . .>>((00A6 6rlcURRRSS5(a&URRRSS5$g)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. rr|rrrrvs rirandom_digit_not_null_or_empty+BaseProvider.random_digit_not_null_or_empty]rrldigitsfix_lenc`UcUR5nUS:a [S5eU(aQUS:a@URRR [ SUS- 5[ SU5S- 5$[S5eURRR S[ SU5S- 5$)aGenerate 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 rz7The digit parameter must be greater than or equal to 0. r|z=A number of fixed length cannot have less than 1 digit in it.)r ValueErrorrdr}rpow)rhrrs ri random_numberBaseProvider.random_numberis >//1F A:VW W z~~,,44SVaZ5H#bRX/\]J]^^ !`aa>>((00CFOa4GH HrlcURRR[[S[R 55$)z-Generate a random ASCII letter (a-z and A-Z).letters)rdr}choicegetattrstring ascii_lettersrvs ri random_letterBaseProvider.random_letters.~~$$++GFIvG[G[,\]]rllengthc\UR[[S[R5US9$)zgGenerate a list of random ASCII letters (a-z and A-Z) of the specified ``length``. :sample: length=10 rr)random_choicesrrr)rhrs rirandom_lettersBaseProvider.random_letterss1 "" FIv';'; <#  rlchURRR[R5$)z/Generate a random lowercase ASCII letter (a-z).)rdr}rrascii_lowercaservs rirandom_lowercase_letter$BaseProvider.random_lowercase_letter%~~$$++F,B,BCCrlchURRR[R5$)z/Generate a random uppercase ASCII letter (A-Z).)rdr}rrascii_uppercaservs rirandom_uppercase_letter$BaseProvider.random_uppercase_letterrrlelementsunique use_weightingcUbUO URn[U[5(a [U[5(d [ S5eU(a[ O[ nUc/URRRS[U55nU(aU[U5:a [ S5e[U[5(a^[US5(d[UR55UlURnU(a[UR55OSnO0U(a%URRR!X5$UnSnU"[U5UURRUS9$)aAGenerate 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).r|zOSample length cannot be longer than the number of unique elements to pick from. _key_cacher)__use_weighting__ isinstancedictrrrrrdr}rlenhasattrtuplerurvaluessample)rhrrrrfnchoices probabilitiess rirandom_elementsBaseProvider.random_elementss"|*7)B H^H^ h % %j;.O.Oef f,2 (8L >^^**221c(mDF fs8},no o h % %8\22&+HMMO&<#))G8EE(//"344M~~,,33HEEG M 'N  NN ! !   rlc"URXSS9$)aGenerate 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 Frrrhrrs rirBaseProvider.random_choicess4##HU#CCrlc(URUSS9S$)aGenerate 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), ]) r|rrr)rhrs rirpBaseProvider.random_elements"##HQ#7::rlc"URXSS9$)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 ri random_sampleBaseProvider.random_sample,s##HT#BBrlnumberlegecU(a U(aU$U(aSOSnU(aSOSn[XRRRXg5-S- 5nUbX:aUnUbX:aUnU$)aGenerate 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<)intrdr}r) rhrrrrxry_min_maxrs rirandomize_nb_elements"BaseProvider.randomize_nb_elements:sh8 "Msbsc ..//77CCcI J ?rxB ?rxB rltextc ^[RU4SjU5n[RU4SjU5n[RU4SjU5n[RU4SjU5n[ RU4SjU5nU$)aGenerate 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='!!! !!@ !@! !@@ @!! @!@ @@! @@@' c6>[TR55$N)strrxrhs ri'BaseProvider.numerify..tsc$*;*;*=&>rlc6>[TR55$r)rrrs rirruc$*D*D*F&Grlc6>[TR55$r)rrrs rirrvsS)D)D)F%Grlc6>[TR55$r)rrrs rirrwrrlc6>[TR55$r)rrrs rirrxsC(K(K(M$Nrl)_re_hashsub_re_perc_re_dol_re_excl_re_at)rhrs` rinumerifyBaseProvider.numerifyas`&||>E||GN{{GN||GNzzNPTU rlz????rc<^^[RUU4SjU5$)a+Generate 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&>TRT5$rrprrrhs rir%BaseProvider.lexify..sD$7$7$@rl)_re_qmrrhrrs` `rilexifyBaseProvider.lexify{szz@$GGrlz## ??c@URURU5US9$)aGenerate 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 ribothifyBaseProvider.bothifys *{{4==.{@@rlupperc^^[RSSmU(aTR5m[R UU4SjU5$)aOGenerate 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&>TRT5$rrrs rir%BaseProvider.hexify..sT%8%8%Arl)r hexdigitsr_re_cirr)rhrrrs` @rihexifyBaseProvider.hexifys7""3B' mmoG{{A4HHrlrg)ri'r|)NF))abcNFN)rN)r)rFFNN)z###)z^^^^F),__name__ __module__ __qualname____firstlineno__ __provider__rrr__annotations__rrqrrjrrrorrrrrr rrboolrrrrrr ElementsTyperrrrprrrrrrrr__static_attributes__rlrirrs L"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###$#    NsN Cc CC Cc C# C3c3 3s3 33 uS#X  c3h IHSMI4ITWI8^s^  S (3- DD DD%4 $(, ] q/]  ]  ]  ~ ] ! ] B%4 $Dq/D D ! D8;|A;Q;(TX C$Q CCKC= C ! C !! %% %  % c] % c] % %NSS4"(8L8L H3 H# HQT H#*&:N:NACACASVA. I3 I I I Irlrct^\rSrSrS S\S\\S\\4U4SjjjrS\SS4S jr SS \ S\4S jjr S r U=r $)DynamicProvideriN provider_namerrdc>U(d [5n[TU] U5 URS5(a [ S5eXl/UlU(aX l[XUR5 g)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 superrj startswithrrrsetattrget_random_value)rhrrrd __class__s rirjDynamicProvider.__init__s^<! I #  # #D ) )ab b* $MT%:%:;rlelementrec:URRU5 g)zAdd new element.N)rappend)rhr!s ri add_elementDynamicProvider.add_elements W%rlrcUR(a[UR5S:Xa [S5eURURSUS9S$)zsReturns 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 fromr|)rr)rrrr)rhrs rir DynamicProvider.get_random_valuesI }}DMM 2a 7\] ]##DMM!=#YZ[\\rl)rr)NN)T)r r rrrrrrrjr$rrr __classcell__)rs@rirrsi$(#' *<*<4.*<C= *<*r5s #LLL!$R ::d  ::d  **U  ::d  D  E  **U  CLZ]OAuH$==> S IS Il9]l9]rl