YV.jwUddlZddlmcmZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlmZmZmZmZmZmZmZmZmZmZddlmZddlmZddlm Z ddl!m"Z"dZ#ejHd ejJejL eee'e(fee'e(ee(efffZ)ee*d <ee)Z+ee*d <Gd de Z,y)N) AnyCallableDictListOptionalSequenceSetTupleTypeUnion) TypeAlias)UnsupportedFeature) BaseProvider) TypesSpecT faker-csv)quoting ColumnSpec DataColumnsceZdZd6dedefdZdeefdZd7dedefdZ d8dede ee ffdZ d8dede ee ffd Z d8dede ee ffd Ze fd ee eej"ge feej"geffde ee ej"ffd Z d9ded edededede f dZ d:dedededee def dZ d:dedededee def dZ d;deeefde dee eeee fdee def dZ dd eed!ed(eed)eee jBdef d*Z" d>d eed!ed(eed)eee jBde f d+Z d?d,ed-ed.ee#d/ee#de f d0Z$d@d ee%d!ed1e de fd2Z&d3e d4ede ee ffd5Z'y)AProviderchance_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 _C:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\faker\providers\misc\__init__.pybooleanzProvider.booleans'~~$$,,Q48NNNc\dddd|jjjddS)zGGenerate ``None``, ``True``, or ``False``, each with equal probability.NTF)rrr&rr)r!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.binary1s_ >> $ $BG-P-QDNN))33C8-DP; zz&!! Qs,A2 raw_outputctjt|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 )hashlibmd5strrrencodedigest hexdigestr!r4ress r"r7z Provider.md5AsN%[[T^^-B-B-I-I-K)L)S)S)UV ::< }}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 )r6sha1r8rrr9r:r;r<s r"r?z Provider.sha1OsN%\\#dnn.C.C.J.J.L*M*T*T*VW ::< }}r$ctjt|jjj j }|r|j S|jS)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 )r6sha256r8rrr9r:r;r<s r"rAzProvider.sha256]sN%^^C0E0E0L0L0N,O,V,V,XY ::< }}r$cast_toctj|jjj dd}|||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!rBgenerated_uuids r"uuid4zProvider.uuid4ksB%)II$..2G2G2S2STW2Xbc$d  >* *r$ special_charsdigits upper_case lower_casecd}g}|r9|j|jjjd|dz }|rU|j|jjjtj |tj z }|rU|j|jjjtj |tj z }|rU|j|jjjtj|tjz }t|}||k} | s9tjd| fd||fdtjvstjtrtjtnddtjvstj|rtj|ndtj|dtjvstj|rtj|nddz} tjd d zd | iz} t!tj"| d x}} |j%|| } t'} t| t|krY| j)|jjj+dt| 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 !@#$%^&*()_+)<=)z0%(py3)s {%(py3)s = %(py0)s(%(py1)s) } <= %(py5)slenrequired_tokensr()py0py1py3py5z3Required length is shorter than required charactersz >assert %(py7)spy7N)r(rr)appendrrchoicestringrNascii_uppercaseascii_lowercaserT @pytest_ar_call_reprcompare @py_builtinslocals_should_repr_global_name _saferepr_format_assertmsgAssertionError_format_explanationrandom_choicessetaddr enumeratejoin)r!r(rMrNrOrPchoicesrU @py_assert2 @py_assert4 @py_format6 @py_format8charsrandom_indexesiindexs r"passwordzProvider.password~s?(   " "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?#d#v-ddd#vddddddsdddsdddddd?ddd?ddd#ddddddvdddvdddd/ddddddd(((@$'5.!C$88   t~~44<>//1C 4DD#1Y5LP]4]#] * $ 5 5 = =mM] ^I%3i%?N .I~~,,Y7##Hd3 7M""$$M""$$s ,B&F++Gctt|t xs|dkt|t xs|dkt|t xs|dkgr td||z|kDr t d|dvrd}n|dvrd}n |dvrd }nd }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~)rrzw:gzrzw:bz2rzw:xzr)rfileobjr)nameN)rrrFrrgrrtarfileopenr,rrr8rr TarInfor3writerTrsizeseekaddfileclose)r!rxryrzr{r tar_bufferr tar_handler file_bufferrrrtarinfors r"tarz Provider.tars4 y#..@)q.}c22Hmq6H0#66P:Kq:P  a  9 $'8 8 Z  . (D , ,D N *DDZZ\ * \\tZ 8J$Q A 6  jjl >>//1C 4DD#1Y5LP]4]#] * $ 5 5 = =mM] ^I%3i%?N .I!//x8~~,,Y7!!$'";#7#7#9:   #""7K8!!## 79&""$$'9&""$$s 3D"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!rrrrPILwidthheightrdrawr1fobjs r"rzProvider.image;sB0 _   eT4>>+?+?CT^+?+_`}}!!%( NSTXTcTcdegiTjNk lNkdooa'F)C DNk 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)rrFrlisttuple TypeErrorrTrStringIOcsvwriterinsertwriterowr,r pystr_formatr8r) r!rrrrrr dsv_bufferrrow_numcolumnrows r"dsvz Provider.dsvfs4J(C(HMDE E,u 6FG G  ftUm4 DEE6{c,// !YZZ[[] JEE9E f a& OOF #Q1 -GEQR\64>>..v6\CR 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)jsonr9)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_selectionrrrj) rentryr definition argumentskwargsitemprocess_list_structurer!s r"rz-Provider.json..process_list_structure:s$&E04,j9)21!&$/#$RSS<7477 MfMMj%0"8"DE$K T3K8NX"Yjd#94&#Aj"YE$K">$">">z"TV"TE$K15L#Zs=B.ci}t|trj|St|tr|j D]z\}}t|t t tfr|Dcgc] }| c}||<;t|ttttfr |||<gj|||<||S|Scc}w)N) rr8rritemsrrrjrFfloatbool)rrrrrprocess_dict_structurer!s r"rz-Provider.json..process_dict_structureNs$&E$$33D99$%(, $D*!*udC.@APZ&[PZ'=d'CPZ&[d #JsE40HI&.create_json_structure`s9,--l;;,--l;;UV Vr$r)rr) rrr rFrrrr8rrrdumpsr,) r!rrrrdefault_data_columnsr r1rrrs ` @@r"rz Provider.jsonsh& ;G,L`  # 3 ( sE4c3h/O)P UX $ WdDj0A Wd W q=::3LA&VYZ Z=B8_M_%l3_Mzz$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)r rrr) xmltodictrrrpydictwordunparse)r!r rrrr_dicts r"rz Provider.xmlos~  ^ %%#!5#' &  $$&.  '' ^$%UW\] ] ^s AA(alignc dddddifg}||}ddd d }g}t|D]}g}|D]f^} } } | r| d ni} t| ts td |j| fi| } |j | |j |d| d| h|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<^>)leftmiddlerightrrrR )r,rrrrr[getrm)r!rrrr  align_maprr1rrrrrresults r" fixed_widthzProvider.fixed_widthsJ  +r* +   ( KK %!yyr$rrc tjd|r|jj|Stjd|r|j dStjd|rh|j d\}}|jj |j}|jj|jfi|S|jj|fi|S)a Formats the string in different ways depending on its contents. The return can be the '@word' itself, a '{{ token }}' passed to PyStr, or a 'provider:argument_group' format field that returns potentially a non-string type. This ensures that Numbers, Boolean types that are generated in the JSON structures in there proper type, and not just strings. z.*\{\{.*\}\}.*z^@.*@z^[a-zA-Z0-9_-]*:\w:) rematchrrlstripsplit get_argumentsstripr)r!rrargument_grouprs r"rz Provider._value_format_selections 88%z 2>>..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)rNrrr3F)Nr5r3F)Nr3NN)r3TNN)Nr3r )(__name__ __module__ __qualname__rFrr#rr'r.r3r r8r7r?rArrHrIrLrwrrr rrrrrrrrr r JSONEncoderrrrrr'rr$r"rrsOcO4O0htn0"S"" d uUCZ/@  t eSj0A   %s 2C  ^a%$))c)9 :Hdii[RWEW(=>PS>ad>ru>@;#;;sTWx;r$r)-builtinsrb_pytest.assertion.rewrite assertionrewriter`rr6rrr/r+r]rrHrtypingrrrrrrr r r r typing_extensionsr faker.exceptionsrrRrpythonr localizedregister_dialectexcel QUOTE_ALLrFr8r__annotations__rrr:r$r"rHs   YYY'/  [#))S]]CeCHouS#tCH~5M/NNO IOj) Y)J ;|J ;r$