liK{nddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZdZejd ej ej! eee"e#fee"e#ee#e fffZ$ee$Z%Gd d eZ&dS) N) JSONEncoder) AnyCallableDictListLiteralOptionalSequenceSetTupleTypeUnionoverload)UnsupportedFeature) BaseProvider) TypesSpecT faker-csv)quotingceZdZdPdedefdZdeefdZdQdedefdZ e de fd Z e d e d defd Z e d e d de fdZ dRd edeee ffdZ e de fdZe d e d defdZe d e d de fdZdRd edeee ffdZe de fdZe d e d defdZe d e d de fdZdRd edeee ffdZe de fdZe dddejfdZe deejge fde fdZe deejgefdefdZe fdeeeejge feejgeffdeee ejffdZ dSded ed!ed"ed#ede f d$Z dTd(ed)ed*ed+ee def d,Z dTd(ed)ed*ed+ee def d-Z dUd0eeefd1e d2eeeeee fd3ee def d4Z dVd7e d8eee d9ee e fd:ed;edZ dWd8eee d9ee e fd:ed;ede f d?Z dWd8eee d9ee e fd:ed;ede f d@Z dXd9ee d:edAeedBee!e"def dCZ# dXd9ee d:edAeedBee!e"de f dDZ$ dYdEedFedGee%dHee%de f dIZ&dZd9ee'd:edKe de fdLZ(dMe dNedeee ffdOZ)dS)[Provider2chance_of_getting_truereturncJ|jjdd|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 m/var/www/html/Pagina-Ingenieria-Requisitos/venv/lib/python3.11/site-packages/faker/providers/misc/__init__.pybooleanzProvider.booleans%~$,,Q448NNNcVdddd|jjddS)zGGenerate ``None``, ``True``, or ``False``, each with equal probability.NTF)rrr'rrr"s r# null_booleanzProvider.null_boolean's;   .  ' 'A . . 0 0r%lengthcjjr*fdt|D}t|St j|S)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 cNg|]!}jjd"S))rr randrange).0_r"s r# z#Provider.binary..:s,PPPQDN)33C88PPPr%)r _is_seededrangebytesosurandom)r"r+blobs` r#binaryzProvider.binary0sO > $ PPPP%--PPPD;; z&!!!r%cdSNr(s r#md5z Provider.md5@s#r% raw_outputTcdSr;r<r"r>s r#r=z Provider.md5C7:sr%FcdSr;r<r@s r#r=z Provider.md5Fs69cr%ctjt|jj}|r|S|S)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 )hashlibr=strrr encodedigest hexdigestr"r>ress r#r=z Provider.md5Is\%[T^-B-I-I-K-K)L)L)S)S)U)UVV  ::<< }}r%cdSr;r<r(s r#sha1z Provider.sha1Ws3r%cdSr;r<r@s r#rLz Provider.sha1Zs8;r%cdSr;r<r@s r#rLz Provider.sha1]rAr%ctjt|jj}|r|S|S)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 )rDrLrErr rFrGrHrIs r#rLz Provider.sha1`s\%\#dn.C.J.J.L.L*M*M*T*T*V*VWW  ::<< }}r%cdSr;r<r(s r#sha256zProvider.sha256ns Sr%cdSr;r<r@s r#rQzProvider.sha256qs:=#r%cdSr;r<r@s r#rQzProvider.sha256ts9<r%ctjt|jj}|r|S|S)a:Generate a random SHA-256 hash. If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-256 hash will be returned. If ``True``, a ``bytes`` object representation will be returned instead. :sample: raw_output=False :sample: raw_output=True )rDrQrErr rFrGrHrIs r#rQzProvider.sha256ws\%^C0E0L0L0N0N,O,O,V,V,X,XYY  ::<< }}r%cdSr;r<r(s r#uuid4zProvider.uuid4sCr%cast_toNcdSr;r<r"rWs r#rVzProvider.uuid4s14r%cdSr;r<rYs r#rVzProvider.uuid4sADr%cdSr;r<rYs r#rVzProvider.uuid4sEHSr%ctj|jjdd}| ||S|S)a"Generate a random UUID4 object and cast it to another type if specified using a callable ``cast_to``. By default, ``cast_to`` is set to ``str``. May be called with ``cast_to=None`` to return a full-fledged ``UUID``. :sample: :sample: cast_to=None )intversion)uuidUUIDrr getrandbits)r"rWgenerated_uuids r#rVzProvider.uuid4sI%)I$.2G2S2STW2X2Xbc$d$d$d  7>** *r% special_charsdigits upper_case lower_casec>d}g}|r7||jjd|dz }|rK||jjtj|tjz }|rK||jjtj|tjz }|rK||jjtj|tjz }t||ks Jd| ||}t} t| t|krc| |jj dt|dz t| t|kct| D]\} } || || <d|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)appendrr choicestringrgascii_uppercaseascii_lowercaselenrandom_choicessetaddr! enumeratejoin) r"r+rfrgrhrichoicesrequired_tokenscharsrandom_indexesiindexs r#passwordzProvider.passwords(  &  " "4>#8#?#?#O#O P P P ~ %G  %  " "4>#8#?#? #N#N O O O v} $G  .  " "4>#8#?#?@V#W#W X X X v- -G  .  " "4>#8#?#?@V#W#W X X X v- -G?##v---/d---(((@@$'55.!!C$8$888   t~4<//11C 4D4DD#1Y5LP]4]#] ** $ 5 = =mM] ^ ^I%3i%?NN .I~,,Y77##Hd3333 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4""$$$s3B)F))F-0F-cXtt|t p|dkt|t p|dkt|t p|dkgrtd||z|krt dd}|dvrd}n |dvrd}n|d vrd }t j}|}tj|| 5}td |d zD]!} t j} |j t| z} ||| z |zz } | |kr&|j j || } || z }n|} tj| }|j | }| |t%| |_| d||| | # dddn #1swxYwY|S)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' rrrzw|)rrzw|gzrzw|bz2rzw|xz)rfileobjr)nameN)rrr_rrrrtarfileopenr4rrrEr r!TarInfor9writerqrsizeseekaddfileclose)r"rrrrr tar_bufferr tar_handler file_bufferrrrtarinfors r#tarz Provider.tars4 y#...@)q.}c222Hmq6H0#666P:Kq:P   a  9 $'8 8 8 Z 8< . ( (DD , , ,DD N * *DZ\\ * \tZ 8 8 8 $J$Q A 66 $ $  jll >//11C 4D4DD#1Y5LP]4]#] ** $ 5 = =mM] ^ ^I%3i%?NN .I!/x888~,,Y77!!$'''";#7#7#9#9::   ###""7K888!!##### $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $&""$$$s D7H  HHr.r.pngr image_formathue luminosityc  ddl}ddl}n#t$rtddwxYw|\ |jd|j||}|j |}| fdt dd Dj||j|| tj5}||| |d|cdddS#1swxYwYdS) 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)rrchg|].}ddf/S)r) random_int)r0r1heightr"widths r#r2z"Provider.image..s: l l ldooa''F)C)C D l l lr% )filloutline)format) PIL.Image PIL.ImageDraw ImportErrorrImagenewrcolor ImageDrawDrawpolygonr4rrrsaverread) r"rrrrPILrdrawfobjrrs ` @@r#rzProvider.image`s0 _      _ _ _$%TV]^^ ^ _ eT4>+?+?CT^+?+_+_``}!!%(( l l l l l leTXTcTcdegiTjTjNkNk l l l%%#*%EEN((SZ(HH    Z\\ T JJtLJ 1 1 1 IIaLLL99;;                  s)AEE #E r{{name}} {{address}}dialectheader data_columnsnum_rowsinclude_row_ids fmtparamsc t|tr|dkrtdt|ttfst d|Zt|ttfst dt |t |krtdtj}tj |fd|i|}|r<|r%t|}| dd| |td |d zD]J} fd |D} |r#| dt| | | K|S) 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 listNz"`header` must be a tuple or a listz6`header` and `data_columns` must have matching lengthsrIDrcDg|]}j|Sr<)r pystr_format)r0columnr"s r#r2z Provider.dsv..s)RRR64>..v66RRRr%)rr_rlisttuple TypeErrorrqrStringIOcsvwriterinsertwriterowr4rEr) r"rrrrrr dsv_bufferrrow_numrows ` r#dsvz Provider.dsvsJ(C(( FHMMDEE E,u 66 HFGG G  ftUm44 F DEEE6{{c,//// !YZZZ[]] JEEE9EE  $ 'f a&&& OOF # # #Q1 -- ! !GRRRR\RRRC , 1c'll+++ OOC ""$$$r%c6|||||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%c6|||||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%c6|||||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%indentclscX|||||S)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)jsonrF)r"rrrrs r# json_byteszProvider.json_bytess+yylXfZ]y^^eegggr%c ddd}rn|dttdtf fd dtttt t ttffdtffd dtt tfdtf fd |d kr tj || Sfd t|D}tj ||| S) 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 rr)r residencyrrcfi}|D]^}}}|r|dni}t|tstd|j|fi|cSt|tr|||<kt|t t frfd|D||<j|fi|||<|S)Nr,Invalid arguments type. Must be a dictionaryc(g|]}|gSr<r<)r0itemprocess_list_structures r#r2zAProvider.json..process_list_structure..ns'"Y"Y"Yd#9#94&#A#A"Y"Y"Yr%)rdictr_value_format_selectionrrrs)rentryr definition argumentskwargsr r"s r#r z-Provider.json..process_list_structure_s$&E04 U U,j9)2:1!&$//T#$RSSS<747 MMfMMMMMj%00U"8"8"D"DE$KK T3K88U"Y"Y"Y"Yj"Y"Y"YE$KK">$">z"T"TV"T"TE$KKLr%ci}t|tr|St|tr|D]\}}t|t t tfrfd|D||<9t|ttttfr|||<p|||<|S|S)Nc&g|] }|Sr<r<)r0r process_dict_structures r#r2zAProvider.json..process_dict_structure..|s%&[&[&['='=d'C'C&[&[&[r%) rrErr itemsrrrsr_floatbool)rrrrrr"s r#rz-Provider.json..process_dict_structuress$&E$$$ :33D999$%% (, OO$D*!*udC.@AAO&[&[&[&[PZ&[&[&[d #JsE40HIIO&<&.create_json_structuresX,-- <--l;;;,-- <--l;;;UVV Vr%r)rrc&g|] }Sr<r<)r0r1rrs r#r2z!Provider.json..s%MMM%%l33MMMr%) r rrr_rrrrErr rdumpsr4) r"rrrrdefault_data_columnsrrrr s `` @@@r#rz Provider.json&sWh&  ;G*`,,L`  # 3       ( sE4c3h/O)P UX       $ WdDj0A Wd W W W W W W W q==:33LAA&VYZZZ ZMMMMMU8__MMMz$v37777r% nb_elementsvariable_nb_elements value_types allowed_typesc ddl}n#t$rtddwxYw|j||||}|j|i}||S)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)rrr r!) xmltodictrrrpydictwordunparse)r"rrr r!r$_dicts r#r#z Provider.xmls  ^      ^ ^ ^$%UW\]] ] ^%%#!5#' &   $$&&.  '''s"leftalignc dddddifg}||}ddd d }g}t|D]}g}|D]z^} } } | r| d ni} t| tstd |j| fi| } || ||d| d| {|d |d|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_valuer,N<^>)r)middlerightrr rk )r4rr rrrlgetrv)r"rrr*r align_maprr1rrrrrresults r# fixed_widthzProvider.fixed_widths3J  +r* +   (..z:: : 8GZ ( ( *$$S)) ) 8): 6 6 J)3)9)9#)>)> &J44^5I5I5K5KLLI(4>()9)9););IIyII I%t~$Z::6:::r%)r)r*)F)reTTTT)r~rrN)rrNN)rNrreF)NrreF)NreNN)reTNN)Nrer))*__name__ __module__ __qualname__r_rr$r r)r5r9rrEr=rrrLrQrVrarbrr}rrr r rrrrrrrr rrrrr# DataColumnsr8rr<r%r#rrshOOcO4OOOO0htn0000""S""""" SX :gdm::::X: 9gen9999X9  d uUCZ/@    cX ;wt};;;;X; :wu~:#:::X:  t eSj0A        X  ==5===X= <>(=>PS>ad>ru>>>>@;#;;sTWx;;;;;;r%r)'rrDrrr6r<rnrrarrtypingrrrrrr r r r r rrfaker.exceptionsrrkrpythonr localizedregister_dialectexcel QUOTE_ALLr_rE ColumnSpecrFrr<r%r#rOs   llllllllllllllllllllllllllll//////  [#)S]CCCC5c?E#sDcN*B$CC D : p ;p ;p ;p ;p ;|p ;p ;p ;p ;p ;r%