U )3g1@sddlZddlZddlmZddlZddlZddlZddlZddl Z dZ e e Z dZ ddZddd Zdd d Zdd d ZedZdddZGdddeZdS)N)partialig333333?cCs*t|t|\}}|g||d|gSN)divmodlen)baseZ target_sizeqrr 5/tmp/pip-unpacked-wheel-0fuzq0j6/benchmarks/common.py_multiplicate_sequence#sr *cCs`tj|}d}t||\}}|dkr2||}n||}dt||}t||ks\t|S)z` Generate a random bytes object of size *n*. Note the result might be compressible. ir) nprandom RandomStaterbytesjoinr rAssertionError)nseedrnd base_sizerrresultrr r r get_random_bytes(s   rcCsLtjt||dtjdd@}t|\}}t|ts8tt ||ksHt|S)z= Get a random ASCII-only unicode string of size *n*. rZdtype) r frombufferrZint8codecs ascii_decode isinstancestrrr)rrZarrr_r r r get_random_ascii;s r#csffdd}tj|g}g}t|krb|s8|}t|}t|ddkr"||q"|S)z= Generate a string of random unicode letters (slow). csjdtjdS)Nrsize)randintsys maxunicodetolistr rrr r _get_more_candidatesJsz5_random_unicode_letters.._get_more_candidatesrL) rrrrchrpop unicodedatacategoryappend)rrr+out candidateschr r*r _random_unicode_lettersFs    r5cCs`tjt|d|dtjdd@}tt|}d|}t||ks\t t|t|f|S)z< Get a random non-ASCII unicode string of size *n*. rri) rrrZint16array_1024_random_unicode_lettersrr)rr)rrindicesZ unicode_arrrr r r get_random_unicode^s r;c@seZdZd&ddZddZddZefdd Zed fd d Zefd dZ ed fddZ efddZ ddZ efddZ efddZefddZefddZefddZefdd Zefd!d"Zd#d$Zd%S)'BuiltinsGeneratorr cCstj||_dSr)rrrr)selfrr r r __init__mszBuiltinsGenerator.__init__cCs4t|jjt|dD]\}}||kr|||<qdS)zP Sprinkle *value* entries in list *lst* with likelihood *prob*. r$N) enumeraterZ random_sampler)r=lstprobvalueipr r r sprinklepszBuiltinsGenerator.sprinklecCs|||ddS)zM Sprinkle None entries in list *lst* with likelihood *prob*. N)rE)r=r@rAr r r sprinkle_nonesxsz BuiltinsGenerator.sprinkle_nonescCstt|}||||S)zm Generate a list of Python ints with *none_prob* probability of an entry being None. )listrangerFr=r none_probdatar r r generate_int_list~s  z#BuiltinsGenerator.generate_int_listFcCsJttt|jdd|}t||ks*t|j|||r>tdndd|S)z Generate a list of Python floats with *none_prob* probability of an entry being None (or NaN if *use_nan* is true). ?nanNrB)rGmapfloatruniformrrrEr=rrJZuse_nanrKr r r generate_float_listsz%BuiltinsGenerator.generate_float_listcCs:dd|jdd|D}t||ks*t||||S)zn Generate a list of Python bools with *none_prob* probability of an entry being None. cSsg|]}t|dkqS)g?)bool).0xr r r sz8BuiltinsGenerator.generate_bool_list..rMrN)rrSrrrFrIr r r generate_bool_lists z$BuiltinsGenerator.generate_bool_listcCsLdd|jdd|D}t||ks*t|j|||r@tdndd|S)z Generate a list of Python Decimals with *none_prob* probability of an entry being None (or NaN if *use_nan* is true). cSsg|]}td|qS)z%.9f)decimalDecimal)rWfr r r rYsz;BuiltinsGenerator.generate_decimal_list..rMrNrONrP)rrSrrrEr[r\rTr r r generate_decimal_listsz'BuiltinsGenerator.generate_decimal_listcCs"ddt|D}||||S)zx Generate a list of generic Python objects with *none_prob* probability of an entry being None. cSsg|] }tqSr )object)rWrCr r r rYsz:BuiltinsGenerator.generate_object_list..)rHrFrIr r r generate_object_lists z&BuiltinsGenerator.generate_object_listc Csd}|||}g}t|D]F} |j|} ||kr:|} n|j||d} ||| | | q|||t||kst|S)a  Generate a list of *n* sequences of varying size between *min_size* and *max_size*, with *none_prob* probability of an entry being None. The base material for each sequence is obtained by calling `random_factory()` i')rHrr&r1rFrr) r=Zrandom_factoryrmin_sizemax_sizerJrrrKrCoffr%r r r _generate_varying_sequencess    z-BuiltinsGenerator._generate_varying_sequencescCs|t||||S)zE Generate a list of bytestrings with a fixed *size*. rer)r=rr%rJr r r generate_fixed_binary_lists z,BuiltinsGenerator.generate_fixed_binary_listcCs|t||||S)zn Generate a list of bytestrings with a random size between *min_size* and *max_size*. rfr=rrbrcrJr r r generate_varying_binary_lists z.BuiltinsGenerator.generate_varying_binary_listcCs|t||||S)zp Generate a list of ASCII strings with a random size between *min_size* and *max_size*. )rer#rhr r r generate_ascii_string_lists z,BuiltinsGenerator.generate_ascii_string_listcCs|t||||S)zr Generate a list of unicode strings with a random size between *min_size* and *max_size*. )rer;rhr r r generate_unicode_string_lists z.BuiltinsGenerator.generate_unicode_string_listcCs|t|j|d||||S)zw Generate a list of lists of Python ints with a random size between *min_size* and *max_size*. rJ)rerrLrhr r r generate_int_list_lists z(BuiltinsGenerator.generate_int_list_listcCs0|j||d}dd|D}t||ks,t|S)z Generate a list of tuples with random values. Each tuple has the form `(int value, float value, bool value)` rlcSs4g|],}|dk r,|d|d|dfndqS)Nuvw)get)rWdr r r rYsz9BuiltinsGenerator.generate_tuple_list..)generate_dict_listrr)r=rrJdictsZtuplesr r r generate_tuple_lists z%BuiltinsGenerator.generate_tuple_listc Cs|j||d}|j||d}|j||d}g}tddg}t|||D]`\}} } i} |dk sft|rn|| d<| dk s~t|r| | d<| dk st|r| | d<|| qH|||t ||kst |S)z Generate a list of dicts with random values. Each dict has the form `{'u': int value, 'v': float value, 'w': bool value}` rlTFNrnrorp) rLrUrZ itertoolscyclezipnextr1rFrr) r=rrJZintsZfloatsZboolsrtZ keep_nonesrnrorprrr r r rss"  z$BuiltinsGenerator.generate_dict_listc Csd}|dkr|}nx|dr"d}nh|dr2d}nX|drBd}nH|dkrPd}n:|dr|d }t|d d}|d kstntd |f|d krtt|}n|dkrt}n|dkrtdd}n|d krt|}n~|dkrt}nl|dkrt }nX|dkrt t }n>|dkrZt t dt t dtt dtg}|j|j|j|jt|j|dt|jdddt|jdddt|jdddt|jd dd|j|jd }|||}||fS)z Return a `(arrow type, list)` tuple where the arrow type corresponds to the given logical *type_name*, and the list is a list of *n* random-generated Python objects compatible with the arrow type. N)rVr[asciiunicode int64 list)intZuintr}rRstructbinaryvarying binary fixed binaryrzunrecognized type %r)r}rRrVr[ )rzr{r|rnrorpr$()rbrc) r}rRrVr[rrrzr{r|r~zstruct from tuples) startswithr}r ValueErrorgetattrpaZbool_Z decimal128rstringlist_Zint64r~fieldZfloat64rLrUrZr^rrgrirjrkrmrsru)r=r type_namer%kindtyZ factoriesrKr r r get_type_and_builtinss~            z'BuiltinsGenerator.get_type_and_builtinsN)r )__name__ __module__ __qualname__r>rErFDEFAULT_NONE_PROBrLrUrZr^r`rergrirjrkrmrursrr r r r r<ks2         r<)r )r )r )r )rr[ functoolsrrvr'r/ZnumpyrZpyarrowrZKILOBYTEZMEGABYTErr rr#r5r9r;r_r<r r r r s"