iKjddlmZmZddlmZddlmZddlmZddlmZm Z m Z ddl m Z m Z mZddlZddlZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZm Z ddl!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z- ddl.m/Z/e1dejdjgdddDdk\Z4dZ5dZ6dZ7dZ8dZ9dZ:dZ;e d>dZ<Gd d!ejzZ>d"Z?e*e+ddejfd#eAd$eAdzd%ejzeBdzd&ejzejfd'ZDe*e+ddddd(ejd)d*ejze'dzd+e d#eAd$eAdzd,eEd%ejzeBdzd&ejzejfd-ZGe+ddddd.ejd/d*ejze'dzd+e d0ejzd1dzd2ejze'dzd,eEd%ejzeBdzd&ejzejfd3ZIed(d.4Gd5d6e e'ZJdddd.d7d8eAeeBzd+e d*ejze'dzd2ejze'dzd,eEd&eKeJe'f d9ZLe+ d>ddd:d;eeJdzdr&*sGSVGs.)r(c"t|tSr!) isinstancer )tzs r%has_constant_offsetr--s b( ##cTtj|jdd|fS)NcBtj|gjSr!)pandasSeriesdtype)r$s r%z-dtype_for_elements_strategy..7s qc*00r.z3hypothesis.extra.pandas.dtype_for_elements_strategy)key)stsharedmap)ss r%dtype_for_elements_strategyr:5s( 99 01 BA F r.c0||s|t|S|Sr!)r:r3valueselementsdraws r%infer_dtype_if_necessaryr@<s }V/9:: Lr.cVd}t|tjr|}nVt|trF tjj j |}t|tjr|}|"tstdtj|S#t$rYywxYw)a*Return a normalised :class:`~pandas.DatetimeTZDtype` if ``dtype`` is a timezone-aware datetime dtype (e.g. ``"datetime64[ns, UTC]"``), else None. Every value in such a column or index shares a single timezone - the only arrangement pandas supports outside of the ``object`` dtype. NzPGenerating timezone-aware datetimes requires pandas >= 2.1, but you have pandas ) r+r1DatetimeTZDtypestrapitypes pandas_dtype TypeError PANDAS_GE_21r __version__)r3tz_dtype converteds r%datetime_tz_dtyperLBsH%//0 E3   ((55e.vsr}}Q/Er.NaT)rPr"rO timedelta64r-r,rWrminr astypeint64maxr6integersr8just)rJdaylohir=rPs @r%tz_default_elementsrdds ==D bnnQ$q$(?? @C8;;'#Y_B x||iQ.??FMMbhhW X x||iQ.??FMMbhhW X [[R $ $%E FF BGGBMM%67 77r.ct|tjr4|jj djj |S|j dj |S)aInterpret a naive datetime64 :class:`~pandas.Series` or :class:`~pandas.Index` as UTC instants and convert it to ``tz``. We build timezone-aware columns from naive ``datetime64[unit]`` values and only attach the timezone at the array level, because constructing them from timezone-aware scalars silently corrupts values near the bounds of the representable range. UTC)r+r1r2dt tz_localize tz_convert)objr,s r%attach_timezonerkzsR#v}}%vv!!%(++66r:: ??5 ! , ,R 00r.c |d n|d |t| dn)td5td d d dddtd5tjj j jrt d  dddttrttrtd d ttrtjjd k(r`turXd d }tt r|dz }t|tt"r|dz }t|t%|ddddtt&j(rtd dt+}||t-|t/|fS||fSt1tdt2}|Dcic]}|j4|c}j7dttr0dtjj4j9nt;tjd|/t=j>}rAt'j@|z}n)'jd k7r fd}|jC|}|J|fS#1swY~xYw#1swY5xYwcc}w)Nr'r>zdtype is not NonezAt least one of z elements or zdtype must be provided.z#isinstance(dtype, CategoricalDtype)z4dtype is categorical, which is currently unsupportedz Passed dtype=zi is a dtype class, please pass in an instance of this class.Otherwise it would be treated as dtype=objectOz is not a valid Pandas dtype.z; To generate valid datetimes, pass `dtype="datetime64[ns]"`z= To generate valid timedeltas, pass `dtype="timedelta64[ns]"`zX We'll treat it as dtype=object for now, but this will be an error in a future version.z 2021-12-31Fr))since has_codemod stacklevelzx is a strategy, but we require a concrete dtype here. See https://stackoverflow.com/q/74355937 for workaround patterns.__subclasses__Tr3c r|y tj|gdS#tttf$r<dd}t d|d|dt |jdjdwxYw) Nr3rzdraw(z elements)zCannot convert = of type z to dtype ) rOarrayrG ValueError OverflowErrorrtype__name__rC)valuenamer3 is_na_dtypeprefixs r%convert_elementz+elements_and_dtype..convert_elementsu} xxu5a88z=9 vhi0%%dV1UIYE{++,JuyykC s #AA3)"rrrr1rDrECategoricalDtypeis_dtyper+rz issubclassrrOr3kindobjectrr rr6SearchStrategyrLrdrQgetattrlistr}getlowerrnpst from_dtypenoner8) r>r3sourceerr_msgrJ_get_subclassestrr~rs ` @@r%elements_and_dtypers ~81xF88!45 & ' }%&vhl6(BYZ  4 5 ::   , , 5 5e <!(NO  = %:e\#BeX< <  %288E?#7#73#>5PVCV"E8#@A eX & T TG!'* * y ) V VG!'* *iS S  %**+eXW W  !'H  &x02H2RR R!!l,r3min_sizemax_sizeuniquer})selfr>r3rrrr} __class__s r%rzValueIndexStrategy.__init__s8          r.c\g}t}tj||j|j|j|jzdz 5}|D]`}|j |j }|jr&||vr|j?|j||j|b dddt|j||j |j }tj||d|j |jS#1swYhxYw)Nr()rr average_sizer<F)r3 tupleize_colsr})setcumanyrrr?r>rraddappendr@r3r1Indexr})rdataresultseenr>_eltr3s r%do_drawzValueIndexStrategy.do_drawsu WW ]]]]--$--71<  #  #ii .;;d{ ) HHSM c" # #)**Vdmm$)) || %u499TYY;O  % # #s A&D""D+)r{ __module__ __qualname__rr __classcell__)rs@r%rrs  r.r rrr}returnct|dt|d|t|tzdg}t||ddt |t j tjt j|||S)aProvides a strategy which generates an :class:`~pandas.Index` whose values are 0, 1, ..., n for some n. Arguments: * min_size is the smallest number of elements the index can have. * max_size is the largest number of elements the index can have. If None it will default to some suitable value based on min_size. * name is the name of the index. If st.none(), the index will have no name. rrrTr}) rr[DEFAULT_MAX_SIZErrr6buildsr1 RangeIndexr_)rrr}s r% range_indexesrsm"Xz*Xz*#33Y?@8ZD4 99V&& Hh(Gd SSr.T)r>r3rrrr}r>r3rc t|dt|dt||ddtt|dt |duxr|du}t ||\}}| |t z}t||||||}|r|jfdS|S)aProvides a strategy for producing a :class:`pandas.Index`. Arguments: * elements is a strategy which will be used to generate the individual values of the index. If None, it will be inferred from the dtype. Note: even if the elements strategy produces tuples, the generated value will not be a MultiIndex, but instead be a normal index whose elements are tuples. * dtype is the dtype of the resulting index. If None, it will be inferred from the elements strategy. At least one of dtype or elements must be provided. * min_size is the minimum number of elements in the index. * max_size is the maximum number of elements in the index. If None then it will default to a suitable small size. If you want larger indexes you should pass a max_size explicitly. * unique specifies whether all of the elements in the resulting index should be distinct. * name is a strategy for strings or ``None``, which will be passed to the :class:`pandas.Index` constructor. rrrNc0t|jSr!rkr,)ixrJs r%r4zindexes..Zsr8;;'Gr.) rrrboolrLrrrr8) r>r3rrrr} localize_tzstrategyrJs @r%indexesr,s@Xz*Xz*8ZDtVX& 'H$&;8t+;K(59OHe..!(E8XvtTH||GHH Or.F)r>r3indexfillrr}rzUnion[Sequence, pandas.Index]rc\ | t}n t|dt duxrdu}t\}| |r|n#|!|jdk(rt t s|tj fd}|r|j fdS|S)aProvides a strategy for producing a :class:`pandas.Series`. Arguments: * elements: a strategy that will be used to generate the individual values in the series. If None, we will attempt to infer a suitable default from the dtype. * dtype: the dtype of the resulting series and may be any value that can be passed to :class:`numpy.dtype`. If None, will use pandas's standard behaviour to infer it from the type of the elements values. Note that if the type of values that comes out of your elements strategy varies, then so will the resulting dtype of the series. With pandas >= 2.1, you may also pass a timezone-aware :class:`~pandas.DatetimeTZDtype` (e.g. ``"datetime64[ns, UTC]"``), in which case every value in the series will share that single timezone. For UTC and other fixed-offset timezones the generated values cover the full range representable at the dtype's resolution - which for coarser units is much wider than ``datetime64[ns]`` - while timezones with a UTC offset that varies over time are limited to years 1-9999. Values include ``NaT`` unless you pass an elements strategy which excludes it. * index: If not None, a strategy for generating indexes for the resulting Series. This can generate either :class:`pandas.Index` objects or any sequence of values (which will be passed to the Index constructor). You will probably find it most convenient to use the :func:`~hypothesis.extra.pandas.indexes` or :func:`~hypothesis.extra.pandas.range_indexes` function to produce values for this argument. * name: is a strategy for strings or ``None``, which will be passed to the :class:`pandas.Series` constructor. Usage: .. code-block:: pycon >>> series(dtype=int).example() 0 -2001747478 1 1153062837 Nrrnc |}t|dkDr<|tjtt|j }nDt |tjtt|j }t j|||St jd|n|t|S)Nr)r3r>shaperr)rr3r}r) lenrarraysrtolistrr1r2r:) r?r result_datar3r>rindex_strategyr}rs r%rzseries..results^$ u:> "KK$!)!%j!% &(# "(%-"%e*!%#) fh  ==ETRVZX X==(9(CD$Z  r.c0t|jSr!r)r9rJs r%r4zseries..soa&Er.) rrrLrrr+rr6 compositer8) r>r3rrrr}rnp_dtyperrrJs `` ``` @@r%seriesr^sx }ug& 'H$&;8t+;K+He<HhN  MMS 5,/\\%%%Nx||EFF 8Or.)slotsfrozenceZdZUdZdZeezdzed<dZe je dzed<dZ e ed<dZe je dzed<dZeed<y) columnaData object for describing a column in a DataFrame. Arguments: * name: the column name, or None to default to the column position. Must be hashable, but can otherwise be any value supported as a pandas column name. * elements: the strategy for generating values in this column, or None to infer it from the dtype. * dtype: the dtype of the column, or None to infer it from the element strategy. At least one of dtype or elements must be provided. * fill: A default value for elements of the column. See :func:`~hypothesis.extra.numpy.arrays` for a full explanation. * unique: If all values in this column should be distinct. Nr}r>r3rFr)r{rr__doc__r}rCr"__annotations__r>r6rrr3r rrrrr.r%rrsd "D#)d !-1Hb#d*1E3)-D"  B $ &-FDr.r)r3r>rrnames_or_numberc t|ttfrdg|z}n t|}|Dcgc]}t |||||c}Scc}w)aA convenience function for producing a list of :class:`column` objects of the same general shape. The names_or_number argument is either a sequence of values, the elements of which will be used as the name for individual column objects, or a number, in which case that many unnamed columns will be created. All other arguments are passed through verbatim to create the columns. N)r}r3r>rr)r+r"floatrr)rr3r>rrnamesns r%columnsrsW"/C<0)-(@_%   AUXDP  sA)rowsrrrc  | tnt|d||- tdtjfd}|S|Jt t |d}gt it|D]}\}}tt|d|dt|}|jd|d}||_ n"|j} t|j|j vrtd |j j#|jt%|j&}|duxr|j(du} t+|j(|j&|\|_} | r | |_|j,|j<|j&  td t/j0|j2|j(|j4||_j7|!tjfd} | Stj fd} | S#t$r>td|d |jd t|jj d dwxYw)aProvides a strategy for producing a :class:`pandas.DataFrame`. Arguments: * columns: An iterable of :class:`column` objects describing the shape of the generated DataFrame. * rows: A strategy for generating a row object. Should generate either dicts mapping column names to values or a sequence mapping column position to the value in that position (note that unlike the :class:`pandas.DataFrame` constructor, single values are not allowed here. Passing e.g. an integer is an error, even if there is only one column). At least one of rows and columns must be provided. If both are provided then the generated rows will be validated against the columns and an error will be raised if they don't match. Caveats on using rows: * In general you should prefer using columns to rows, and only use rows if the columns interface is insufficiently flexible to describe what you need - you will get better performance and example quality that way. * If you provide rows and not columns, then the shape and dtype of the resulting DataFrame may vary. e.g. if you have a mix of int and float in the values for one column in your row entries, the column will sometimes have an integral dtype and sometimes a float. * index: If not None, a strategy for generating indexes for the resulting DataFrame. This can generate either :class:`pandas.Index` objects or any sequence of values (which will be passed to the Index constructor). You will probably find it most convenient to use the :func:`~hypothesis.extra.pandas.indexes` or :func:`~hypothesis.extra.pandas.range_indexes` function to produce values for this argument. Usage: The expected usage pattern is that you use :class:`column` and :func:`columns` to specify a fixed shape of the DataFrame you want as follows. For example the following gives a two column data frame: .. code-block:: pycon >>> from hypothesis.extra.pandas import column, data_frames >>> data_frames([ ... column('A', dtype=int), column('B', dtype=float)]).example() A B 0 2021915903 1.793898e+232 1 1146643993 inf 2 -2096165693 1.000000e+07 If you want the values in different columns to interact in some way you can use the rows argument. For example the following gives a two column DataFrame where the value in the first column is always at most the value in the second: .. code-block:: pycon >>> from hypothesis.extra.pandas import column, data_frames >>> import hypothesis.strategies as st >>> data_frames( ... rows=st.tuples(st.floats(allow_nan=False), ... st.floats(allow_nan=False)).map(sorted) ... ).example() 0 1 0 -3.402823e+38 9.007199e+15 1 -1.562796e-298 5.000000e-01 You can also combine the two: .. code-block:: pycon >>> from hypothesis.extra.pandas import columns, data_frames >>> import hypothesis.strategies as st >>> data_frames( ... columns=columns(["lo", "hi"], dtype=float), ... rows=st.tuples(st.floats(allow_nan=False), ... st.floats(allow_nan=False)).map(sorted) ... ).example() lo hi 0 9.314723e-49 4.353037e+45 1 -9.999900e-01 1.000000e+07 2 -2.152861e+134 -1.069317e-73 (Note that the column dtype must still be specified and will not be inferred from the rows. This restriction may be lifted in future). Combining rows and columns has the following behaviour: * The column names and dtypes will be used. * If the column is required to be unique, this will be enforced. * Any values missing from the generated rows will be provided using the column's fill. * Any values in the row not present in the column specification (if dicts are passed, if there are keys with no corresponding column name, if sequences are passed if there are too many items) will result in InvalidArgument being raised. Nrz1At least one of rows and columns must be providedc}fd}t|dkDr*tj|Dcgc] }| c}|Stj|g}|jdScc}w)NcN}ttj|d|S)Nz draw(row))rrIterable)rr?rs r%rowz+data_frames..rows_only..rows!!$ZFs||V[A!Mr.rr)rr1 DataFramedrop)r?rrrbaserrs` r% rows_onlyzdata_frames..rows_onlysi^," u:>!++E,BqSU,B%PP "++SUG4D99Q<' -CsA5rzcolumns[rNz+Column names must be hashable, but columns[z ].name was rvz, which cannot be hashed.z$duplicate definition of column name zFMust specify a dtype for all columns when combining rows with columns.)rr>rr}c j|}tj|}tdD}Dcgc]}|jjs|}}|r@|D]S}t j tjt|t||j||j<U|Dcic]$}|js|jt&}}tt|D]}|D]}|jr^tdD]E}||j } | ||jvs'||jj#| nt%n||j }  ||jj&|<D]d}|jjr|t9||j|j |j|j||j<ft j:|| } j=D]\} } t?| | | | | <| Scc}wcc}w#t($rY} |jGt+ t,t.t0t2t4t6fst)d| d|jd| d} ~ wwxYw) Nc38K|]}|jdfywr!rr#cs r%r&z9data_frames..just_draw_columns..sI!~Is)rr3)rr3zFailed to add value=z to column z9 with dtype=None. Maybe passing dtype=object would help?)rr3r>rrr) r6r`rris_emptyr1r2rOzerosrrr3r}rrranger>rrilocrxr+rr"rCrrr rritemsrk)r?rlocal_index_strategyrrcolumns_without_fillrirr|errrr}r,rrewritten_columns tz_columnss r%just_draw_columnsz&data_frames..just_draw_columnssy(E#%775> I7HIID0A#T!AFFOOA#T #T#-A#)==s5z@#gg$DL 0DP!qxx PPs5z*"A1"88%*1X)(,QZZ(8#(QVV #<$(L$4$4U$;$) ) !'$($4E"38DL--a0"":' vv#'"6"#''%&ZZ!"#$88 $DL %%d%8F&,,. Ab.vd|R@t  AMm$UQ" * " !wwz %sCx'S8'1&;UHK'(vvh/?%?'"(+ !+ " "s0II6I I :I J2AJ--J2c&|tjtfdD}i}tdD}|r@Dcgc]}|jr t nd}}|d|j |dttD]}tdD]}|}|} t| trodgtz} tD]\} } | |j| | <| D]3} | vst!d| d | d Dcgc]}|jc}d | } |r7d } t#| d D]!\}}| ||vrd} n|j%|#| rt't)t*| d} t| tkDr&t!d|dt| dtt| tkrnt| }|jjrt!d|d|| j-||jt| tkrn| |j.|<t1j3D]\}}t5|||||<|Scc}w#t$rb || | | <nT#t$rH|jjrt!d|d|d||j|| <|| | | <YnwxYwY%wxYwcc}w)Nc 3K|]Y}|jtjtj|j t |j f[yw))r3rrtN)r}r1r2rOrr3r)r#rrs r%r&z3data_frames..assign_rows..$sL  HH177#e*EQWWsAA"rc34K|]}|jywr!)rrs r%r&z3data_frames..assign_rows..2sA!QXXAsrzEmpty fill strategy in z cannot complete row zRow z contains column z not in columns )F)strictTz draw(rows)z contains too many entries. Has z but expected at most )r1rranyrrpoprrr+dict enumerater}KeyErrorrrrziprrrtuplerrrrrk)r?rfills any_uniquerall_seen row_indexr original_rowras_listrk has_duplicaterr|r}r,r column_namesrrrrs @r% assign_rowsz data_frames..assign_rowss(E%%/ FEA/@AAJARSAQXXCE47SSrl*LLNrl*#3u:.8  q7A#':L&C!#t,#'&3/@+A"A$-.?$@ :DAq :-0[  :"%"A 4&5&*3'1B1%H/@Q/R1/R.UUV%X'"!"" &!(- +.xU+K,KD%#| ($}04 % HHUO ,)${5#|DEC3x#&7"88-"<"22R"3xj(>sCT?U>VXc(S):%;;-c#h766??"1"9!?00rr,rfill_forrrr)rrrrcolsrrlabel column_tzrrrr r rrrs ` @@@@r% data_framesrsZ }&ug& <!"UV V\\ ( (";     ugy 1D#&5LJ$$$1611o. G 66>qcOEAFFFE QVV  66\ !!$H "ST T %agg. t+B d0B 1!**agguM H AG!*Jqvv  77?t/!X !**QXXE    #I$$L | I  I V!"" T  T l}G %A!Kvvj $qvv,*?*?)@@Y[ s IAJ r!)P collectionsrrcollections.abcrr dataclassesrrr r typingr r r rrOr1 hypothesisrr6hypothesis.controlrhypothesis.errorsrhypothesis.extrarhypothesis.internal.conjecturerrhypothesis.internal.coveragerrhypothesis.internal.validationrrrr*hypothesis.strategies._internal.strategiesrr%hypothesis.strategies._internal.utilsrrhypothesis.utils.deprecationrpandas.core.arrays.integerr ImportErrorrrIsplitrHr-r:r@rLrQrdrkrrrrrr"rCrrrrrr2rrrrrrrrr.r%r#s0)$!22&& '%-*6> JM97GV%7%7%=%=c%B2A%FGG6Q $ 84 8, 1]]@" **" J *1"'')TTDjT  C$J 'Tv(() T T2 .2*1"'')-#d*- - - Dj -  -  C$J '-v||$- -`.2 )-*1"'')|#d*| | 9:TA|  B $ &| |  C$J '|v}}%||~ e$WR[%6-1)- 8C=( #d*   B $ &    &*6'+c<@*. c f  $c  D8C=0 1D 8c   R 4 ' c v''( ccYLsK::LL