U Whb@sddlZddlZddlmZddlmZmZmZmZm Z m Z m Z ddl m Z ddlmZddlmZmZedZed Zed Zed Zed Zed ZedZe dZe eeeeeffZGdddZGdddeZdS)N) OrderedDict)Any CollectionListOptionalSequenceTypeVarUnion) Generator)OrderedDictType)choices_distributionchoices_distribution_unique#%z\$!@z\?z\^Tc@seZdZUdZdZeeed<dZddddd d d d d d d ddddd d dddd ddddddddddddd d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1dd2d d dd3dd4d d d5d6d7d8d9dd:d3d;dd?d@dAdBd dCd d dDddEdFdGdHd/dIdJdKdLdd d dMddNdOd dPd d dQdRdSddTdUdVdWdXdYdTddddZd dd[d\dd]d^d d d_d`dad d d/d[dTd;dbddcdddedfdgdddhdiddjd d dkdldVd2ddmd,ddndddodd%d[dpddqdrdsdd*dd%d3dtduddvZ e ddwdxdyZ edzd{d|Z edzd}d~Z deeeedddZedzddZedzddZedzddZeeefdzddZeeefdzddZdeeeedddZedzddZdeeedddZedzddZedzddZdeeeeeeeeedddZdeeeeeedddZ deeedddZ!deeeeeedddZ"deeeeeeeedddZ#deedddZ$de%j&feeedddZ'de%j&feeedddZ(deeedddZ)dS) BaseProviderbaseN__lang__F)DJERET)ZA)GH)r)ES)IN)AEBHrDZEGEHrILrIQJOKMKWLBLYMAMROMPSQASASDSOSSSYTDTNYE)PE)AZr)BY)ZM)r r*)BG)BDr)CNr)FR)BA)r)ADrr>IT)RU)r$)TW)UA)CZ)PL)GB)DK)ATBECHDELILU)MV)BT)GRCY)AGAUr<BWCArHrGHKIErNGNZPHPKSGUSrr:ZW)r^)ARBOCLCOCRCUDOECrGTHNMXNIPAr7PRPYSVr^UYVE)EE)rr>)IR)SN)FI)r[)FO)rVrKr>rN)rA)NLrL)rX)rr)rY)r#)HR)rL)HT)HU)AM)ID)rV)IS)rKrA)JP)GE)KZ)GL)KH)KR)TR)KG)rN)UG)rJrw)CD)LA)LT)LV)MG)rZ)MK)MN)MY)MT)MM)NO)rLrw)NP)rj)NUrZ)AWrJrw)rKE)rr\)ANrCW)AF)BRPT)RO)rBrD)RW)LK)SK)SI)rrrr1)ALML)MERS)ruSE)rTZ)rr)TJ)TH)TM)rRr)r=)UZ)VN)rJ)rK)rW)r=rWr]rC)aaafakamanZapnarasastZaycazbeZbemberbgZbhbZbhobnbobrZbrxbsZbyncaceZckbZcmnZcrhcsZcsbcvcydadeZdoidvdzeleneoeseteufafffiZfilfofrZfurfygagdZgezglgugvhaZhakhehihnehrZhsbhthuhyiaidigikisitiuiwjakakkklkmknkoZkokkskukwkylblgliZlijlnloltlvZlzhZmagmaimgZmhrmimkmlmnZmnimrmsmtmynannbZndsneZnhnZniunlnnnrnsoocomorospaZpapplpsptZquzZrajrorurwsasatscsdseZshssiZsidskslsosqsrssstsvswZszltaZtcytetgthZthetiZtigtktltntrtsttugukZunmuruzveviwaZwaeZwalwoxhyiyoZyuezhzu) generatorreturncCs ||_dS)zc Base class for fake data providers :param generator: `Generator` instance N)r:)selfr:r=Z/var/www/html/arya_register/venvv2/lib/python3.8/site-packages/faker/providers/__init__.py__init__szBaseProvider.__init__)r;cCs |}|d|tj|S)zlocale$szBaseProvider.localecCs|tjS)z/Generate a random i18n language code (e.g. en).)rBrrCkeysr<r=r=r>rA0szBaseProvider.language_coder')minmaxstepr;cCs|jj||d|S)aZGenerate a random integer between two integers ``min`` and ``max`` inclusive while observing the provided ``step`` value. This method is functionally equivalent to randomly sampling an integer from the sequence ``range(min, max + 1, step)``. :sample: min=0, max=15 :sample: min=0, max=15, step=3 rH)r:random randrange)r<rIrJrKr=r=r> random_int5s zBaseProvider.random_intcCs|jjddS)z!Generate a random digit (0 to 9).r r:rLrandintrFr=r=r> random_digitAszBaseProvider.random_digitcCs|jjddS)z*Generate a random non-zero digit (1 to 9).rHrOrPrFr=r=r>random_digit_not_nullFsz"BaseProvider.random_digit_not_nullcCs|jjddS)z1Generate a random digit above value two (2 to 9).r rOrPrFr=r=r>random_digit_above_twoKsz#BaseProvider.random_digit_above_twocCs(|jjddr |jjddSdSdS)zGenerate a random digit (0 to 9) or an empty string. This method will return an empty string 50% of the time, and each digit has a 1/20 chance of being generated. rrHrONrPrFr=r=r>random_digit_or_emptyPsz"BaseProvider.random_digit_or_emptycCs(|jjddr |jjddSdSdS)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. rrHrOrUNrPrFr=r=r>random_digit_not_null_or_empty\sz+BaseProvider.random_digit_not_null_or_empty)digitsfix_lenr;cCsx|dkr|}|dkr td|rZ|dkrP|jjtd|dtd|dStdn|jjdtd|dSdS)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. rHz=A number of fixed length cannot have less than 1 digit in it.)rS ValueErrorr:rLrQpow)r<rXrYr=r=r> random_numberhs$ zBaseProvider.random_numbercCs|jjttdtjS)z-Generate a random ASCII letter (a-z and A-Z).letters)r:rLchoicegetattrstring ascii_lettersrFr=r=r> random_letterszBaseProvider.random_letter)lengthr;cCs|jttdtj|dS)zwGenerate a list of random ASCII letters (a-z and A-Z) of the specified ``length``. :sample: length=10 r^re)random_choicesr`rarb)r<rer=r=r>random_letterss zBaseProvider.random_letterscCs|jjtjS)z/Generate a random lowercase ASCII letter (a-z).)r:rLr_raascii_lowercaserFr=r=r>random_lowercase_lettersz$BaseProvider.random_lowercase_lettercCs|jjtjS)z/Generate a random uppercase ASCII letter (A-Z).)r:rLr_raascii_uppercaserFr=r=r>random_uppercase_lettersz$BaseProvider.random_uppercase_letterabc)elementsreunique use_weightingr;cCs|dk r |n|j}t|tr.t|ts.td|r6tnt}|dkrV|jj dt |}|rn|t |krntdt|trt |dst | |_|j}|rt |nd}n|r|jj||S|}d}|t |||jj|dS)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).rHzOSample length cannot be longer than the number of unique elements to pick from. _key_cacherf)__use_weighting__ isinstancedictrr[rr r:rLrQlenhasattrtuplerErtvaluessample)r<rqrerrrsfnchoicesZ probabilitiesr=r=r>random_elementss.>   zBaseProvider.random_elements)rqrer;cCs|j||ddS)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 Frrrr<rqrer=r=r>rgszBaseProvider.random_choices)rqr;cCs|j|dddS)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), ]) rHrfrr)r<rqr=r=r>rBszBaseProvider.random_elementcCs|j||ddS)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 Trrrr=r=r> random_sample+s zBaseProvider.random_samplerZ)numberlegerIrJr;c Csl|r |r |S|rdnd}|r dnd}t||jj||d}|dk rT||krT|}|dk rh||krh|}|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<N)intr:rLrQ) r<rrrrIrJ_minZ_maxrr=r=r>randomize_nb_elements9s  z"BaseProvider.randomize_nb_elements###)textr;cshtfdd|}tfdd|}tfdd|}tfdd|}tfdd|}|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='!!! !!@ !@! !@@ @!! @!@ @@! @@@' cs tSN)strrRxrFr=r>sz'BaseProvider.numerify..cs tSr)rrSrrFr=r>rtrcs tSr)rrTrrFr=r>rurcs tSr)rrVrrFr=r>rvrcs tSr)rrWrrFr=r>rwr)_re_hashsub_re_perc_re_dol_re_excl_re_at)r<rr=rFr>numerify`s zBaseProvider.numerifyz????)rr^r;cstfdd|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' cs SrrBrr^r<r=r>rrz%BaseProvider.lexify..)_re_qmrr<rr^r=rr>lexifyzs zBaseProvider.lexifyz## ??cCs|j|||dS)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). - 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' )r^)rrrr=r=r>bothifyszBaseProvider.bothify^^^^)rupperr;cs0tjdd|rtfdd|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 Nics Srrrrr=r>rrz%BaseProvider.hexify..)ra hexdigitsr_re_cirr)r<rrr=rr>hexifys zBaseProvider.hexify)rrGrH)NF)rd)rmNFN)rmN)rm)rmN)rZFFNN)r)rF)*__name__ __module__ __qualname__ __provider__rrr__annotations__rurCrr?rDrArrNrRrSrTr rVrWboolr]rcrrhrjrl ElementsTyperrrgrBrrrrarbrrrr=r=r=r>rs       a   ' rcsReZdZd eeeeedfdd ZeddddZd e ed d d Z Z S)DynamicProviderN) provider_namerqr:csP|s t}t||dr(td||_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 superr? startswithr[rrqsetattrget_random_value)r<rrqr: __class__r=r>r?s  zDynamicProvider.__init__)elementr;cCs|j|dS)zAdd new element.N)rqappend)r<rr=r=r> add_elementszDynamicProvider.add_elementT)rsr;cCs2|jrt|jdkrtd|j|jd|ddS)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 fromrH)rers)rqrxr[r)r<rsr=r=r>rsz DynamicProvider.get_random_value)NN)T) rrrrrrrr?rrr __classcell__r=r=rr>rs,r)rera collectionsrtypingrrrrrrr r:r r Zutils.distributionr rcompilerrrrrrrrfloatrrrr=r=r=r>s, $