iKjjmddlZddlmZddlmZddlmZmZddl m Z ddl m Z ddl mZddlmZmZdd lmZdd lmZmZgd Zeed fZeezdzezZeezdzZeezezZeezZeeed fzZ Gd deZ!edZ"edZ#dZ$edZ%eddddddededzdededzdejLef dZ'eddddedededzdejLeed ffdZ(edddddd edededzdededzdejLef d!Z)d"Z*d#e*d$e*d%Z+e+d$e+d&Z,d'e,d(e+d)Z-d'e,d(e,d)Z.Gd*d+eZ/d,Z0eeed-ddddd.d/eezd0ee1zd1edededzdededzdejLe!fd2Z2Gd3d4ejLZ3Gd5d6ejLZ4y)7N) EllipsisType) NamedTuple)assume strategiesInvalidArgument)_calc_p_continue)check_function) check_typecheck_valid_interval)defines_strategy)UniqueIdentifiernot_set)NDIM_MAX_BIE BasicIndexBasicIndexStrategyBroadcastableShapes#MutuallyBroadcastableShapesStrategyShape_BIENoEllipsis_BIENoEllipsisNoNewaxis _BIENoNewaxis array_shapesbroadcastable_shapescheck_argumentcheck_valid_dimsmutually_broadcastable_shapes order_checkvalid_tuple_axes.c,eZdZUeedfed<eed<y)r. input_shapes result_shapeN__name__ __module__ __qualname__tupler__annotations__d/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/extra/_array_helpers.pyrr8s ##r+rc>|st|j|i|yN)rformat) condition fail_messagef_argsf_kwargss r,rr=s( 1l116FXFGG r+c n||kDrtd|d|d|||kDrtd|d|d|d|y)Nmin_z must be at least z but was =z is larger than max_r)namefloorr6max_s r,rrCsY t|TF*= 1). * ``min_dims`` is the smallest length that the generated shape can possess. * ``max_dims`` is the largest length that the generated shape can possess, defaulting to ``min_dims + 2``. * ``min_side`` is the smallest size that a dimension can possess. * ``max_side`` is the largest size that a dimension can possess, defaulting to ``min_side + 5``. r@rBrArCr=rsidemin_sizemax_size) r intrminrrstlistsintegersmapr(r?s r,rr\s"sHj)sHj)Xz*x!|X.sHj)Xz*a<sHj)8X.8X. 88 Hh'(X  c%jr+rIndimrJrKcxttdtt|d|}tt|dtdd||t|ddt j dt ddzdz jfd}t j|||fd  jtS) a All tuples will have a length >= ``min_size`` and <= ``max_size``. The default value for ``max_size`` is ``ndim``. Examples from this strategy shrink towards an empty tuple, which render most sequential functions as no-ops. The following are some examples drawn from this strategy. .. code-block:: pycon >>> [valid_tuple_axes(3).example() for i in range(4)] [(-3, 1), (0, 1, -1), (0, 2), (0, -2, 2)] ``valid_tuple_axes`` can be joined with other strategies to generate any type of valid axis object, i.e. integers, tuples, and ``None``: .. code-block:: python any_axis_strategy = none() | integers(-ndim, ndim - 1) | valid_tuple_axes(ndim) rRrJrKsizerrFr>c"|kr|S|dzz S)NrFr*xrRs r,z"valid_tuple_axes..sq4x!QT\r+c|zSr/r*rVs r,rXz"valid_tuple_axes..s Dr+)rJrK unique_by) r rLrr rNrPmaxrQrOr()rRrJrKaxess` r,r r s8sD&!sHj)sHj)8X.4V< ;;q#aTA. / 3 31 D 88 x(>P  c%jr+shapec tt|dttdtt|dt|dduxs|du}|&t t t ||dzt}tt|dt|dt || dfzdzttdtdd ||td d |r|}d}n|}d}tfd |ddd d|Dstd |d|d|ddcxkrks9ntfd|ddd d|Dstd|d|d|dd |sJtt||ddd dD]*\}} | kr | dk7r|}ndcxkrkr n| kr(|}ntd|||jdS)aReturn a strategy for shapes that are broadcast-compatible with the provided shape. Examples from this strategy shrink towards a shape with length ``min_dims``. The size of an aligned dimension shrinks towards size ``1``. The size of an unaligned dimension shrink towards ``min_side``. * ``shape`` is a tuple of integers. * ``min_dims`` is the smallest length that the generated shape can possess. * ``max_dims`` is the largest length that the generated shape can possess, defaulting to ``max(len(shape), min_dims) + 2``. * ``min_side`` is the smallest size that an unaligned dimension can possess. * ``max_side`` is the largest size that an unaligned dimension can possess, defaulting to 2 plus the size of the largest aligned dimension. The following are some examples drawn from this strategy. .. code-block:: pycon >>> [broadcastable_shapes(shape=(2, 3)).example() for i in range(5)] [(1, 3), (), (2, 3), (2, 1), (4, 1, 3), (3, )] r]rBr@NrFrArCr=rrHc34K|]}|dk7s |kywr>Nr*.0srBs r, z'broadcastable_shapes..sCAFx1}C  z Given shape=9, there are no broadcast-compatible shapes that satisfy: r7 and min_side=r>c3(K|] }|k ywr/r*rbrcrCs r,rdz'broadcastable_shapes..s(S1h(SGiven base_shape=?, there are no broadcast-compatible shapes that satisfy all of , min_side=, and max_side=Fstrict) num_shapes base_shaper@rArBrCc |jdS)Nr)r")rWs r,rXz&broadcastable_shapes.. sANN1%r+)r r(rLrrMr[lenrrallrziprangerrQ) r]r@rArBrC strict_checkr= bound_namenrcs `` r,rrs"@ueW%sHj)sHj)Xz*t#7x4'7Ls3u:x014h?sHj)Xz*uhYZ(H;67!;sHj)8X.8X.   CeDbDk%4&8C C5'"$$.$c,eZdZUeedfed<eed<y) _GUfuncSig.r"r#Nr$r*r+r,rr(r-r+rc tjt|sctjt|rt d|dtjd|rt d|dt dt |dd|j d D\}}t|d k(sJ|d }g||D]:}|D]3} t|jd d |vrt d |d|d5<t||S#t$r~|Dchc]}|D]}|jd ncc}}w}}}|Dchc]}|jd ncc}w} }|jd | |z vrt d|d|ddYwxYw)NzHypothesis does not yet support generalised ufunc signatures with multiple output arrays - mostly because we don't know of anyone who uses them! Please get in touch with us to fix that. (signature=)zd^\((?:\w+(?:,\w+)*)?\)(?:,\((?:\w+(?:,\w+)*)?\))*->\((?:\w+(?:,\w+)*)?\)(?:,\((?:\w+(?:,\w+)*)?\))*$z signature=zQ matches Numpy's regex for gufunc signatures, but contains shapes with more than z dimensions and is thus invalid.z is not a valid gufunc signaturec3pK|].}tdtjt|D0yw)c3bK|]'}ttjt|)ywr/)r(refindall _DIMENSION)rbas r,rdz?_hypothesis_parse_gufunc_signature...Es U1eBJJz1-. Us-/N)r(rr_SHAPE)rbarg_lists r,rdz5_hypothesis_parse_gufunc_signature..Ds.#   U 688T UU#s46r}r>r?zGot dimension z, but handling of frozen optional dimensions is ambiguous. If you known how this should work, please contact us to get this fixed and documented (signature=z).zThe zi dimension only appears in the output shape, and is not frozen, so the size is not determined (signature=r"r#) rmatch _SIGNATURE_SIGNATURE_MULTIPLE_OUTPUTrrsplitrurLstrip ValueErrorr) signaturer" output_shapesr#r]r8shpr{names_in names_outs r,"_hypothesis_parse_gufunc_signaturer-s 88J * 88. :!"!l!%  88E   "9,66>Z?_a  -MNOO#!-#L- }  "" " #L /<..  D DJJsO$$;)(1SHQ|SUW  $ 0C??F D- ,F:E 1FFr*rrrrsr@rArBrCrrrrsc ^d}|tur:t|tu|tt|dt |tsJd}d} n}t|tu|| t dtt |dt|}g|j|j} td| D} t|j}|dkrt d |d tt|d ttd tt|d t|d |du} |)ttt||dzt| z }tt|dt|dt|| dfzdzttdt!dd||t!dd|$|t| z kDrt d|dtd|| r|} d} n|} d } t#fd|dddd| Dst d|d| d| ddcxkrks9nt#fd|dddd| Dst d|d| d| dd | sJt%t'||dddd !D]*\}}|kr |dk7r|}ndcxkrkr n|kr(|}nt)|||||"S)#a[ Return a strategy for a specified number of shapes N that are mutually-broadcastable with one another and with the provided base shape. * ``num_shapes`` is the number of mutually broadcast-compatible shapes to generate. * ``base_shape`` is the shape against which all generated shapes can broadcast. The default shape is empty, which corresponds to a scalar and thus does not constrain broadcasting at all. * ``min_dims`` is the smallest length that the generated shape can possess. * ``max_dims`` is the largest length that the generated shape can possess, defaulting to ``max(len(shape), min_dims) + 2``. * ``min_side`` is the smallest size that an unaligned dimension can possess. * ``max_side`` is the largest size that an unaligned dimension can possess, defaulting to 2 plus the size of the largest aligned dimension. The strategy will generate a :obj:`python:typing.NamedTuple` containing: * ``input_shapes`` as a tuple of the N generated shapes. * ``result_shape`` as the resulting shape produced by broadcasting the N shapes with the base shape. The following are some examples drawn from this strategy. .. code-block:: pycon >>> # Draw three shapes where each shape is broadcast-compatible with (2, 3) ... strat = mutually_broadcastable_shapes(num_shapes=3, base_shape=(2, 3)) >>> for _ in range(5): ... print(strat.example()) BroadcastableShapes(input_shapes=((4, 1, 3), (4, 2, 3), ()), result_shape=(4, 2, 3)) BroadcastableShapes(input_shapes=((3,), (1, 3), (2, 3)), result_shape=(2, 3)) BroadcastableShapes(input_shapes=((), (), ()), result_shape=()) BroadcastableShapes(input_shapes=((3,), (), (3,)), result_shape=(3,)) BroadcastableShapes(input_shapes=((1, 2, 3), (3,), ()), result_shape=(1, 2, 3)) zGPass either the `num_shapes` or the `signature` argument, but not both.rrNrzjExpected a string, but got invalid signature=None. (maybe .signature attribute of an element-wise ufunc?)rc32K|]}t|ywr/)rurbrcs r,rdz0mutually_broadcastable_shapes..s2!s1v2r>z num_shapes=z must be at least 1rsrBr@rFrArCr=rHz max_dims=z would exceed the zD-dimensionlimit Hypothesis imposes on array shapes, given signature=c34K|]}|dk7s |kywr`r*ras r,rdz0mutually_broadcastable_shapes..sHax1}Hrerfrlrgr7rhc3(K|] }|k ywr/r*rjs r,rdz0mutually_broadcastable_shapes..s(X1h(XrkrmrnroFrpr)rrr rL isinstancerstrrr"r#rMrur(rr[rrrvrwrxr)rrrrsr@rArBrCarg_msgparsed_signaturesig_dims all_shapesryr=rzr{rcs `` r,rrds7\XG yG+W53 L1*c***y/9  !I  3 ;/=iHT'44T6F6S6ST 2z22)667 A~ J<7JKLLuj,/sHj)sHj)Xz*4'Ls3z?H598h;NOsHj)Xz*z8)*- ;) super__init__rsrNrP side_stratrrrr@rArBrCsize_one_allowed) selfrrrrsr@rArBrC __class__s r,rz,MutuallyBroadcastableShapesStrategy.__init__su $++h9$"        $  Cdmm C Cr+c (|j|j|S|j|\}}|Dcgc]}d|v}}|j||\}}dtt fdt ||dD||Scc}w)N)usec<td||zt dDS)Nc3&K|] }|| ywr/r*rbrWs r,rdzQMutuallyBroadcastableShapesStrategy.do_draw..add_shape..sOqOs)r(r)loopcores r, add_shapez>MutuallyBroadcastableShapesStrategy.do_draw..add_shapes OTD[8)*$=OO Or+c36K|]\}}||ywr/r*)rbl_incrs r,rdz>MutuallyBroadcastableShapesStrategy.do_draw..s!'.tQ $"sTrpr)r_draw_loop_dimensions_draw_core_dimensionsrr(rw) rdatacore_incore_resrrloop_inloop_resrs @r,do_drawz+MutuallyBroadcastableShapesStrategy.do_draws >> !--d3 3!66t<+223t322 66t6E P#25gwt2T#8X6   3s Bc@i}g}g|jj|jjD]}|jg|D]}|j r|djt |1||vrc|j d}|j|j||<|jdk(r|jds d||dz<n ||||dz<|dj||td|ddDt|dfS)Nrfrrg?c32K|]}t|ywr/)r(rs r,rdzLMutuallyBroadcastableShapesStrategy._draw_core_dimensions..6s3!U1X3r) rr"r#appendisdigitrLrdrawrr@ draw_booleanr()rrr=shapesr]r8dims r,rz9MutuallyBroadcastableShapesStrategy._draw_core_dimensions"sPt~~22PDNN4O4OP .E MM"  .<<>2J%%c$i0t#**S/C $ $// :DI}})$2C2CE2J*.S3Y*.s)S3Yr !!$t*- . .3vcr{33U6":5FFFr+c jddd}t|}tjDcgc]}g}}|#tjDcgc]}d}}n.t |jk(sJt d|DsJj jz }t|dz |}tdj dzD]J} | dz } t || ks|| dk(r|jj} n|| jkr|| } nd} td| g} t|D]\} }| t |kr1jr%|jtj | }n| }j| kr|| xx|j#|zcc<|| sx|j%|t |t |kr|j%|d|ddk7s|| dk(s|d|| <t'|rKn|dt)t+tjg|}t |jk(sJt fd|DsJt fd|DsJt-t/d |Dt/t1| Scc}wcc}w) NrfTc3<K|]}t|tywr/)rboolrs r,rdzLMutuallyBroadcastableShapesStrategy._draw_loop_dimensions..As8qz!T*8rF) desired_avgrKr>c3xK|]1}jt|cxkxrjknc3ywr/)r@rurA)rbrcrs r,rdzLMutuallyBroadcastableShapesStrategy._draw_loop_dimensions..vs*L4==CF;dmm;;Ls7:c3tK|]/}|D](}j|cxkxrjknc*1ywr/)rBrC)rbrHrcrs r,rdzLMutuallyBroadcastableShapesStrategy._draw_loop_dimensions..ws4X4SWXa4==A666X6Xs58c3DK|]}tt|ywr/)r(reversed)rbr]s r,rdzLMutuallyBroadcastableShapesStrategy._draw_loop_dimensions..zsJ%uXe_5Js r)rslistrxrrrurvrAr@r rrrCsorted enumeraterrN sampled_fromrranyr[rQrr(r)rrrrsr#_r_gapp_keep_extending_shape dim_countrdim_side allowed_sidesshape_idr]rHs` r,rz9MutuallyBroadcastableShapesStrategy._draw_loop_dimensions8s__TrT* J' #DOO45"55 ;!&t!78A48C8s8t. ..8C88 88}}t}},!1dQhQU!Vq$--!"34+ Ia-C :*jo.B99T__5CDMM1%c?"Ax=1M#,V#4 6%#l++0E0E99R__]%CDD#D==9,MT%6%67M%NNMx=LL&<(3u:5$++E"I6raL,=,B,1"I S)/ 60s8W+ Z$$Oc#cDOO3Mf3M*N&OP 6{doo---LVLLLLX6XXXX"J6JJx 56  {68s K K)Nr*rNr>Nr/)r%r&r'rrrr __classcell__rs@r,rrs.D, 6G,D r+rc$eZdZfdZdZxZS)rcvt|||_||_||_||_||_||_yr/)rrr]r@rAallow_ellipsis allow_newaxisallow_fewer_indices_than_dims)rr]r@rArrrrs r,rzBasicIndexStrategy.__init__s@      ,*.K*r+cg}|jD]r}|dk(r|jtd#tj| |dz tj |z}|j|j |ttd|D}|jr||jkr||jks#|j tjr|j tjdt|}|j|d|dz }|jrC||jkr4||jkrp|j tjrt|j|cxkxr|jknc|jr|j tjr|j tjdt|x}}|dkDr3||dz tdk(r|dz}|dkDr||dz tdk(r|t|kr6||tdk(r%|dz }|t|kr||tdk(r%t g|||n|j"r|ddtddgk(rn|j tjddrI|j%|ddtddgk(r&|j tjddrIt|dk(r(|j tjr|dSt'|S)Nrr>c3<K|]}t|tywr/)rslice)rbidxs r,rdz-BasicIndexStrategy.do_draw..sCS*S%0Crrf)r]rrrNrPslicesrsumrrAr@booleansruinsertrrEllipsisrpopr()rrresultdim_sizestrategy result_dimsijs r,rzBasicIndexStrategy.do_draws  /H1} eDk*{{H9hl;bii>QQH MM$))H- .  /CFCC   dmm+t}}, "++-0H "++aV56A MM!T " 1 K   dmm+t}}, "++-0H t}} Qc&k/fQi5;&>#*F1QK  / /+%d"3!442;;qRSCT9U +%d"3!442;;qRSCT9U v;!  "++- 8!9 V}r+)r%r&r'rrrrs@r,rrsK((r+r)5rtypesrtypingr hypothesisrrrNhypothesis.errorsr$hypothesis.internal.conjecture.utilsr hypothesis.internal.coverager hypothesis.internal.validationr r %hypothesis.strategies._internal.utilsr hypothesis.utils.conventionsrr__all__r(rLrrrrrrrrrrrrSearchStrategyrr rrr_ARGUMENT_LISTrrrrrrrrr*r+r,rsU /-A7KBB * c3h U{TL(ut#e l* + E$)$ $ * HH UU    ""Dj" " Dj " u ""J ) ))Dj ) uS#X' ))X [' ['['Dj ['  [' Dj ['u['['b *T*] ;84xr*.!F81 - !.!1N3C1E 4Ln*1(/H 3&H #%H H  H Dj HHDjH*+HHVL "*;*;L ^=**=r+