\jI{`ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZdZej>d ej@ejB eee"e#fee"e#ee#e fffZ$ee$Z%Gd d eZ&y) N) JSONEncoder) AnyCallableDictListLiteralOptionalSequenceSetTupleTypeUnionoverload)UnsupportedFeature) BaseProvider) TypesSpecT faker-csv)quotingceZdZdEdedefdZdeefdZdFdedefdZ e de fdZ e de d defd Z e de d de fd Z dGdedeee ffd Z e de fdZe de d defdZe de d de fdZdGdedeee ffdZe de fdZe de d defdZe de d de fdZdGdedeee ffdZe de fdZe dddej&fdZe deej&ge fde fdZe deej&gefdefdZe fdeeeej&ge feej&geffdeee ej&ffdZ dHdedededed ede f d!Z dId"ed#ed$ed%ee def d&Z dId"ed#ed$ed%ee def d'Z dJd(eeefd)e d*eeeeee fd+ee def d,Z dKd-e d.eee d/ee e fd0ed1ed2ede fd3Z dLd.eee d/ee e fd0ed1ede f d4Z dLd.eee d/ee e fd0ed1ede f d5Z dLd.eee d/ee e fd0ed1ede f d6Z dMd/ee d0ed7eed8ee!e"def d9Z# dMd/ee d0ed7eed8ee!e"de f d:Z$ dNd;edee%de f d?Z&dOd/ee'd0ed@e de fdAZ(dBe dCedeee ffdDZ)y)PProviderchance_of_getting_truereturncT|jjjdd|kS)zGenerate a random boolean value based on ``chance_of_getting_true``. :sample: chance_of_getting_true=25 :sample: chance_of_getting_true=50 :sample: chance_of_getting_true=75 d generatorrandomrandint)selfrs G/root/env/lib/python3.12/site-packages/faker/providers/misc/__init__.pybooleanzProvider.booleans'~~$$,,Q48NNNc\dddd|jjjddS)zGGenerate ``None``, ``True``, or ``False``, each with equal probability.NTF)rrr&rrr!s r" null_booleanzProvider.null_boolean's8  ..   ' 'A . 0 0r$lengthc|jjrFt|Dcgc]'}|jjj d)}}t |St j|Scc}w)zGenerate a random binary blob of ``length`` bytes. If this faker instance has been seeded, performance will be signficiantly reduced, to conform to the seeding. :sample: length=64 )r _is_seededranger randrangebytesosurandom)r!r)_blobs r"binaryzProvider.binary0s^ >> $ $BG-PQDNN))33C8PDP; zz&!! Qs,A2cyNr's r"md5z Provider.md5@sr$ raw_outputTcyr6r7r!r9s r"r8z Provider.md5C7:r$Fcyr6r7r;s r"r8z Provider.md5Fs69r$ctjt|jjj j }|r|j S|jS)a2Generate a random MD5 hash. If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the MD5 hash will be returned. If ``True``, a ``bytes`` object representation will be returned instead. :sample: raw_output=False :sample: raw_output=True )hashlibr8strrrencodedigest hexdigestr!r9ress r"r8z Provider.md5IsN%[[T^^-B-B-I-I-K)L)S)S)UV ::< }}r$cyr6r7r's r"sha1z Provider.sha1Wsr$cyr6r7r;s r"rGz Provider.sha1Zs8;r$cyr6r7r;s r"rGz Provider.sha1]r<r$ctjt|jjj j }|r|j S|jS)a6Generate a random SHA-1 hash. If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-1 hash will be returned. If ``True``, a ``bytes`` object representation will be returned instead. :sample: raw_output=False :sample: raw_output=True )r?rGr@rrrArBrCrDs r"rGz Provider.sha1`sN%\\#dnn.C.C.J.J.L*M*T*T*VW ::< }}r$cyr6r7r's r"sha256zProvider.sha256ns r$cyr6r7r;s r"rLzProvider.sha256qs:=r$cyr6r7r;s r"rLzProvider.sha256ts9* *r$ special_charsdigits upper_case lower_casec&d}g}|r9|j|jjjd|dz }|rU|j|jjjtj |tj z }|rU|j|jjjtj |tj z }|rU|j|jjjtj|tjz }t||ksJd|j||}t} t| t|krY| j|jjjdt|dz t| t|krYt| D] \} } || || <dj|S)aGenerate a random password of the specified ``length``. The arguments ``special_chars``, ``digits``, ``upper_case``, and ``lower_case`` control what category of characters will appear in the generated password. If set to ``True`` (default), at least one character from the corresponding category is guaranteed to appear. Special characters are characters from ``!@#$%^&*()_+``, digits are characters from ``0123456789``, and uppercase and lowercase characters are characters from the ASCII set of letters. :sample: length=12 :sample: length=40, special_chars=False, upper_case=False z !@#$%^&*()_+z3Required length is shorter than required characters)r)rr)appendrrchoicestringraascii_uppercaseascii_lowercaselenrandom_choicessetaddr enumeratejoin) r!r)r`rarbrcchoicesrequired_tokenscharsrandom_indexesiindexs r"passwordzProvider.passwords(   " "4>>#8#8#?#?#O P ~ %G   " "4>>#8#8#?#? #N O v}} $G   " "4>>#8#8#?#?@V@V#W X v-- -G   " "4>>#8#8#?#?@V@V#W X v-- -G?#v-d/dd-(((@$'5.!C$88   t~~44<>//1C 4DD#1Y5LP]4]#] * $ 5 5 = =mM] ^I%3i%?N .I~~,,Y7##Hd3 4 4""$$ 4""$$s ,B&F++Gctt|t xs|dkt|t xs|dkt|t xs|dkgr td||z|kDr t dd}|dvrd}n |dvrd}n|d vrd }t j }|}tj|| 5}td |d zD]} t j } |jjt| z} ||| z |zz } | |kr,|jjj|| } || z }n|} tj| }|jj!| }| j#|t%| j'|_| j+d|j-|| | j/ ddd|j'S#1swY|j'SxYw)aGenerate a bytes object containing a random valid tar file. The number and sizes of files contained inside the resulting archive can be controlled using the following arguments: - ``uncompressed_size`` - the total size of files before compression, 16 KiB by default - ``num_files`` - the number of files archived in resulting zip file, 1 by default - ``min_file_size`` - the minimum size of each file before compression, 4 KiB by default No compression is used by default, but setting ``compression`` to one of the values listed below will use the corresponding compression type. - ``'bzip2'`` or ``'bz2'`` for BZIP2 - ``'lzma'`` or ``'xz'`` for LZMA - ``'gzip'`` or ``'gz'`` for GZIP :sample: uncompressed_size=256, num_files=4, min_file_size=32 :sample: uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2' rr}r~zw|)rrzw|gzrzw|bz2rzw|xz)rfileobjr)nameN)rrrZrrrrtarfileopenr-rrr@rr TarInfor4writerkrsizeseekaddfileclose)r!rxryrzr{r tar_bufferr tar_handler file_bufferrrrtarinfors r"tarz Provider.tars4 y#..@)q.}c22Hmq6H0#66P:Kq:P  a  9 $'8 8 Z 8< . (D , ,D N *DZZ\ * \\tZ 8 $J$Q A 6 $  jjl >>//1C 4DD#1Y5LP]4]#] * $ 5 5 = =mM] ^I%3i%?N .I!//x8~~,,Y7!!$'";#7#7#9:   #""7K8!!## $ $&""$$' $&""$$s 2D"G--Hr image_formathue luminosityc  ddl}ddl}|\}}|jj d||j j||}|jj|} | jt|jddD cgc]&} |jd||jd|f(c} |j j|||j j|| tj5} |j| | | j!d| j#cdddS#t$r tddwxYwcc} w#1swYyxYw) a;Generate an image and draw a random polygon on it using the Python Image Library. Without it installed, this provider won't be functional. Returns the bytes representing the image in a given format. The argument ``size`` must be a 2-tuple containing (width, height) in pixels. Defaults to 256x256. The argument ``image_format`` can be any valid format to the underlying library like ``'tiff'``, ``'jpeg'``, ``'pdf'`` or ``'png'`` (default). Note that some formats need present system libraries prior to building the Python Image Library. Refer to https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html for details. The arguments ``hue`` and ``luminosity`` are the same as in the color provider and are simply forwarded to it to generate both the background and the shape colors. Therefore, you can ask for a "dark blue" image, etc. :sample: size=(2, 2), hue='purple', luminosity='bright', image_format='pdf' :sample: size=(16, 16), hue=[90,270], image_format='ico' rNz-`image` requires the `Pillow` python library.imageRGB)rr )filloutline)format) PIL.Image PIL.ImageDraw ImportErrorrImagenewrcolor ImageDrawDrawpolygonr- random_intrrsaverread) r!rrrrPILwidthheightrdrawr2fobjs r"rzProvider.image`sG0 _   v eT4>>+?+?CT^+?+_`}}!!%( NSTXTcTcdegiTjNk ldooa'F)C D l%%#*%ENN((SZ(H  ZZ\ T JJtLJ 1 IIaL99;   _$%TV]^ ^ _ m  sE +E  4E%E%E.dialectheader data_columnsnum_rowsinclude_row_ids fmtparamsc t|tr|dkr tdt|ttfs t d|Ct|ttfs t dt |t |k7r tdtj}tj|fd|i|}|r0|rt|}|jdd|j|td|dzD]X} |D cgc]} |jj| } } |r| jdt!| |j| Z|j#Scc} w) aGenerate random delimiter-separated values. This method's behavior share some similarities with ``csv.writer``. The ``dialect`` and ``**fmtparams`` arguments are the same arguments expected by ``csv.writer`` to control its behavior, and instead of expecting a file-like object to where output will be written, the output is controlled by additional keyword arguments and is returned as a string. The ``dialect`` argument defaults to ``'faker-csv'`` which is the name of a ``csv.excel`` subclass with full quoting enabled. The ``header`` argument expects a list or a tuple of strings that will serve as the header row if supplied. The ``data_columns`` argument expects a list or a tuple of string tokens, and these string tokens will be passed to :meth:`pystr_format() ` for data generation. Argument Groups are used to pass arguments to the provider methods. Both ``header`` and ``data_columns`` must be of the same length. Example: fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100}) fake.dsv(data_columns=('{{ name }}', '{{ pyint:top_half }}')) The ``num_rows`` argument controls how many rows of data to generate, and the ``include_row_ids`` argument may be set to ``True`` to include a sequential row ID column. :sample: dialect='excel', data_columns=('{{name}}', '{{address}}') :sample: dialect='excel-tab', data_columns=('{{name}}', '{{address}}'), include_row_ids=True :sample: data_columns=('{{name}}', '{{address}}'), num_rows=5, delimiter='$' rz%`num_rows` must be a positive integerz(`data_columns` must be a tuple or a listz"`header` must be a tuple or a listz6`header` and `data_columns` must have matching lengthsrIDr)rrZrlisttuple TypeErrorrkrStringIOcsvwriterinsertwriterowr-r pystr_formatr@r) r!rrrrrr dsv_bufferrrow_numcolumnrows r"dsvz Provider.dsvs8J(C(HMDE E,u 6FG G  ftUm4 DEE6{c,// !YZZ[[] JEE9E f a& OOF #Q1 - !GEQR64>>..v6RCR 1c'l+ OOC  !""$$ Ss;"Ec.|j||||dS)aGenerate random comma-separated values. For more information on the different arguments of this method, please refer to :meth:`dsv() ` which is used under the hood. :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False :sample: header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True ,rrrr delimiterrr!rrrrs r"rz Provider.csv)"xx%+   r$c.|j||||dS)aGenerate random tab-separated values. For more information on the different arguments of this method, please refer to :meth:`dsv() ` which is used under the hood. :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False :sample: header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True  rrrs r"tsvz Provider.tsvs)"xx%+   r$c.|j||||dS)aGenerate random pipe-separated values. For more information on the different arguments of this method, please refer to :meth:`dsv() ` which is used under the hood. :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False :sample: header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True |rrrs r"psvz Provider.psvrr$indentclscH|j||||jS)z Generate random JSON structure and return as bytes. For more information on the different arguments of this method, refer to :meth:`json() ` which is used under the hood. )rrrr)jsonrA)r!rrrrs r" json_byteszProvider.json_bytess%yylXfZ]y^eeggr$c ddd}|r|n|}dttdtf fd dtttt t ttffdtf fd dtt tfdtf fd }|d k(rtj|||| St|Dcgc] }|| }}tj||| Scc}w) a Generate random JSON structure values. Using a dictionary or list of records that is passed as ``data_columns``, define the structure that is used to build JSON structures. For complex data structures it is recommended to use the dictionary format. Data Column Dictionary format: {'key name': 'definition'} The definition can be 'provider', 'provider:argument_group', tokenized 'string {{ provider:argument_group }}' that is passed to the python provider method pystr_format() for generation, or a fixed '@word'. Using Lists, Tuples, and Dicts as a definition for structure. Example: fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100}) fake.json(data_columns={'Name': 'name', 'Score': 'pyint:top_half'}) Data Column List format: [('key name', 'definition', {'arguments'})] With the list format the definition can be a list of records, to create a list within the structure data. For literal entries within the list, set the 'field_name' to None. :param data_columns: specification for the data structure :type data_columns: dict :param num_rows: number of rows the returned :type num_rows: int :param indent: number of spaces to indent the fields :type indent: int :param cls: optional json encoder to use for non-standard objects such as datetimes :type cls: json.JSONEncoder :return: Serialized JSON data :rtype: str :sample: data_columns={'Spec': '@1.0.1', 'ID': 'pyint', 'Details': {'Name': 'name', 'Address': 'address'}}, num_rows=2 :sample: data_columns={'Candidates': ['name', 'name', 'name']}, num_rows=1 :sample: data_columns=[('Name', 'name'), ('Points', 'pyint', {'min_value': 50, 'max_value': 100})], num_rows=1 {{name}} {{address}})r residencyrrcfi}|D]^}}}|r|dni}t|ts td|j|fi|cSt|tr |||<]t|t t fr|Dcgc] }|g c}||<j|fi|||<|Scc}w)Nr,Invalid arguments type. Must be a dictionary)rdictr_value_format_selectionrrrm) rentryr definition argumentskwargsitemprocess_list_structurer!s r"rz-Provider.json..process_list_structure_s$&E04 U,j9)21!&$/#$RSS<7477 MfMMj%0"8"DE$K T3K8NX"Yd#94&#A"YE$K">$">">z"TV"TE$K UL#Zs=B.ci}t|trj|St|tr|j D]z\}}t|t t tfr|Dcgc] }| c}||<;t|ttttfr |||<gj|||<||S|Scc}wr6) rr@rritemsrrrmrZfloatbool)rrrrrprocess_dict_structurer!s r"r z-Provider.json..process_dict_structuress$&E$$33D99$%(, O$D*!*udC.@APZ&['=d'C&[d #JsE40HI&.create_json_structures9,--l;;,--l;;UV Vr$r)rr) r rrrZrrrr@rrrdumpsr-) r!rrrrdefault_data_columnsr r2rr rs ` @@r"rz Provider.json&sh& ;G,L`  # 3 ( sE4c3h/O)P UX $ WdDj0A Wd W q=::3LA&VYZ Z=B8_M%l3MMzz$v377Ns0C nb_elementsvariable_nb_elements value_types allowed_typesc ddl}|jj ||||}|jj |i}|j |S#t$r tddwxYw)a Returns some XML. :nb_elements: number of elements for dictionary :variable_nb_elements: is use variable number of elements for dictionary :value_types: type of dictionary values Note: this provider required xmltodict library installed rNz.`xml` requires the `xmltodict` Python library.xml)rrrr) xmltodictrrrpydictwordunparse)r!rrrrr_dicts r"rz Provider.xmls~  ^ %%#!5#' &  $$&.  '' ^$%UW\] ] ^s AA(alignc dddddifg}||}ddd d }g}t|D]}g}|D]g^} } } | r| d ni} t| ts td |j| fi| } |j | |j |d| d d| i|j d j|dj|S)a Generate random fixed width values. Using a list of tuple records that is passed as ``data_columns``, that defines the structure that will be generated. Arguments within the record are provider specific, and should be a dictionary that will be passed to the provider method. Data Column List format [('field width', 'definition', {'arguments'})] The definition can be 'provider', 'provider:argument_group', tokenized 'string {{ provider:argument_group }}' that is passed to the python provider method pystr_format() for generation, or a fixed '@word'. Using Lists, Tuples, and Dicts as a definition for structure. Argument Groups can be used to pass arguments to the provider methods, but will override the arguments supplied in the tuple record. Example: fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100}) fake.fixed_width(data_columns=[(20, 'name'), (3, 'pyint:top_half')]) :param data_columns: specification for the data structure :type data_columns: list :param num_rows: number of rows the generator will yield :type num_rows: int :param align: positioning of the value. (left, middle, right) :type align: str :return: Serialized Fixed Width data :rtype: str :sample: data_columns=[(20, 'name'), (3, 'pyint', {'min_value': 50, 'max_value': 100})], align='right', num_rows=2 )rrpyint max_valuerN<^>)leftmiddlerightrrre )r-rrrrrfgetrp)r!rrrr  align_maprr2rrrrrresults r" fixed_widthzProvider.fixed_widthsJ  +r* +   (>..z: : 88GZ ($$S) ) 88): 6)3)9)9#)> &J44^5I5I5KLI(4>>(()9)9);IyI I%t~~$$Z:6::r$)2)i)F) TTTT)iriN))r+r+pngNN)rNrrr4F)Nr6r4F)Nr4NN)r4TNN)Nr4r!)*__name__ __module__ __qualname__rZrr#r r(r/r4rr@r8rrrGrLrQr\r]rrwrrr r rrrrrrrr rrrrr DataColumnsr(rr7r$r"rrs`OcO4O0htn0"S"" S :gdm::: 9gen999 d uUCZ/@ c ;wt};;; :wu~:#:: t eSj0A     ==5== <(=>PS>ad>ru>@;#;;sTWx;r$r)'rr?rrr0r,rhrr\rrtypingrrrrrr r r r r rrfaker.exceptionsrrerpythonr localizedregister_dialectexcel QUOTE_ALLrZr@ ColumnSpecr:rr7r$r"rCs   llll/  [#))S]]C5c?E#sDcN*B$CC D : p ;|p ;r$